[🤗 강좌 6.9] 블록 단위로 토크나이저 빌딩하기

이전 섹션에서 보았듯이 토큰화는 다음과 같은 단계로 실행됩니다:

• 정규화 (공백이나 악센트 제거, 유니코드 정규화 등과 같이 필요하다고 여겨지는 모든 텍스트 정제 작업)

• 사전 토큰화 (입력을 단어들로 분리)

• 모델을 통한 입력 실행 (사전 토큰화된 단어들을 사용하여 토큰 시퀀스 생성)

• 후처리 (토큰나이저의 특수 토큰 추가, attention mask 및 토큰 유형 ID 생성)

다시 말하지만, 전체 프로세스를 살펴보면 다음과 같습니다:

🤗Tokenizers 라이브러리는 위의 개별 단계에 대해 여러 옵션을 제공할 수 있도록 만들어졌으며, 이러한 옵션들은 목적에 따라 짜맞춰서 활용할 수 있습니다. 이 섹션에서는 섹션 2에서 설명했던 기존 토크나이저에서 새로운 토크나이저를 학습하는 것과는 달리 아예 처음부터 토크나이저를 구축하는 방법을 볼 것입니다. 이를 통해서, 생각할 수 있는 모든 종류의 토크나이저를 만들 수 있습니다!

보다 정확하게 이 라이브러리는 중심에 Tokenizer 클래스를 중심으로 다양한 하부 모듈들이 기능별로 결합된 구성 요소(building blocks)가 결합된 형태로 구축되었습니다:

• normalizers에는 사용할 수 있는 모든 가능한 Normalizer 유형이 포함되어 있습니다(전체 목록은 여기에서 확인하세요).

• pre_tokenizers에는 사용할 수 있는 모든 가능한 유형의 PreTokenizer가 포함되어 있습니다 (전체 목록은 여기에서 확인하세요).

• models에는 BPE, WordPiece 및 Unigram과 같이 사용할 수 있는 다양한 유형의 Model이 포함되어 있습니다(전체 목록은 여기에서 확인하세요).

• trainer에는 말뭉치에서 모델을 훈련하는데 사용할 수 있는 다양한 유형의 Trainer가 모두 포함되어 있습니다(모델 유형당 하나씩, 전체 목록은 여기).

• post_processors에는 사용할 수 있는 다양한 유형의 PostProcessor가 포함되어 있습니다(전체 목록은 여기에서 확인하세요).

• decoders에는 토큰화 출력을 디코딩하는데 사용할 수 있는 다양한 유형의 Decoder가 포함되어 있습니다(전체 목록은 여기에서 확인하세요).

여기에서 구성 요소(building blocks)의 전체 목록을 찾을 수 있습니다.

말뭉치 확보

새로운 토크나이저를 학습하기 위해 작은 텍스트 말뭉치를 사용합니다(예제 실행 시간을 줄이기 위해서). 말뭉치를 획득하는 단계는 이 장의 시작 부분에서 수행한 단계와 유사하지만 이번에는 WikiText-2 데이터셋을 사용합니다:

from datasets import load_dataset


dataset = load_dataset("wikitext", name="wikitext-2-raw-v1", split="train")


def get_training_corpus():
    for i in range(0, len(dataset), 1000):
        yield dataset[i : i + 1000]["text"]

get_training_corpus() 함수는 1,000개의 텍스트 배치(batch)를 생성하는 생성자(generator)이며 토크나이저를 학습하는 데 사용할 것입니다.

🤗Tokenizers는 텍스트 파일에서 직접 학습될 수도 있습니다. 로컬에서 사용할 수 있는 WikiText-2의 모든 텍스트/입력을 포함하는 텍스트 파일을 생성하는 방법은 다음과 같습니다:

with open("wikitext-2.txt", "w", encoding="utf-8") as f:
    for i in range(len(dataset)):
        f.write(dataset[i]["text"] + "\n")

이제 블록 단위로 BERT, GPT-2 및 XLNet 토크나이저를 빌드하는 방법을 보여드리겠습니다. 이 과정에서 각각 WordPiece, BPE 및 Unigram의 세 가지 주요 토큰화 알고리즘 각각의 실제 예시가 제공됩니다. BERT부터 시작하겠습니다!

