Buckets:
| # ساختن یک توکِنایزر، گامبهگام[[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.