Buckets:

|
download
raw
18.2 kB
# توکِنایزرها[[tokenizers]]
<CourseFloatingBanner chapter={2}
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/chapter2/section4_pt.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section4_pt.ipynb"},
]} />
توکِنایزرها یکی از اجزای اصلی خط تولید NLP هستند. آن‌ها یک هدف دارند: تبدیل متن به داده‌ای که مدل بتواند پردازش کند. مدل‌ها فقط می‌توانند اعداد را پردازش کنند، بنابراین توکِنایزرها باید ورودی‌های متنی ما را به داده‌های عددی تبدیل کنند. در این بخش دقیقاً بررسی می‌کنیم که در خط تولید توکِن‌سازی چه اتفاقی می‌افتد.
در مسائل NLP، داده‌ای که معمولاً پردازش می‌شود متن خام است. نمونه‌ای از چنین متنی:
```
Jim Henson was a puppeteer
```
بااین‌حال، مدل‌ها فقط می‌توانند اعداد را پردازش کنند، پس باید راهی برای تبدیل متن خام به اعداد پیدا کنیم. توکِنایزرها همین کار را انجام می‌دهند و برای انجام آن راه‌های زیادی وجود دارد. هدف این است که معنادارترین نمایش را پیدا کنیم؛ یعنی نمایشی که بیشترین معنا را برای مدل داشته باشد و، در صورت امکان، کوچک‌ترین نمایش باشد.
بیایید چند نمونه از الگوریتم‌های توکِن‌سازی را ببینیم و تلاش کنیم به برخی پرسش‌هایی که ممکن است درباره‌ی توکِن‌سازی داشته باشید پاسخ دهیم.
## مبتنی بر کلمه[[word-based]]
نخستین نوع توکِنایزری که به ذهن می‌رسد، توکِنایزر *مبتنی بر کلمه* است. راه‌اندازی و استفاده از آن معمولاً با چند قاعده‌ی ساده بسیار آسان است و اغلب نتایج قابل‌قبولی به دست می‌دهد. برای نمونه، در تصویر زیر هدف این است که متن خام را به کلمات تقسیم کنیم و برای هرکدام نمایش عددی پیدا کنیم:
راه‌های مختلفی برای تقسیم متن وجود دارد. برای مثال، می‌توانیم با اجرای تابع `split()` پایتون از فاصله‌های سفید استفاده کنیم و متن را به کلمه‌ها توکِن‌سازی کنیم:
```py
tokenized_text = "Jim Henson was a puppeteer".split()
print(tokenized_text)
```
```python out
['Jim', 'Henson', 'was', 'a', 'puppeteer']
```
توکِنایزرهای کلمه‌ای انواع دیگری هم دارند که برای علائم نگارشی قواعد بیشتری ارائه می‌کنند. با چنین توکِنایزری ممکن است به «واژگان» بسیار بزرگی برسیم؛ واژگان در اینجا با تعداد کل توکِن‌های مستقل موجود در پیکره تعریف می‌شود.
برای هر کلمه یک شناسه تعیین می‌شود که از ۰ شروع می‌شود و تا اندازه‌ی واژگان ادامه پیدا می‌کند. مدل از این شناسه‌ها برای شناسایی هر کلمه استفاده می‌کند.
اگر بخواهیم با توکِنایزری مبتنی بر کلمه یک زبان را به‌طور کامل پوشش دهیم، باید برای هر کلمه‌ی آن زبان یک شناسه داشته باشیم و در نتیجه تعداد بسیار زیادی توکِن تولید می‌شود. برای مثال، در زبان انگلیسی بیش از ۵۰۰٬۰۰۰ کلمه وجود دارد؛ بنابراین برای ساختن نگاشتی از هر کلمه به یک شناسه‌ی ورودی، باید همین تعداد شناسه را دنبال کنیم. علاوه بر این، کلماتی مانند «dog» با کلماتی مانند «dogs» متفاوت نمایش داده می‌شوند و مدل در ابتدا راهی ندارد که بداند «dog» و «dogs» مشابه‌اند: این دو کلمه را نامرتبط تشخیص می‌دهد. همین موضوع درباره‌ی کلمات مشابه دیگری مانند «run» و «running» هم صدق می‌کند؛ مدل در ابتدا آن‌ها را مشابه نمی‌بیند.
در نهایت، برای نمایش کلماتی که در واژگان ما نیستند به یک توکِن سفارشی نیاز داریم. این توکِن، «توکِن ناشناخته» نام دارد و معمولاً با "[UNK]" یا "&lt;unk&gt;" نمایش داده می‌شود. اگر ببینید توکِنایزر تعداد زیادی از این توکِن‌ها تولید می‌کند، معمولاً نشانه‌ی خوبی نیست، چون نتوانسته نمایش معقولی از یک کلمه پیدا کند و در این مسیر اطلاعاتی از دست می‌رود. هنگام ساخت واژگان باید آن را طوری طراحی کنیم که توکِنایزر تا حد امکان کلمات کمتری را به توکِن ناشناخته تبدیل کند.
یکی از راه‌های کاهش توکِن‌های ناشناخته این است که یک سطح پایین‌تر برویم و از توکِنایزری *مبتنی بر نویسه* استفاده کنیم.
## مبتنی بر نویسه[[character-based]]
توکِنایزرهای نویسه‌ای متن را به‌جای کلمه، به نویسه‌ها تقسیم می‌کنند. این روش دو مزیت اصلی دارد:
- واژگان بسیار کوچک‌تر است.
- توکِن‌های خارج از واژگان (ناشناخته) بسیار کمتری داریم، چون هر کلمه را می‌توان از نویسه‌ها ساخت.
اما در اینجا هم درباره‌ی فاصله‌ها و علائم نگارشی پرسش‌هایی پیش می‌آید:
این روش هم بی‌نقص نیست. حالا که نمایش بر پایه‌ی نویسه‌هاست نه کلمه‌ها، می‌توان استدلال کرد که از نظر شهودی معنا و ارزش کمتری دارد: هر نویسه به‌تنهایی معنای زیادی ندارد، درحالی‌که کلمه‌ها چنین معنایی دارند. بااین‌حال، این موضوع به زبان هم بستگی دارد؛ برای مثال در زبان چینی هر نویسه اطلاعات بیشتری از یک نویسه در زبان‌های لاتین منتقل می‌کند.
نکته‌ی دیگری که باید در نظر بگیریم این است که تعداد بسیار زیادی توکِن برای پردازش مدل تولید می‌شود: درحالی‌که یک کلمه در توکِنایزر کلمه‌ای فقط یک توکِن است، وقتی به نویسه تبدیل شود به‌راحتی می‌تواند به ۱۰ توکِن یا بیشتر تبدیل شود.
برای به‌دست‌آوردن بهترین ویژگی‌های هر دو روش، می‌توانیم از تکنیک سومی استفاده کنیم که این دو رویکرد را ترکیب می‌کند: *توکِن‌سازی زیرکلمه‌ای*.
## توکِن‌سازی زیرکلمه‌ای[[subword-tokenization]]
الگوریتم‌های توکِن‌سازی زیرکلمه‌ای بر این اصل تکیه دارند که کلمات پرکاربرد نباید به زیرکلمه‌های کوچک‌تر تقسیم شوند، اما کلمات کم‌کاربرد باید به زیرکلمه‌های معنادار تجزیه شوند.
برای نمونه، ممکن است «annoyingly» کلمه‌ای کم‌کاربرد در نظر گرفته شود و به «annoying» و «ly» تجزیه شود. احتمالاً هر دو به‌عنوان زیرکلمه‌های مستقل بیشتر ظاهر می‌شوند و هم‌زمان معنای «annoyingly» از ترکیب معنایی «annoying» و «ly» حفظ می‌شود.
در اینجا نمونه‌ای می‌بینید که نشان می‌دهد الگوریتم توکِن‌سازی زیرکلمه‌ای چگونه رشته‌ی «Let's do tokenization!» را توکِن‌سازی می‌کند:
این زیرکلمه‌ها معنای معنایی زیادی فراهم می‌کنند: برای نمونه، در مثال بالا «tokenization» به «token» و «ization» تقسیم شد؛ دو توکِنی که هم معنای معنایی دارند و هم از نظر فضا کارآمدند (برای نمایش یک کلمه‌ی بلند فقط دو توکِن لازم است). این روش به ما امکان می‌دهد با واژگانی کوچک پوشش نسبتاً خوبی داشته باشیم و تقریباً هیچ توکِن ناشناخته‌ای تولید نکنیم.
این روش به‌ویژه برای زبان‌های پیوندی مانند ترکی مفید است؛ در این زبان‌ها می‌توان با کنار هم گذاشتن زیرکلمه‌ها کلمات پیچیده و تقریباً به هر طولی ساخت.
### و بیشتر![[and-more]]
همان‌طور که انتظار می‌رود، تکنیک‌های بسیار بیشتری وجود دارند. برای نام‌بردن از چند مورد:
- BPE در سطح بایت، همان‌طور که در GPT-2 استفاده می‌شود
- WordPiece، همان‌طور که در BERT استفاده می‌شود
- SentencePiece یا Unigram، همان‌طور که در چندین مدل چندزبانه استفاده می‌شوند
حالا باید دانش کافی درباره‌ی نحوه‌ی کار توکِنایزرها داشته باشید تا کار با API را شروع کنید.
## بارگذاری و ذخیره‌سازی[[loading-and-saving]]
بارگذاری و ذخیره‌سازی توکِنایزرها به سادگی مدل‌هاست. در واقع، این کار بر پایه‌ی همان دو تابع انجام می‌شود: `from_pretrained()` و `save_pretrained()`. این تابع‌ها الگوریتم استفاده‌شده توسط توکِنایزر (تا حدی مانند *معماری* مدل) و نیز واژگان آن (تا حدی مانند *وزن‌های* مدل) را بارگذاری یا ذخیره می‌کنند.
بارگذاری توکِنایزر BERT که با همان نقطه‌ی تعلیم BERT آموزش داده شده، مانند بارگذاری مدل انجام می‌شود، با این تفاوت که از کلاس `BertTokenizer` استفاده می‌کنیم:
```py
from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
```
مشابه `AutoModel`، کلاس `AutoTokenizer` در کتابخانه بر اساس نام نقطه‌ی تعلیم، کلاس توکِنایزر مناسب را پیدا می‌کند و می‌توان آن را مستقیماً با هر نقطه‌ی تعلیمی به کار برد:
```py
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
```
حالا می‌توانیم توکِنایزر را همان‌طور که در بخش قبلی دیدیم به کار ببریم:
```python
tokenizer("Using a Transformer network is simple")
```
```python out
{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}
```
ذخیره‌سازی توکِنایزر با ذخیره‌سازی مدل یکسان است:
```py
tokenizer.save_pretrained("directory_on_my_computer")
```
در [فصل ۳](/course/chapter3) درباره‌ی `token_type_ids` بیشتر صحبت می‌کنیم و کمی جلوتر کلید `attention_mask` را توضیح می‌دهیم. ابتدا ببینیم `input_ids` چگونه تولید می‌شوند. برای این کار باید به تابع‌های میانی توکِنایزر نگاه کنیم.
## کدگذاری[[encoding]]
تبدیل متن به اعداد را *کدگذاری* می‌نامیم. کدگذاری در دو مرحله انجام می‌شود: توکِن‌سازی و سپس تبدیل به شناسه‌های ورودی.
همان‌طور که دیدیم، مرحله‌ی نخست تقسیم متن به کلمات (یا بخش‌هایی از کلمات، علائم نگارشی و مانند آن) است که معمولاً *توکِن* نامیده می‌شوند. قواعد متعددی می‌توانند این فرایند را کنترل کنند؛ به همین دلیل باید توکِنایزر را با نام مدل نمونه‌سازی کنیم تا مطمئن شویم از همان قواعدی استفاده می‌کنیم که هنگام پیش‌تعلیم مدل به کار رفته‌اند.
مرحله‌ی دوم تبدیل آن توکِن‌ها به اعداد است تا بتوانیم از آن‌ها تِنسوری بسازیم و به مدل بدهیم. برای این کار توکِنایزر *واژگان* دارد؛ همان بخشی که هنگام نمونه‌سازی با تابع `from_pretrained()` دانلود می‌کنیم. باز هم باید از همان واژگانی استفاده کنیم که مدل هنگام پیش‌تعلیم از آن‌ها استفاده کرده است.
برای درک بهتر این دو مرحله، آن‌ها را جداگانه بررسی می‌کنیم. توجه داشته باشید که برای نشان‌دادن نتایج میانی، از تابع‌هایی استفاده می‌کنیم که بخش‌هایی از خط تولید توکِن‌سازی را جداگانه انجام می‌دهند، اما در عمل باید توکِنایزر را مستقیماً روی ورودی‌های خود فراخوانی کنید (همان‌طور که در بخش ۲ نشان داده شد).
### توکِن‌سازی[[tokenization]]
فرایند توکِن‌سازی با تابع `tokenize()` توکِنایزر انجام می‌شود:
```py
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
sequence = "Using a Transformer network is simple"
tokens = tokenizer.tokenize(sequence)
print(tokens)
```
خروجی این تابع فهرستی از رشته‌ها یا توکِن‌هاست:
```python out
['Using', 'a', 'transform', '##er', 'network', 'is', 'simple']
```
این توکِنایزر زیرکلمه‌ای است: کلمات را آن‌قدر تقسیم می‌کند تا به توکِن‌هایی برسد که با واژگان آن قابل نمایش باشند. در اینجا `transformer` به دو توکِن `transform` و `##er` تقسیم می‌شود.
### از توکِن‌ها تا شناسه‌های ورودی[[from-tokens-to-input-ids]]
تبدیل به شناسه‌های ورودی با تابع `convert_tokens_to_ids()` توکِنایزر انجام می‌شود:
```py
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)
```
```python out
[7993, 170, 11303, 1200, 2443, 1110, 3014]
```
این خروجی‌ها پس از تبدیل به تِنسور مناسب فریمورک، می‌توانند همان‌طور که پیش‌تر در این فصل دیدیم به‌عنوان ورودی مدل استفاده شوند.
> [!TIP]
> ✏️ **خودتان امتحان کنید!** دو مرحله‌ی آخر (توکِن‌سازی و تبدیل به شناسه‌های ورودی) را روی جمله‌های ورودی‌ای که در بخش ۲ استفاده کردیم تکرار کنید («I've been waiting for a HuggingFace course my whole life.» و «I hate this so much!»). بررسی کنید که همان شناسه‌های ورودی قبلی را به دست می‌آورید!
## کدگشایی[[decoding]]
*کدگشایی* مسیر برعکس است: از اندیس‌های واژگان می‌خواهیم به یک رشته برسیم. این کار را می‌توان با تابع `decode()` به شکل زیر انجام داد:
```py
decoded_string = tokenizer.decode([7993, 170, 11303, 1200, 2443, 1110, 3014])
print(decoded_string)
```
```python out
'Using a Transformer network is simple'
```
توجه داشته باشید که تابع `decode` فقط اندیس‌ها را دوباره به توکِن تبدیل نمی‌کند، بلکه توکِن‌هایی را که بخشی از یک کلمه بوده‌اند نیز کنار هم می‌گذارد تا جمله‌ای خوانا تولید کند. این رفتار زمانی بسیار مفید خواهد بود که از مدل‌هایی استفاده کنیم که متن جدید پیش‌بینی می‌کنند (یا متنی که از یک پرامپت تولید شده یا برای مسائل دنباله‌به‌دنباله مانند ترجمه یا خلاصه‌سازی).
تا اینجا باید با عملیات اتمی‌ای که یک توکِنایزر می‌تواند انجام دهد آشنا شده باشید: توکِن‌سازی، تبدیل به شناسه‌ها و تبدیل شناسه‌ها به رشته. بااین‌حال، ما فقط نوک کوه یخ را دیده‌ایم. در بخش بعدی، رویکرد خود را به محدودیت‌هایش می‌رسانیم و راه‌های غلبه بر آن‌ها را بررسی می‌کنیم.

Xet Storage Details

Size:
18.2 kB
·
Xet hash:
bbf267033912e681dacb4b1020f45c4331fc56642d37d386c5a3b42519c931e0

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