WordPiece 토크나이저를 처음부터 빌딩하기

🤗Tokenizers 라이브러리를 사용하여 토크나이저를 빌드하려면 먼저 model로 Tokenizer 객체를 인스턴스화한 다음 normalizer, pre_tokenizer, post_processor 및 decoder 속성을 원하는 값으로 설정합니다.

이 예에서는 WordPiece 모델을 사용하여 Tokenizer를 만듭니다:

from tokenizers import (
    decoders,
    models,
    normalizers,
    pre_tokenizers,
    processors,
    trainers,
    Tokenizer,
)

tokenizer = Tokenizer(models.WordPiece(unk_token="[UNK]"))

모델이 이전에 본 적이 없는 문자들을 만났을 때 무엇을 반환할지 알 수 있도록 unk_token을 지정해야 합니다. 여기서 설정할 수 있는 다른 인수에는 모델의 vocab(여기서는 모델을 학습할 것이므로 이것을 설정할 필요가 없습니다)과 각 단어의 최대 길이를 지정하는 max_input_chars_per_word(이 길이보다 더 긴 단어는 분할됨)가 포함됩니다.

토큰화의 첫 번째 단계는 정규화(normalization)입니다. BERT가 널리 사용되기 때문에 BERT에 대해 설정할 수 있는 기본적인 옵션이 포함된 BertNormalizer가 존재합니다. 지정할 수 있는 옵션에는 lowercase, strip_accents 등을 비롯하여, 모든 제어 문자를 제거하고 반복되는 공백을 단일 문자로 바꾸는 clean_text 그리고 한자(Chinese characters) 주위에 공백을 배치하는 handle_chinese_chars가 있습니다. bert-base-uncased 토크나이저를 복제하려면 이 노멀라이저(normalizer)를 설정하면 됩니다:

tokenizer.normalizer = normalizers.BertNormalizer(lowercase=True)

그러나 일반적으로 새로운 토크나이저를 빌드할 때 🤗Tokenizers 라이브러리에 이미 구현된 편리한 노멀라이저에 접근할 수가 없습니다. 따라서 BERT 노멀라이저를 직접 만드는 방법을 살펴보겠습니다. 라이브러리에서는 Lowercase 노멀라이저와 StripAccents 노멀라이저를 제공하며 Sequence를 사용하여 여러 노멀라이저를 구성할 수 있습니다:

tokenizer.normalizer = normalizers.Sequence(
    [normalizers.NFD(), normalizers.Lowercase(), normalizers.StripAccents()]
)

또한 여기서는 NFD 유니코드 노멀라이저를 사용하고 있습니다. 그렇지 않으면, StripAccents 노멀라이저가 악센트가 있는 문자를 제대로 인식하지 못하므로 제대로 동작할 수 없습니다.

이전에 보았듯이 normalize_str() 메서드를 사용하여 주어진 텍스트의 변화 양상을 확인할 수 있습니다:

print(tokenizer.normalizer.normalize_str("Héllò hôw are ü?"))

To go further 유니코드 문자 u"\u0085"가 포함된 문자열에서 위 2가지 노멀라이저를 테스트하면 그 결과가 동일하지 않다는 것을 확실히 알 수 있습니다. normalizers.Sequence 버전을 너무 복잡하게 만들지 않기 위해, clean_text 인수가 기본 동작인 True로 설정될 때, BertNormalizer가 필요로 하는 정규식 대체(Regex replacements)를 포함하지 않았습니다. 그러나 걱정하지 마십시오. 두 개의 normalizer.Replace를 노멀라이저 시퀀스에 추가하여 편한 BertNormalizer를 사용하지 않고도 정확히 동일한 정규화를 얻을 수 있습니다.

다음은 사전 토큰화 단계입니다. 여기서도 우리가 사용할 수 있는 사전 빌드된 BertPreTokenizer가 있습니다:

tokenizer.pre_tokenizer = pre_tokenizers.BertPreTokenizer()

또는 처음부터 빌드할 수 있습니다:

tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()

Whitespace 사전 토크나이저(pre-tokenizer)는 공백은 물론, 문자, 숫자 또는 밑줄 문자가 아닌 모든 문자를 기준으로 텍스트를 분할하므로, 결국은 공백과 구두점으로 분할한다고 볼 수 있습니다:

