Buckets:

|
download
raw
31.9 kB
# ساختن یک توکِنایزر، گام‌به‌گام[[building-a-tokenizer-block-by-block]]
<CourseFloatingBanner chapter={6}
classNames="absolute z-10 right-0 top-0"
notebooks={[
{label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter6/section8.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter6/section8.ipynb"},
]} />
همان‌طور که در بخش‌های قبلی دیدیم، توکِن‌سازی چند گام دارد:
- نرمال‌سازی (هر نوع پاک‌سازی لازم متن، مانند حذف فاصله‌ها یا اَکسان‌ها، نرمال‌سازی Unicode و غیره)
- پیش‌توکِن‌سازی (تقسیم ورودی به کلمه‌ها)
- عبور دادن ورودی از مدل (استفاده از کلمه‌های پیش‌توکِن‌سازی‌شده برای تولید رشته‌ای از توکِن‌ها)
- پس‌پردازش (افزودن توکِن‌های ویژه‌ی توکِنایزر، تولید ماسک توجه و شناسه‌های نوع توکِن)
برای یادآوری، نگاهی دوباره به فرایند کلی بیندازیم:
کتابخانه‌ی 🤗 Tokenizers برای هرکدام از این گام‌ها چند گزینه فراهم می‌کند که می‌توانید آن‌ها را با هم ترکیب کنید. در این بخش می‌بینیم چگونه از صفر یک توکِنایزر بسازیم؛ برخلاف کاری که در [بخش ۲](/course/chapter6/2) انجام دادیم و توکِنایزر جدیدی را از روی توکِنایزری قدیمی تعلیم دادیم. سپس می‌توانید هر نوع توکِنایزری را که تصور می‌کنید بسازید!
به‌طور دقیق‌تر، کتابخانه حول کلاس مرکزی `Tokenizer` ساخته شده است و اجزای سازنده‌ی آن در زیرماژول‌ها گروه‌بندی شده‌اند:
- `normalizers` شامل همه‌ی انواع `Normalizer` است که می‌توانید استفاده کنید (فهرست کامل [اینجا](https://huggingface.co/docs/tokenizers/api/normalizers) است).
- `pre_tokenizers` شامل همه‌ی انواع `PreTokenizer` است که می‌توانید استفاده کنید (فهرست کامل [اینجا](https://huggingface.co/docs/tokenizers/api/pre-tokenizers) است).
- `models` شامل انواع مختلف `Model` است که می‌توانید استفاده کنید؛ مانند `BPE`، `WordPiece` و `Unigram` (فهرست کامل [اینجا](https://huggingface.co/docs/tokenizers/api/models) است).
- `trainers` شامل انواع مختلف `Trainer` است که می‌توانید برای تعلیم مدل روی یک پیکره استفاده کنید (برای هر نوع مدل یک مورد؛ فهرست کامل [اینجا](https://huggingface.co/docs/tokenizers/api/trainers) است).
- `post_processors` شامل انواع مختلف `PostProcessor` است که می‌توانید استفاده کنید (فهرست کامل [اینجا](https://huggingface.co/docs/tokenizers/api/post-processors) است).
- `decoders` شامل انواع مختلف `Decoder` است که می‌توانید برای کدگشایی خروجی‌های توکِن‌سازی استفاده کنید (فهرست کامل [اینجا](https://huggingface.co/docs/tokenizers/components#decoders) است).
فهرست کامل اجزای سازنده را [اینجا](https://huggingface.co/docs/tokenizers/components) می‌بینید.
## به‌دست‌آوردن پیکره[[acquiring-a-corpus]]
برای تعلیم توکِنایزر جدیدمان از پیکره‌ی کوچکی از متن استفاده می‌کنیم (تا مثال‌ها سریع اجرا شوند). گام‌های به‌دست‌آوردن پیکره شبیه گام‌هایی است که در [ابتدای این فصل](/course/chapter6/2) انجام دادیم، اما این بار از دیتاست [WikiText-2](https://huggingface.co/datasets/wikitext) استفاده می‌کنیم:
```python
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()` یک مولد است که دسته‌هایی شامل ۱۰۰۰ متن تولید می‌کند و از آن‌ها برای تعلیم توکِنایزر استفاده خواهیم کرد.
🤗 Tokenizers را می‌توان مستقیماً روی فایل‌های متنی نیز تعلیم داد. در اینجا می‌بینیم چگونه فایلی متنی بسازیم که همه‌ی متن‌ها/ورودی‌های WikiText-2 را دربرگیرد و بتوانیم آن را به‌صورت محلی استفاده کنیم:
```python
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 از صفر[[building-a-wordpiece-tokenizer-from-scratch]]
برای ساختن توکِنایزر با کتابخانه‌ی 🤗 Tokenizers، ابتدا یک شیء `Tokenizer` را با یک `model` نمونه‌سازی می‌کنیم، سپس ویژگی‌های `normalizer`، `pre_tokenizer`، `post_processor` و `decoder` آن را به مقادیری که می‌خواهیم تنظیم می‌کنیم.
برای این مثال، یک `Tokenizer` با مدل WordPiece ایجاد می‌کنیم:
```python
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` است که حداکثر طول هر کلمه را مشخص می‌کند (کلمه‌های طولانی‌تر از مقدار داده‌شده تقسیم می‌شوند).
نخستین گام توکِن‌سازی نرمال‌سازی است؛ پس با آن شروع کنیم. از آنجا که BERT به‌طور گسترده استفاده می‌شود، `BertNormalizer`ای وجود دارد که گزینه‌های کلاسیک قابل تنظیم برای BERT را در اختیار می‌گذارد: `lowercase` و `strip_accents` که خودشان گویا هستند؛ `clean_text` برای حذف همه‌ی نویسه‌های کنترلی و جایگزین کردن فاصله‌های تکراری با یک فاصله؛ و `handle_chinese_chars` که اطراف نویسه‌های چینی فاصله قرار می‌دهد. برای بازسازی توکِنایزر `bert-base-uncased` کافی است این نرمال‌ساز را تنظیم کنیم:
```python
tokenizer.normalizer = normalizers.BertNormalizer(lowercase=True)
```
بااین‌حال، به‌طور کلی هنگام ساختن یک توکِنایزر جدید به نرمال‌ساز آماده و مناسبی که از قبل در کتابخانه‌ی 🤗 Tokenizers پیاده‌سازی شده باشد دسترسی ندارید؛ پس ببینیم چگونه نرمال‌ساز BERT را دستی ایجاد کنیم. کتابخانه نرمال‌سازهای `Lowercase` و `StripAccents` را فراهم می‌کند و می‌توانید با استفاده از `Sequence` چند نرمال‌ساز را ترکیب کنید:
```python
tokenizer.normalizer = normalizers.Sequence(
[normalizers.NFD(), normalizers.Lowercase(), normalizers.StripAccents()]
)
```
همچنین از نرمال‌ساز Unicode `NFD` استفاده می‌کنیم، چون در غیر این صورت نرمال‌ساز `StripAccents` نویسه‌های دارای اَکسان را درست تشخیص نمی‌دهد و آن‌ها را حذف نمی‌کند.
همان‌طور که قبلاً دیدیم، می‌توانیم از متد `normalize_str()` نرمال‌ساز `normalizer` برای بررسی اثر آن روی متنی مشخص استفاده کنیم:
```python
print(tokenizer.normalizer.normalize_str("Héllò hôw are ü?"))
```
```python out
hello how are u?
```
> [!TIP]
> **برای مطالعه‌ی بیشتر** اگر دو نسخه‌ی نرمال‌سازهای قبلی را روی رشته‌ای دارای نویسه‌ی Unicode یعنی `u"\u0085"` امتحان کنید، حتماً متوجه می‌شوید که این دو نرمال‌ساز دقیقاً معادل نیستند.
> برای اینکه نسخه‌ی دارای `normalizers.Sequence` بیش از حد پیچیده نشود، جایگزینی‌های Regex موردنیاز `BertNormalizer` را که هنگام تنظیم آرگومان `clean_text` روی `True` لازم است (و رفتار پیش‌فرض است) وارد نکرده‌ایم. اما نگران نباشید: می‌توانیم بدون استفاده از نرمال‌ساز آماده‌ی `BertNormalizer` و با افزودن دو `normalizers.Replace` به دنباله‌ی نرمال‌سازها، دقیقاً همان نرمال‌سازی را انجام دهیم.
گام بعدی، پیش‌توکِن‌سازی است. در اینجا نیز `BertPreTokenizer` از پیش آماده است و می‌توانیم از آن استفاده کنیم:
```python
tokenizer.pre_tokenizer = pre_tokenizers.BertPreTokenizer()
```
یا می‌توانیم آن را از صفر بسازیم:
```python
tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()
```
توجه کنید که پیش‌توکِن‌ساز `Whitespace` بر اساس فاصله و همه‌ی نویسه‌هایی که حرف، رقم یا نویسه‌ی زیرخط نیستند تقسیم می‌کند؛ بنابراین از نظر فنی متن را بر اساس فاصله و علائم نگارشی جدا می‌کند:
```python
tokenizer.pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.")
```
```python out
[('Let', (0, 3)), ("'", (3, 4)), ('s', (4, 5)), ('test', (6, 10)), ('my', (11, 13)), ('pre', (14, 17)),
('-', (17, 18)), ('tokenizer', (18, 27)), ('.', (27, 28))]
```
اگر فقط می‌خواهید بر اساس فاصله تقسیم کنید، باید به‌جای آن از پیش‌توکِن‌ساز `WhitespaceSplit` استفاده کنید:
```python
pre_tokenizer = pre_tokenizers.WhitespaceSplit()
pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.")
```
```python out
[("Let's", (0, 5)), ('test', (6, 10)), ('my', (11, 13)), ('pre-tokenizer.', (14, 28))]
```
مانند نرمال‌سازها، می‌توانید از `Sequence` برای ترکیب چند پیش‌توکِن‌ساز استفاده کنید:
```python
pre_tokenizer = pre_tokenizers.Sequence(
[pre_tokenizers.WhitespaceSplit(), pre_tokenizers.Punctuation()]
)
pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.")
```
```python out
[('Let', (0, 3)), ("'", (3, 4)), ('s', (4, 5)), ('test', (6, 10)), ('my', (11, 13)), ('pre', (14, 17)),
('-', (17, 18)), ('tokenizer', (18, 27)), ('.', (27, 28))]
```
گام بعدی در خط تولید توکِن‌سازی، عبور دادن ورودی‌ها از مدل است. مدل را در مرحله‌ی نمونه‌سازی مشخص کردیم، اما هنوز باید آن را تعلیم دهیم؛ این کار به `WordPieceTrainer` نیاز دارد. نکته‌ی اصلی هنگام نمونه‌سازی تعلیم‌دهنده در 🤗 Tokenizers این است که باید همه‌ی توکِن‌های ویژه‌ای را که قصد استفاده از آن‌ها را دارید به آن بدهید — وگرنه آن‌ها را به واژگان اضافه نمی‌کند، چون در پیکره‌ی تعلیم وجود ندارند:
```python
special_tokens = ["[UNK]", "[PAD]", "[CLS]", "[SEP]", "[MASK]"]
trainer = trainers.WordPieceTrainer(vocab_size=25000, special_tokens=special_tokens)
```
علاوه بر تعیین `vocab_size` و `special_tokens`، می‌توانیم `min_frequency` (تعداد دفعاتی که یک توکِن باید ظاهر شود تا در واژگان قرار بگیرد) را تنظیم کنیم یا `continuing_subword_prefix` را تغییر دهیم (اگر بخواهیم به‌جای `##` از چیز دیگری استفاده کنیم).
برای تعلیم مدل با استفاده از تکرارکننده‌ای که پیش‌تر تعریف کردیم، فقط باید این دستور را اجرا کنیم:
```python
tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer)
```
همچنین می‌توانیم از فایل‌های متنی برای تعلیم توکِنایزر استفاده کنیم؛ شکل کار چنین است (ابتدا مدل را با یک `WordPiece` خالی دوباره مقداردهی می‌کنیم):
```python
tokenizer.model = models.WordPiece(unk_token="[UNK]")
tokenizer.train(["wikitext-2.txt"], trainer=trainer)
```
در هر دو حالت، سپس می‌توانیم با فراخوانی متد `encode()` توکِنایزر را روی متنی امتحان کنیم:
```python
encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)
```
```python out
['let', "'", 's', 'test', 'this', 'tok', '##eni', '##zer', '.']
```
`encoding` به‌دست‌آمده یک `Encoding` است که همه‌ی خروجی‌های لازم توکِنایزر را در ویژگی‌های مختلف خود دربرمی‌گیرد: `ids`، `type_ids`، `tokens`، `offsets`، `attention_mask`، `special_tokens_mask` و `overflowing`.
آخرین گام در خط تولید توکِن‌سازی پس‌پردازش است. باید توکِن `[CLS]` را در ابتدا و توکِن `[SEP]` را در انتها اضافه کنیم (یا اگر یک جفت جمله داریم، پس از هر جمله). برای این کار از `TemplateProcessor` استفاده می‌کنیم، اما ابتدا باید شناسه‌های توکِن‌های `[CLS]` و `[SEP]` را در واژگان بدانیم:
```python
cls_token_id = tokenizer.token_to_id("[CLS]")
sep_token_id = tokenizer.token_to_id("[SEP]")
print(cls_token_id, sep_token_id)
```
```python out
(2, 3)
```
برای نوشتن قالب `TemplateProcessor` باید مشخص کنیم با یک جمله و با یک جفت جمله چگونه رفتار شود. در هر دو حالت، توکِن‌های ویژه‌ای را که می‌خواهیم استفاده کنیم می‌نویسیم؛ جمله‌ی اول (یا تنها جمله) با `$A` نمایش داده می‌شود و جمله‌ی دوم (اگر جفتی را کدگذاری کنیم) با `$B`. برای هرکدام از این توکِن‌های ویژه و جمله‌ها، شناسه‌ی نوع توکِن متناظر را پس از دونقطه مشخص می‌کنیم.
قالب کلاسیک BERT به شکل زیر تعریف می‌شود:
```python
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)],
)
```
توجه کنید که باید شناسه‌های توکِن‌های ویژه را نیز ارسال کنیم تا توکِنایزر بتواند آن‌ها را به‌درستی به شناسه‌هایشان تبدیل کند.
پس از افزودن این مورد، مثال قبلی نتیجه‌ی زیر را خواهد داد:
```python
encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)
```
```python out
['[CLS]', 'let', "'", 's', 'test', 'this', 'tok', '##eni', '##zer', '.', '[SEP]']
```
و برای جفتی از جمله‌ها، نتیجه‌ی درست را می‌گیریم:
```python
encoding = tokenizer.encode("Let's test this tokenizer...", "on a pair of sentences.")
print(encoding.tokens)
print(encoding.type_ids)
```
```python out
['[CLS]', 'let', "'", 's', 'test', 'this', 'tok', '##eni', '##zer', '...', '[SEP]', 'on', 'a', 'pair', 'of', 'sentences', '.', '[SEP]']
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
```
تقریباً ساختن این توکِنایزر از صفر تمام شده است — گام آخر افزودن یک کدگشا است:
```python
tokenizer.decoder = decoders.WordPiece(prefix="##")
```
بیایید آن را روی `encoding` قبلی امتحان کنیم:
```python
tokenizer.decode(encoding.ids)
```
```python out
"let's test this tokenizer... on a pair of sentences."
```
عالی است! می‌توانیم توکِنایزر خود را در یک فایل JSON واحد، به شکل زیر ذخیره کنیم:
```python
tokenizer.save("tokenizer.json")
```
سپس می‌توانیم آن فایل را در یک شیء `Tokenizer` با استفاده از متد `from_file()` دوباره بارگذاری کنیم:
```python
new_tokenizer = Tokenizer.from_file("tokenizer.json")
```
برای استفاده از این توکِنایزر در 🤗 Transformers، باید آن را در یک `PreTrainedTokenizerFast` بپیچیم. می‌توانیم از کلاس عمومی استفاده کنیم یا اگر توکِنایزر ما با مدلی موجود مطابقت دارد، از کلاس همان مدل (در اینجا `BertTokenizerFast`) استفاده کنیم. اگر این درس را برای ساختن توکِنایزری کاملاً جدید دنبال می‌کنید، باید گزینه‌ی اول را به کار ببرید.
برای پیچیدن توکِنایزر در `PreTrainedTokenizerFast`، می‌توانیم توکِنایزری را که ساخته‌ایم به‌عنوان `tokenizer_object` یا فایل توکِنایزری را که ذخیره کرده‌ایم به‌عنوان `tokenizer_file` ارسال کنیم. نکته‌ی مهم این است که باید همه‌ی توکِن‌های ویژه را دستی تنظیم کنیم، چون این کلاس نمی‌تواند از شیء `tokenizer` بفهمد کدام توکِن، توکِن ماسک، توکِن `[CLS]` و غیره است:
```python
from transformers import PreTrainedTokenizerFast
wrapped_tokenizer = PreTrainedTokenizerFast(
tokenizer_object=tokenizer,
# tokenizer_file="tokenizer.json", # You can load from the tokenizer file, alternatively
unk_token="[UNK]",
pad_token="[PAD]",
cls_token="[CLS]",
sep_token="[SEP]",
mask_token="[MASK]",
)
```
اگر از کلاس توکِنایزر مشخصی (مانند `BertTokenizerFast`) استفاده می‌کنید، فقط باید توکِن‌های ویژه‌ای را مشخص کنید که با موارد پیش‌فرض متفاوت‌اند (در اینجا هیچ‌کدام):
```python
from transformers import BertTokenizerFast
wrapped_tokenizer = BertTokenizerFast(tokenizer_object=tokenizer)
```
اکنون می‌توانید از این توکِنایزر مانند هر توکِنایزر 🤗 Transformers دیگری استفاده کنید. می‌توانید آن را با متد `save_pretrained()` ذخیره کنید یا با متد `push_to_hub()` آن را در هاب بارگذاری کنید.
حالا که دیدیم چگونه توکِنایزر WordPiece بسازیم، همین کار را برای یک توکِنایزر BPE انجام دهیم. چون همه‌ی گام‌ها را می‌دانید، کمی سریع‌تر پیش می‌رویم و فقط تفاوت‌ها را برجسته می‌کنیم.
## ساختن توکِنایزر BPE از صفر[[building-a-bpe-tokenizer-from-scratch]]
حالا یک توکِنایزر GPT-2 می‌سازیم. مانند توکِنایزر BERT، کار را با مقداردهی اولیه‌ی `Tokenizer` همراه با یک مدل BPE شروع می‌کنیم:
```python
tokenizer = Tokenizer(models.BPE())
```
مانند BERT، اگر واژگانی داشتیم می‌توانستیم این مدل را با آن مقداردهی اولیه کنیم (در این حالت باید `vocab` و `merges` را ارسال می‌کردیم)، اما چون از صفر تعلیم می‌دهیم، به این کار نیاز نداریم. همچنین لازم نیست `unk_token` را مشخص کنیم، چون GPT-2 از BPE در سطح بایت استفاده می‌کند که به آن نیاز ندارد.
GPT-2 از نرمال‌ساز استفاده نمی‌کند؛ پس این گام را رد می‌کنیم و مستقیماً به پیش‌توکِن‌سازی می‌رویم:
```python
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)
```
گزینه‌ای که اینجا به `ByteLevel` اضافه کردیم این است که در ابتدای جمله فاصله‌ای اضافه نشود (در غیر این صورت رفتار پیش‌فرض همین است). می‌توانیم مانند قبل پیش‌توکِن‌سازی متنی نمونه را بررسی کنیم:
```python
tokenizer.pre_tokenizer.pre_tokenize_str("Let's test pre-tokenization!")
```
```python out
[('Let', (0, 3)), ("'s", (3, 5)), ('Ġtest', (5, 10)), ('Ġpre', (10, 14)), ('-', (14, 15)),
('tokenization', (15, 27)), ('!', (27, 28))]
```
گام بعدی مدل است که به تعلیم نیاز دارد. برای GPT-2، تنها توکِن ویژه، توکِن پایان متن است:
```python
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` را مشخص کنیم؛ یا اگر پسوند پایان کلمه‌ای (مانند `</w>`) داریم، آن را با `end_of_word_suffix` تنظیم کنیم.
این توکِنایزر را می‌توان روی فایل‌های متنی نیز تعلیم داد:
```python
tokenizer.model = models.BPE()
tokenizer.train(["wikitext-2.txt"], trainer=trainer)
```
بیایید توکِن‌سازی یک متن نمونه را بررسی کنیم:
```python
encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)
```
```python out
['L', 'et', "'", 's', 'Ġtest', 'Ġthis', 'Ġto', 'ken', 'izer', '.']
```
پس‌پردازش سطح بایت را برای توکِنایزر GPT-2 به شکل زیر اعمال می‌کنیم:
```python
tokenizer.post_processor = processors.ByteLevel(trim_offsets=False)
```
گزینه‌ی `trim_offsets = False` به پس‌پردازش‌گر می‌گوید offsetهای توکِن‌هایی را که با 'Ġ' شروع می‌شوند همان‌طور نگه دارد: به این ترتیب، ابتدای offset به فاصله‌ی پیش از کلمه اشاره می‌کند، نه نخستین نویسه‌ی کلمه (چون فاصله از نظر فنی بخشی از توکِن است). بیایید نتیجه را با متن همین حالا کدگذاری‌شده بررسی کنیم؛ در این متن، `'Ġtest'` توکِنِ اندیس ۴ است:
```python
sentence = "Let's test this tokenizer."
encoding = tokenizer.encode(sentence)
start, end = encoding.offsets[4]
sentence[start:end]
```
```python out
' test'
```
در پایان، یک کدگشای سطح بایت اضافه می‌کنیم:
```python
tokenizer.decoder = decoders.ByteLevel()
```
و می‌توانیم دوباره بررسی کنیم که درست کار می‌کند:
```python
tokenizer.decode(encoding.ids)
```
```python out
"Let's test this tokenizer."
```
عالی است! حالا که کار تمام شد، می‌توانیم مانند قبل توکِنایزر را ذخیره کنیم و اگر بخواهیم در 🤗 Transformers از آن استفاده کنیم، آن را در `PreTrainedTokenizerFast` یا `GPT2TokenizerFast` بپیچیم:
```python
from transformers import PreTrainedTokenizerFast
wrapped_tokenizer = PreTrainedTokenizerFast(
tokenizer_object=tokenizer,
bos_token="<|endoftext|>",
eos_token="<|endoftext|>",
)
```
یا:
```python
from transformers import GPT2TokenizerFast
wrapped_tokenizer = GPT2TokenizerFast(tokenizer_object=tokenizer)
```
در آخرین مثال، نشان می‌دهیم چگونه یک توکِنایزر Unigram را از صفر بسازیم.
## ساختن توکِنایزر Unigram از صفر[[building-a-unigram-tokenizer-from-scratch]]
حالا یک توکِنایزر XLNet می‌سازیم. مانند توکِنایزرهای قبلی، کار را با مقداردهی اولیه‌ی `Tokenizer` همراه با مدل Unigram شروع می‌کنیم:
```python
tokenizer = Tokenizer(models.Unigram())
```
همچنین اگر واژگانی داشتیم می‌توانستیم این مدل را با آن مقداردهی اولیه کنیم.
برای نرمال‌سازی، XLNet از چند جایگزینی استفاده می‌کند (که از SentencePiece می‌آیند):
```python
from tokenizers import Regex
tokenizer.normalizer = normalizers.Sequence(
[
normalizers.Replace("``", '"'),
normalizers.Replace("''", '"'),
normalizers.NFKD(),
normalizers.StripAccents(),
normalizers.Replace(Regex(" {2,}"), " "),
]
)
```
این کار `` و '' را با " و هر رشته‌ای از دو فاصله یا بیشتر را با یک فاصله جایگزین می‌کند و همچنین اَکسان‌ها را از متن‌های مورد توکِن‌سازی حذف می‌کند.
پیش‌توکِن‌سازی که باید برای هر توکِنایزر SentencePiece استفاده شود `Metaspace` است:
```python
tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
```
می‌توانیم مانند قبل پیش‌توکِن‌سازی یک متن نمونه را بررسی کنیم:
```python
tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
```
```python out
[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
```
گام بعدی مدل است که به تعلیم نیاز دارد. XLNet چند توکِن ویژه دارد:
```python
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` است. می‌توانیم آرگومان‌های دیگری را که مخصوص الگوریتم Unigram هستند نیز ارسال کنیم؛ مانند `shrinking_factor` برای هر گام حذف توکِن‌ها (مقدار پیش‌فرض ۰٫۷۵) یا `max_piece_length` برای تعیین حداکثر طول یک توکِن مشخص (مقدار پیش‌فرض ۱۶).
این توکِنایزر را می‌توان روی فایل‌های متنی نیز تعلیم داد:
```python
tokenizer.model = models.Unigram()
tokenizer.train(["wikitext-2.txt"], trainer=trainer)
```
بیایید توکِن‌سازی یک متن نمونه را بررسی کنیم:
```python
encoding = tokenizer.encode("Let's test this tokenizer.")
print(encoding.tokens)
```
```python out
['▁Let', "'", 's', '▁test', '▁this', '▁to', 'ken', 'izer', '.']
```
یکی از ویژگی‌های XLNet این است که توکِن `<cls>` را با شناسه‌ی نوع ۲ در انتهای جمله قرار می‌دهد (برای متمایز کردن آن از توکِن‌های دیگر). در نتیجه، هم‌طول‌سازی در سمت چپ انجام می‌شود. می‌توانیم همه‌ی توکِن‌های ویژه و شناسه‌های نوع توکِن را با قالبی مانند قالب BERT مدیریت کنیم، اما ابتدا باید شناسه‌های توکِن‌های `<cls>` و `<sep>` را به دست آوریم:
```python
cls_token_id = tokenizer.token_to_id("<cls>")
sep_token_id = tokenizer.token_to_id("<sep>")
print(cls_token_id, sep_token_id)
```
```python out
0 1
```
قالب به شکل زیر است:
```python
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)],
)
```
می‌توانیم با کدگذاری یک جفت جمله درست کار کردن آن را آزمایش کنیم:
```python
encoding = tokenizer.encode("Let's test this tokenizer...", "on a pair of sentences!")
print(encoding.tokens)
print(encoding.type_ids)
```
```python out
['▁Let', "'", 's', '▁test', '▁this', '▁to', 'ken', 'izer', '.', '.', '.', '<sep>', '▁', 'on', '▁', 'a', '▁pair',
'▁of', '▁sentence', 's', '!', '<sep>', '<cls>']
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
```
در پایان، یک کدگشای `Metaspace` اضافه می‌کنیم:
```python
tokenizer.decoder = decoders.Metaspace()
```
و کارمان با این توکِنایزر تمام است! می‌توانیم مانند قبل آن را ذخیره کنیم و اگر بخواهیم در 🤗 Transformers از آن استفاده کنیم، آن را در `PreTrainedTokenizerFast` یا `XLNetTokenizerFast` بپیچیم. نکته‌ای که هنگام استفاده از `PreTrainedTokenizerFast` باید در نظر داشته باشید این است که علاوه بر توکِن‌های ویژه، باید به کتابخانه‌ی 🤗 Transformers بگوییم از سمت چپ هم‌طول‌سازی کند:
```python
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",
)
```
یا به‌صورت جایگزین:
```python
from transformers import XLNetTokenizerFast
wrapped_tokenizer = XLNetTokenizerFast(tokenizer_object=tokenizer)
```
حالا که دیدید اجزای سازنده‌ی مختلف چگونه برای ساخت توکِنایزرهای موجود استفاده می‌شوند، باید بتوانید با کتابخانه‌ی 🤗 Tokenizers هر توکِنایزری را که می‌خواهید بنویسید و از آن در 🤗 Transformers استفاده کنید.

Xet Storage Details

Size:
31.9 kB
·
Xet hash:
82aa49e858ad7019801fe96173e31d08ea820a646dd33377dc297cecba10187a

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.