tokenizer.pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.")

공백만을 기준으로 분할하려면 WhitespaceSplit 사전 토크나이저(pre-tokenizer) 대신 사용해야 합니다:

pre_tokenizer = pre_tokenizers.WhitespaceSplit()
pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.")

노멀라이저와 마찬가지로 Sequence를 사용하여 여러 사전 토크나이저(pre-tokenizer)들을 결합할 수도 있습니다:

pre_tokenizer = pre_tokenizers.Sequence(
    [pre_tokenizers.WhitespaceSplit(), pre_tokenizers.Punctuation()]
)
pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.")

토큰화 파이프라인의 다음 단계는 모델을 통해 입력을 실행하는 것입니다. 이미 초기화 단계에서 모델을 지정하긴 했지만 이제 학습이 필요하며 이를 위해서 WordPieceTrainer가 필요합니다. 🤗Tokenizers에서 트레이너(trainer)를 인스턴스화할 때 기억해야 할 중요한 점은 사용하려는 모든 특수 토큰을 전달해야 한다는 것입니다. 그렇지 않으면 이들 토큰이 학습 코퍼스에 없기 때문에 어휘집(vocabulary)에 추가되지 않습니다:

special_tokens = ["[UNK]", "[PAD]", "[CLS]", "[SEP]", "[MASK]"]
trainer = trainers.WordPieceTrainer(vocab_size=25000, special_tokens=special_tokens)

vocab_size 및 special_tokens를 지정하는 것 외에도 min_frequency(토큰이 vocabulary에 포함되기 위한 최소 출현 빈도)를 설정하거나 continue_subword_prefix(##말고 다른 기호를 사용하려는 경우)를 변경할 수 있습니다.

앞에서 정의한 반복자(iterator)를 사용하여 모델을 학습시키려면 다음 명령을 실행하기만 하면 됩니다:

tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer)

또한 텍스트 파일을 사용하여 토크나이저를 학습할 수 있습니다. 다음처럼 실행하면 됩니다. 미리 비어있는 WordPiece로 모델을 다시 초기화했습니다:

tokenizer.model = models.WordPiece(unk_token="[UNK]")
tokenizer.train(["wikitext-2.txt"], trainer=trainer)

두 경우 모두 encode() 메서드를 호출하여 텍스트에서 토크나이저를 테스트할 수 있습니다:

encoding = tokenizer.encode("Let's test this tokenizer")
print(encoding.tokens)

위에서 encoding은 다양한 속성(ids, type_ids, tokens, offsets, attention_mask, special_tokens_mask, overflowing)에 토크나이저의 모든 필요한 출력을 포함하고 있는 Encoding 클래스의 객체입니다.

토큰화 파이프라인의 마지막 단계는 후처리(post-processing)입니다. 시작 부분에 [CLS] 토큰을 추가하고 끝 부분에 [SEP] 토큰을 추가해야 합니다. 한 쌍의 문장이 있는 경우에는 각 문장 뒤에 [SEP]를 붙입니다. 이를 위해서, TemplateProcessor를 사용하지만 먼저 어휘집(vocabulary)에서 [CLS] 및 [SEP] 토큰의 ID를 알아야 합니다:

cls_token_id = tokenizer.token_to_id("[CLS]")
sep_token_id = tokenizer.token_to_id("[SEP]")
print(cls_token_id, sep_token_id)

TemplateProcessor용 템플릿을 작성하려면 단일 문장과 문장 쌍을 처리하는 방법을 지정해야 합니다. 둘 다 사용하려는 특수 토큰을 작성합니다. 첫 번째(또는 단일) 문장은 \$A로 표시되고 두 번째 문장(쌍을 인코딩하는 경우)은 \\$B로 표시됩니다. 이들 각각(특수 토큰 및 문장)에 대해 콜론(colon) 뒤에 해당 토큰 유형 ID도 지정합니다.

따라서 고전적인 BERT 템플릿은 다음과 같이 정의됩니다:

tokenizer.post_processor = processors.TemplateProcessing(
    single=f"[CLS]:0 $A:0 [SEP]:0",
    pair=f"[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1",
    special_tokens=[("[CLS]", cls_token_id), ("[SEP]", sep_token_id)]
)

특수 토큰의 ID를 전달해야 토크나이저가 이를 해당 ID로 적절하게 변환할 수 있습니다.

일단 추가되면 이전 예제의 결과는 다음과 같습니다:

encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)

또한, 2개의 문장을 입력하면 다음과 같은 결과가 나옵니다:

encoding = tokenizer.encode("Let's test this tokenizer...", "on a pair of sentences.")
print(encoding.tokens)
print(encoding.type_ids)

새로운 토크나이저를 거의 완성했습니다. 마지막 단계는 디코더를 포함하는 것입니다:

tokenizer.decoder = decoders.WordPiece(prefix="##")

위의 encoding을 이용해서 테스트해 보겠습니다:

tokenizer.decode(encoding.ids)

좋습니다! 이제 다음과 같이 단일 JSON 파일에 토크나이저를 저장할 수 있습니다:

tokenizer.save("tokenizer.json")

그런 다음 from_file() 메서드를 사용하여 Tokenizer 객체에서 해당 파일을 다시 로드할 수 있습니다:

new_tokenizer = Tokenizer.from_file("tokenizer.json")

🤗Transformers에서 우리가 만든 토크나이저를 사용하려면 PreTrainedTokenizerFast로 래핑해야 합니다. 제너릭 클래스(generic class)를 사용하거나, 토크나이저가 기존 모델에 해당하는 경우, 해당 클래스(여기서는 BertTokenizerFast)를 사용할 수 있습니다. 이 강의를 활용하여 새로운 토크나이저를 구축하는 경우 첫번째 옵션을 사용해야 합니다.

PreTrainedTokenizerFast를 가지고 토크나이저를 래핑하려면 우리가 만든 토크나이저를 tokenizer_object로 전달하거나 tokenizer_file로 저장한 토크나이저 파일을 전달할 수 있습니다. 기억해야 할 중요한 점은 모든 특수 토큰을 수동으로 직접 설정해야 한다는 것입니다. PreTrainedTokenizerFast 클래스는 tokenizer 객체로부터 어떤 토큰이 마스크 토큰인지 아니면 [CLS] 토큰 등인지 추론할 수 없기 때문입니다:

from transformers import PreTrainedTokenizerFast

wrapped_tokenizer = PreTrainedTokenizerFast(
    tokenizer_object=tokenizer,
    unk_token="[UNK]",
    pad_token="[PAD]",
    cls_token="[CLS]",
    sep_token="[SEP]",
    mask_token="[MASK]",
)

특정 토크나이저 클래스(예: BertTokenizerFast)를 사용하는 경우, 기본적으로 지정된 토큰(여기서는 없음)과 다른 특수 토큰만 지정하면 됩니다:

from transformers import BertTokenizerFast

wrapped_tokenizer = BertTokenizerFast(tokenizer_object=tokenizer)

이제 위 토크나이저를 다른 🤗Transformers 토크나이저처럼 동일하게 사용할 수 있습니다. 또한, save_pretrained() 메서드로 저장하거나 push_to_hub() 메서드로 허브에 업로드할 수 있습니다.

이제까지 WordPiece 토크나이저를 빌드하는 방법을 보았으므로 BPE 토크나이저에 대해서도 동일한 작업을 수행해 보겠습니다. 모든 단계를 알고 있기 때문에 조금 더 빠르게 진행하고 차이점만 강조 표시합니다.

BPE 토크나이저를 처음부터 빌딩하기

이제 GPT-2 토크나이저를 빌드해 보겠습니다. BERT 토크나이저와 마찬가지로 BPE 모델로 Tokenizer를 초기화하는 것으로 시작합니다:

tokenizer = Tokenizer(models.BPE())

앞에서와 마찬가지로 기존에 어휘집(vocabulary)이 있는 경우 모델을 해당 어휘집(vocabulary)으로 초기화할 수 있지만(이 경우 vocab과 merges를 전달해야 함) 처음부터 학습할 것이기 때문에 그럴 필요는 없습니다. 또한 GPT-2는 byte-level BPE(바이트 수준 BPE)를 사용하기 때문에 unk_token을 지정할 필요가 없습니다.

GPT-2는 노멀라이저를 사용하지 않으므로 해당 단계를 건너뛰고 사전 토큰화(pre-tokenization)로 바로 이동합니다:

tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)

여기에서 ByteLevel에 추가한 옵션은 문장 시작 부분에 공백을 추가하지 않도록 하는 옵션입니다. 이전과 동일한 사전 토큰화 결과를 아래에서 볼 수 있습니다:

tokenizer.pre_tokenizer.pre_tokenize_str("Let's test pre-tokenization!")

다음은 학습이 필요한 모델입니다. GPT-2의 경우, 유일한 특수 토큰은 텍스트 끝(end-of-text) 토큰입니다:

trainer = trainers.BpeTrainer(vocab_size=25000, special_tokens=["<|endoftext|>"])
tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer)

WordPieceTrainer와 vocab_size 및 special_tokens와 마찬가지로, 원하는 경우 min_frequency를 지정할 수 있습니다. 또는 단어 끝 접미사(end-of-word suffix)가 있는 경우(예: </w>) end_of_word_suffix 인수를 설정할 수 있습니다.

이 토크나이저는 텍스트 파일에 대해서도 학습할 수 있습니다:

tokenizer.model = models.BPE()
tokenizer.train(["wikitext-2.txt"], trainer=trainer)

샘플 텍스트로 토큰화 테스트를 해보겠습니다:

encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)

다음과 같이 GPT-2 토크나이저에 대한 바이트 수준(byte-level) 후처리를 적용합니다:

tokenizer.post_processor = processors.ByteLevel(trim_offsets=False)

trim_offsets = False 옵션은 후처리기(post-processor)가 'Ġ'로 시작하는 토큰의 오프셋을 그대로 두어야 함을 나타냅니다. 이렇게 하면 오프셋의 시작은 단어의 첫번째 문자가 아니라 단어 앞의 공백을 가리킵니다. 그 이유는 공백도 기술적으로 토큰의 일부이기 때문입니다. 방금 인코딩한 텍스트로 결과를 살펴보겠습니다. 여기서 'Ġtest'는 인덱스 4의 토큰입니다:

sentence = "Let's test this tokenizer."
encoding = tokenizer.encode(sentence)
start, end = encoding.offsets[4]
sentence[start:end]

마지막으로, 바이트 수준(byte-level) 디코더를 추가합니다:

tokenizer.decoder = decoders.ByteLevel()

이것이 제대로 작동하는지 다시 확인할 수 있습니다:

tokenizer.decode(encoding.ids)

이제 완료되었으므로, 이전과 같이 토크나이저를 저장하고, 이를 🤗Transformers에서 사용하기를 원하는 경우에는 PreTrainedTokenizerFast 또는 GPT2TokenizerFast를 이용하여 래핑(wrapping)할 수 있습니다:

from transformers import PreTrainedTokenizerFast

wrapped_tokenizer = PreTrainedTokenizerFast(
    tokenizer_object=tokenizer,
    bos_token="<|endoftext|>",
    eos_token="<|endoftext|>",
)

from transformers import GPT2TokenizerFast

wrapped_tokenizer = GPT2TokenizerFast(tokenizer_object=tokenizer)

이제 마지막 예제로 Unigram 토크나이저를 처음부터 빌드하는 방법을 보여 드리겠습니다.

Unigram 토크나이저를 처음부터 빌딩하기

이제 XLNet 토크나이저를 빌드해 보겠습니다. 이전 토크나이저와 마찬가지로 Unigram 모델로 Tokenizer를 초기화하는 것으로 시작합니다:

tokenizer = Tokenizer(models.Unigram())

역시 여기서도, 어휘집(vocabulary)이 있는 경우 모델을 어휘집으로 초기화할 수 있습니다.

정규화(normalization)를 위해 XLNet은 다음과 같은 몇 가지 대체규칙(relpacements, SentencePiece에서 제공)을 사용합니다:

from tokenizers import Regex

tokenizer.normalizer = normalizers.Sequence(
    [
        normalizers.Replace("``", '"'),
        normalizers.Replace("''", '"'),
        normalizers.NFKD(),
        normalizers.StripAccents(),
        normalizers.Replace(Regex(" {2,}"), " "),
    ]
)

위 대체규칙은 “ 및 ”를 ”로 대체하고, 둘 이상의 공백 시퀀스를 단일 공백으로 대체하며, 토큰화할 텍스트의 악센트를 제거합니다.

모든 SentencePiece 토크나이저에 사용되는 사전 토크나이저(pre-tokenizer)는 Metaspace입니다.

tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()

이전의 예제 텍스트에 대한 사전 토큰화 결과를 한번 보겠습니다:

tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")

다음으로 모델 학습입니다. XLNet에는 몇 가지 특별한 토큰들이 있습니다:

special_tokens = ["<cls>", "<sep>", "<unk>", "<pad>", "<mask>", "<s>", "</s>"]
trainer = trainers.UnigramTrainer(
    vocab_size=25000, special_tokens=special_tokens, unk_token="<unk>"
)
tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer)

UnigramTrainer에서 뻬먹지 말아야 할 매우 중요한 인수는 unk_token입니다. 또한 토큰을 제거하는 각 단계에 대한 shrinking_factor(기본값은 0.75), 또는 주어진 토큰의 최대 길이를 지정하기 위한 max_piece_length(기본값은 16) 등과 같은 Unigram 알고리즘에 특화된 추가 매개변수들을 전달할 수도 있습니다.

이 토크나이저는 역시 텍스트 파일에 대해서도 학습할 수 있습니다:

tokenizer.model = models.Unigram()
tokenizer.train(["wikitext-2.txt"], trainer=trainer)

샘플 텍스트에 대한 토큰화 결과를 살펴보겠습니다:

encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)

XLNet의 특징은 토큰 타입 ID가 2인 <cls> 토큰을 문장 끝에 추가한다는 것입니다. 결과적으로 좌측 패딩입니다. BERT와 같이 템플릿을 사용하여 모든 특수 토큰과 토큰 타입 ID를 처리할 수 있지만 그전에 먼저 <cls> 및 <sep> 토큰의 ID를 가져와야 합니다:

cls_token_id = tokenizer.token_to_id("<cls>")
sep_token_id = tokenizer.token_to_id("<sep>")
print(cls_token_id, sep_token_id)

템플릿은 다음과 같은 형태로 구현됩니다:

tokenizer.post_processor = processors.TemplateProcessing(
    single="$A:0 <sep>:0 <cls>:2",
    pair="$A:0 <sep>:0 $B:1 <sep>:1 <cls>:2",
    special_tokens=[("<sep>", sep_token_id), ("<cls>", cls_token_id)],
)

이제 한 쌍의 문장에 대한 인코딩이 제대로 작동하는지 테스트할 수 있습니다:

encoding = tokenizer.encode("Let's test this tokenizer...", "on a pair of sentences!")
print(encoding.tokens)
print(encoding.type_ids)

마지막으로 Metaspace 디코더를 추가합니다:

tokenizer.decoder = decoders.Metaspace()

토크나이저 빌드를 끝냈습니다! 이전과 같이 토크나이저를 저장하고 🤗Transformers 내에서 사용하려면 PreTrainedTokenizerFast 또는 XLNetTokenizerFast로 래핑할 수 있습니다. PreTrainedTokenizerFast를 사용할 때 한 가지 주의해야 할 점은 특수 토큰 지정과 더불어 🤗Transformers 라이브러리에 왼쪽을 채우도록 지시(padding_side="left")해야 한다는 것입니다:

from transformers import PreTrainedTokenizerFast

wrapped_tokenizer = PreTrainedTokenizerFast(
    tokenizer_object=tokenizer,
    bos_token="<s>",
    eos_token="</s>",
    unk_token="<unk>",
    pad_token="<pad>",
    cls_token="<cls>",
    sep_token="<sep>",
    mask_token="<mask>",
    padding_side="left",
)

from transformers import XLNetTokenizerFast

wrapped_tokenizer = XLNetTokenizerFast(tokenizer_object=tokenizer)

지금까지 다양한 요소 모듈들이 기존 토크나이저를 새롭게 빌드하는 데 어떻게 사용되는지 보았으므로, 이 설명을 활용하여 🤗Tokenizers 라이브러리로 원하는 토크나이저를 구성하고 🤗Transformers에서 사용할 수 있어야 합니다.