Buckets:

|
download
raw
67.5 kB
# کوک کردن یک مدل زبان ماسک‌شده[[fine-tuning-a-masked-language-model]]
{#if fw === 'pt'}
<CourseFloatingBanner chapter={7}
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/chapter7/section3_pt.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter7/section3_pt.ipynb"},
]} />
{:else}
<CourseFloatingBanner chapter={7}
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/chapter7/section3_tf.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter7/section3_tf.ipynb"},
]} />
{/if}
برای بسیاری از کاربردهای NLP که شامل مدل‌های ترنسفورمر هستند، می‌توانید به سادگی یک مدل از پیش تعلیم‌دیده را از هاگینگ‌فِیس هاب بگیرید و آن را مستقیماً روی داده‌های خود برای کار مورد نظر کوک کردن کنید. مشروط بر اینکه پیکره مورد استفاده برای پیش‌تعلیم خیلی متفاوت از پیکره مورد استفاده برای کوک کردن نباشد، یادگیری انتقالی معمولاً نتایج خوبی به همراه خواهد داشت.
با این حال، چند مورد وجود دارد که قبل از آموزش یک سربرگ مختص به وظیفه، ابتدا باید مدل‌های زبانی را روی داده‌های خود کوک کردن کنید. به عنوان مثال، اگر دیتاسِت‌های شما شامل قراردادهای حقوقی یا مقالات علمی باشد، یک مدل ترنسفورمر معمولی مانند BERT معمولاً کلمات مختص به دامنه را در مجموعه شما به عنوان توکن‌های نادر در نظر می‌گیرد و عملکرد حاصل ممکن است چندان رضایت‌بخش نباشد. با کوک کردن مدل زبان روی داده‌های درون دامنه می‌توانید عملکرد بسیاری از وظایف پایین‌دستی را افزایش دهید، به این معنی که معمولاً فقط باید این مرحله را یک بار انجام دهید!
این فرآیند کوک کردن یک مدل زبانی از پیش آموزش دیده روی داده‌های درون دامنه، معمولاً _انطباق دامنه_ نامیده می‌شود. این روش در سال ۲۰۱۸ توسط [ULMFiT](https://arxiv.org/abs/1801.06146) رواج یافت، که یکی از اولین معماری‌های عصبی (مبتنی بر LSTMها) بود که یادگیری انتقالی را برای پردازش زبان طبیعی (NLP) واقعاً کارآمد می‌کرد. نمونه‌ای از انطباق دامنه با ULMFiT در تصویر زیر نشان داده شده است؛ در این بخش، کاری مشابه انجام خواهیم داد، اما با یک ترنسفورمر به جای LSTM!
در پایان این بخش، شما یک [مدل زبان نقاب‌دار](https://huggingface.co/huggingface-course/distilbert-base-uncased-finetuned-imdb?text=This+is+a+great+%5BMASK%5D.) روی هاب خواهید داشت که می‌تواند جملات را به صورت خودکار تکمیل کند، همانطور که در زیر نشان داده شده است:
بیایید شیرجه بزنیم
> نکته
> 🙋 اگر اصطلاحات «مدل‌سازی زبان نقاب‌دار» و «مدل از پیش تعلیم‌دیده» برایتان ناآشنا به نظر می‌رسد، به [فصل ۱](/course/chapter1) مراجعه کنید، جایی که ما تمام این مفاهیم اصلی را به همراه ویدیوها توضیح می‌دهیم!
## انتخاب یک مدل از پیش آموزش دیده برای مدل سازی زبان ماسک شده[[picking-a-pretrained-model-for-masked-language-modeling]]
برای شروع، بیایید یک مدل از پیش تعلیم‌دیده مناسب برای مدل‌سازی زبان ماسک‌شده انتخاب کنیم. همانطور که در تصویر زیر نشان داده شده است، می‌توانید با اعمال فیلتر "Fill-Mask" در [هاگینگ‌فِیس هاب](https://huggingface.co/models?pipeline_tag=fill-mask&sort=downloads) لیستی از کاندیداها را پیدا کنید:
اگرچه خانواده مدل‌های BERT و RoBERTa بیشترین دانلود را دارند، ما از مدلی به نام [DistilBERT](https://huggingface.co/distilbert-base-uncased) استفاده خواهیم کرد.
که می‌تواند خیلی سریع‌تر و با کمترین یا بدون هیچ افتی در عملکرد پایین‌دستی تعلیم داده شود. این مدل با استفاده از تکنیک خاصی به نام [_knowledge distillation_](https://en.wikipedia.org/wiki/Knowledge_distillation) تعلیم داده شده است، که در آن از یک "مدل معلم" بزرگ مانند BERT برای هدایت آموزش یک "مدل دانش‌آموز" که پارامترهای بسیار کمتری دارد استفاده می‌شود. توضیح جزئیات تقطیر دانش ما را در این بخش خیلی از بحث اصلی دور می‌کند، اما اگر علاقه‌مند هستید می‌توانید می‌توانید همه چیز را در مورد آن در [_پردازش زبان طبیعی با ترنسفورمرها_](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/) (که به صورت محاوره‌ای به عنوان کتاب درسی ترنسفورمرها شناخته می‌شود) بخوانید.
{#if fw === 'pt'}
بیایید با استفاده از کلاس `AutoModelForMaskedLM`، DistilBERT را دانلود کنیم:
```python
from transformers import AutoModelForMaskedLM
model_checkpoint = "distilbert-base-uncased"
model = AutoModelForMaskedLM.from_pretrained(model_checkpoint)
```
می‌توانیم با فراخوانی متد `num_parameters()` ببینیم که این مدل چند پارامتر دارد:
```python
distilbert_num_parameters = model.num_parameters() / 1_000_000
print(f"'>>> DistilBERT number of parameters: {round(distilbert_num_parameters)}M'")
print(f"'>>> BERT number of parameters: 110M'")
```
```python out
'>>> DistilBERT number of parameters: 67M'
'>>> BERT number of parameters: 110M'
```
{:else}
بیایید با استفاده از کلاس `AutoModelForMaskedLM`، DistilBERT را دانلود کنیم:
```python
from transformers import TFAutoModelForMaskedLM
model_checkpoint = "distilbert-base-uncased"
model = TFAutoModelForMaskedLM.from_pretrained(model_checkpoint)
```
می‌توانیم با فراخوانی متد `summary()` ببینیم که این مدل چند پارامتر دارد:
```python
model.summary()
```
```python out
Model: "tf_distil_bert_for_masked_lm"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
distilbert (TFDistilBertMain multiple 66362880
_________________________________________________________________
vocab_transform (Dense) multiple 590592
_________________________________________________________________
vocab_layer_norm (LayerNorma multiple 1536
_________________________________________________________________
vocab_projector (TFDistilBer multiple 23866170
=================================================================
Total params: 66,985,530
Trainable params: 66,985,530
Non-trainable params: 0
_________________________________________________________________
```
{/if}
با حدود ۶۷ میلیون پارامتر، DistilBERT تقریباً دو برابر کوچکتر از مدل پایه BERT است، که تقریباً به معنای افزایش دو برابری سرعت آموزش است -- عالی! حال بیایید ببینیم این مدل چه نوع توکن‌هایی را پیش‌بینی می‌کند که محتمل‌ترین تکمیل‌های یک نمونه کوچک از متن هستند:
```python
text = "This is a great [MASK]."
```
ما به عنوان انسان، می‌توانیم احتمالات زیادی را برای توکن `[MASK]` تصور کنیم، مانند "روز"، "سوار شدن" یا "نقاشی". برای مدل‌های از پیش تعلیم‌دیده، پیش‌بینی‌ها به پیکره‌ای که مدل بر اساس آن آموزش دیده است بستگی دارد، زیرا یاد می‌گیرد الگوهای آماری موجود در داده‌ها را انتخاب کند. مانند BERT، DistilBERT نیز بر روی دیتاسِت‌های [ویکی‌پدیای انگلیسی](https://huggingface.co/datasets/wikipedia) و [BookCorpus](https://huggingface.co/datasets/bookcorpus) از پیش آموزش دیده است، بنابراین انتظار داریم پیش‌بینی‌های `[MASK]` بازتاب‌دهنده‌ی این حوزه‌ها باشند. برای پیش‌بینی ماسک، به توکن‌ساز DistilBERT نیاز داریم تا ورودی‌های مدل را تولید کند، بنابراین بیایید آن را نیز از هاب دانلود کنیم:
```python
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
```
با یک توکن‌ساز و یک مدل، اکنون می‌توانیم مثال متنی خود را به مدل ارسال کنیم، لوجیت‌ها را استخراج کنیم و ۵ کاندید برتر را چاپ کنیم:
{#if fw === 'pt'}
```python
import torch
inputs = tokenizer(text, return_tensors="pt")
token_logits = model(**inputs).logits
# Find the location of [MASK] and extract its logits
mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]
mask_token_logits = token_logits[0, mask_token_index, :]
# Pick the [MASK] candidates with the highest logits
top_5_tokens = torch.topk(mask_token_logits, 5, dim=1).indices[0].tolist()
for token in top_5_tokens:
print(f"'>>> {text.replace(tokenizer.mask_token, tokenizer.decode([token]))}'")
```
{:else}
```python
import numpy as np
import tensorflow as tf
inputs = tokenizer(text, return_tensors="np")
token_logits = model(**inputs).logits
# Find the location of [MASK] and extract its logits
mask_token_index = np.argwhere(inputs["input_ids"] == tokenizer.mask_token_id)[0, 1]
mask_token_logits = token_logits[0, mask_token_index, :]
# Pick the [MASK] candidates with the highest logits
# We negate the array before argsort to get the largest, not the smallest, logits
top_5_tokens = np.argsort(-mask_token_logits)[:5].tolist()
for token in top_5_tokens:
print(f">>> {text.replace(tokenizer.mask_token, tokenizer.decode([token]))}")
```
{/if}
```python out
'>>> This is a great deal.'
'>>> This is a great success.'
'>>> This is a great adventure.'
'>>> This is a great idea.'
'>>> This is a great feat.'
```
از خروجی‌ها می‌توانیم ببینیم که پیش‌بینی‌های مدل به اصطلاحات روزمره اشاره دارد، که با توجه به اساس ویکی‌پدیای انگلیسی شاید تعجب‌آور نباشد. بیایید ببینیم چگونه می‌توانیم این حوزه را به چیزی کمی خاص‌تر تغییر دهیم - نقدهای فیلم بسیار قطبی!
## دیتاسِت‌ها[[the-dataset]]
برای نمایش انطباق دامنه، از دیتاسِت معروف [Large Movie Review Dataset](https://huggingface.co/datasets/imdb) (یا به اختصار IMDb) استفاده خواهیم کرد، که مجموعه‌ای از نقدهای فیلم است که اغلب برای سنجش مدل‌های تحلیل احساسات استفاده می‌شود. با کوک کردن DistilBERT روی این دیتاسِت، انتظار داریم مدل زبانی واژگان خود را از داده‌های واقعی ویکی‌پدیا که از قبل روی آن آموزش دیده است، با عناصر ذهنی‌تر نقدهای فیلم تطبیق دهد. می‌توانیم داده‌ها از هاگینگ‌فِیس هاب با تابع `load_dataset()` از دیتاسِت‌های 🤗:
```python
from datasets import load_dataset
imdb_dataset = load_dataset("imdb")
imdb_dataset
```
```python out
DatasetDict({
train: Dataset({
features: ['text', 'label'],
num_rows: 25000
})
test: Dataset({
features: ['text', 'label'],
num_rows: 25000
})
unsupervised: Dataset({
features: ['text', 'label'],
num_rows: 50000
})
})
```
می‌توانیم ببینیم که تقسیم‌بندی‌های `train` و `test` هر کدام شامل ۲۵۰۰۰ نقد هستند، در حالی که یک تقسیم‌بندی بدون برچسب به نام `unsupervised` وجود دارد که شامل ۵۰۰۰۰ نقد است. بیایید نگاهی به چند نمونه بیندازیم تا ایده‌ای از نوع متنی که با آن سروکار داریم، به دست آوریم. همانطور که در فصل‌های قبلی دوره انجام داده‌ایم، توابع `Dataset.shuffle()` و `Dataset.select()` را برای ایجاد یک نمونه تصادفی زنجیره می‌کنیم:
```python
sample = imdb_dataset["train"].shuffle(seed=42).select(range(3))
for row in sample:
print(f"\n'>>> Review: {row['text']}'")
print(f"'>>> Label: {row['label']}'")
```
```python out
'>>> Review: This is your typical Priyadarshan movie--a bunch of loony characters out on some silly mission. His signature climax has the entire cast of the film coming together and fighting each other in some crazy moshpit over hidden money. Whether it is a winning lottery ticket in Malamaal Weekly, black money in Hera Pheri, "kodokoo" in Phir Hera Pheri, etc., etc., the director is becoming ridiculously predictable. Don\'t get me wrong; as clichéd and preposterous his movies may be, I usually end up enjoying the comedy. However, in most his previous movies there has actually been some good humor, (Hungama and Hera Pheri being noteworthy ones). Now, the hilarity of his films is fading as he is using the same formula over and over again.<br /><br />Songs are good. Tanushree Datta looks awesome. Rajpal Yadav is irritating, and Tusshar is not a whole lot better. Kunal Khemu is OK, and Sharman Joshi is the best.'
'>>> Label: 0'
'>>> Review: Okay, the story makes no sense, the characters lack any dimensionally, the best dialogue is ad-libs about the low quality of movie, the cinematography is dismal, and only editing saves a bit of the muddle, but Sam" Peckinpah directed the film. Somehow, his direction is not enough. For those who appreciate Peckinpah and his great work, this movie is a disappointment. Even a great cast cannot redeem the time the viewer wastes with this minimal effort.<br /><br />The proper response to the movie is the contempt that the director San Peckinpah, James Caan, Robert Duvall, Burt Young, Bo Hopkins, Arthur Hill, and even Gig Young bring to their work. Watch the great Peckinpah films. Skip this mess.'
'>>> Label: 0'
'>>> Review: I saw this movie at the theaters when I was about 6 or 7 years old. I loved it then, and have recently come to own a VHS version. <br /><br />My 4 and 6 year old children love this movie and have been asking again and again to watch it. <br /><br />I have enjoyed watching it again too. Though I have to admit it is not as good on a little TV.<br /><br />I do not have older children so I do not know what they would think of it. <br /><br />The songs are very cute. My daughter keeps singing them over and over.<br /><br />Hope this helps.'
'>>> Label: 1'
```
بله، اینها قطعاً نقد فیلم هستند، و اگر به اندازه کافی سن داشته باشید، حتی ممکن است نظر آخرین نقد در مورد داشتن نسخه VHS را درک کنید 😜! اگرچه برای مدل‌سازی زبان به برچسب‌ها نیازی نداریم، اما از همین الان می‌توانیم ببینیم که `0` نشان‌دهنده یک نقد منفی است، در حالی که `1` مربوط به یک نقد مثبت است.
> نکته
> ✏️ **امتحانش کنید!** یک نمونه تصادفی از تقسیم‌بندی `unsupervised` ایجاد کنید و تأیید کنید که برچسب‌ها نه `0` هستند و نه `1`. در حین انجام این کار، می‌توانید بررسی کنید که برچسب‌ها در تقسیم‌بندی‌های `train` و `test` واقعاً `0` یا `1` هستند -- این یک بررسی سلامت عقل مفید است که هر متخصص NLP باید در شروع یک پروژه جدید انجام دهد!
حالا که نگاهی سریع به داده‌ها انداختیم، بیایید به آماده‌سازی آن‌ها برای مدل‌سازی زبان پنهان بپردازیم. همانطور که خواهیم دید، در مقایسه با وظایف طبقه‌بندی توالی که در [فصل 3](/course/chapter3) دیدیم، مراحل دیگری نیز وجود دارد که باید انجام شود. شروع می‌کنیم!
## پیش‌پردازش داده‌ها[[preprocessing-the-data]]
برای هر دو مدل‌سازی زبان خودرگرسیون و ماسک‌شده، یک مرحله پیش‌پردازش رایج، الحاق همه مثال‌ها و سپس تقسیم کل مجموعه به قطعاتی با اندازه مساوی است. این کاملاً با رویکرد معمول ما که در آن صرفاً مثال‌های منفرد را توکنیزه می‌کنیم، متفاوت است. چرا همه چیز را با هم الحاق کنیم؟ دلیلش این است که اگر مثال‌های منفرد خیلی طولانی باشند، ممکن است کوتاه شوند و این منجر به از دست رفتن ... می‌شود. اطلاعاتی که ممکن است برای کار مدل‌سازی زبان مفید باشد!
بنابراین برای شروع، ابتدا طبق معمول، دیتاسِت‌های خود را توکنیزه می‌کنیم، اما _بدون_ تنظیم گزینه `truncation=True` در توکن‌ساز خود. همچنین شناسه‌های کلمات را در صورت موجود بودن، دریافت خواهیم کرد ((که اگر از یک توکن‌ساز سریع استفاده کنیم، همانطور که در [فصل 6](/course/chapter6/3) توضیح داده شده است، این کار را انجام خواهیم داد)، زیرا بعداً برای انجام پوشش کامل کلمه به آنها نیاز خواهیم داشت. این را در یک تابع ساده قرار می‌دهیم و در حین انجام این کار، `text` و `label` را حذف می‌کنیم. ستون‌ها، چون دیگر به آنها نیازی نداریم:
```python
def tokenize_function(examples):
result = tokenizer(examples["text"])
if tokenizer.is_fast:
result["word_ids"] = [result.word_ids(i) for i in range(len(result["input_ids"]))]
return result
# Use batched=True to activate fast multithreading!
tokenized_datasets = imdb_dataset.map(
tokenize_function, batched=True, remove_columns=["text", "label"]
)
tokenized_datasets
```
```python out
DatasetDict({
train: Dataset({
features: ['attention_mask', 'input_ids', 'word_ids'],
num_rows: 25000
})
test: Dataset({
features: ['attention_mask', 'input_ids', 'word_ids'],
num_rows: 25000
})
unsupervised: Dataset({
features: ['attention_mask', 'input_ids', 'word_ids'],
num_rows: 50000
})
})
```
از آنجایی که DistilBERT یک مدل شبیه به BERT است، می‌توانیم ببینیم که متون رمزگذاری شده شامل `input_ids` و `attention_mask` که در فصل‌های دیگر دیده‌ایم، و همچنین `word_ids` که خودمان اضافه کرده‌ایم، هستند.
حالا که نقدهای فیلم خود را توکنیزه کرده‌ایم، قدم بعدی گروه‌بندی همه آنها و تقسیم نتیجه به قطعات کوچک‌تر است. اما این قطعات باید چقدر بزرگ باشند؟ این در نهایت توسط میزان حافظه GPU موجود تعیین می‌شود، اما یک نقطه شروع خوب این است که ببینیم حداکثر اندازه متن مدل چقدر است. این را می‌توان با بررسی ویژگی `model_max_length` توکنایزر استنباط کرد:
```python
tokenizer.model_max_length
```
```python out
512
```
این مقدار از فایل *توکِن‌ساز_config.json* مرتبط با یک Checkpoint گرفته شده است؛ در این حالت می‌توانیم ببینیم که اندازه context، درست مانند BERT، 512 توکن است.
> نکته
> ✏️ **امتحانش کنید!** برخی از مدل‌های ترنسفورمر، مانند [BigBird](https://huggingface.co/google/bigbird-roberta-base) و [Longformer](https://huggingface.co/allenai/longformer-base-4096)، طول متن بسیار طولانی‌تری نسبت به BERT و سایر مدل‌های اولیه ترنسفورمر دارند. توکن‌ساز را برای یکی از این نقاط بررسی نمونه‌سازی کنید و تأیید کنید که `model_max_length` با آنچه در کارت مدل آن ذکر شده است، مطابقت دارد.
بنابراین، برای اجرای آزمایش‌هایمان روی پردازنده‌های گرافیکی مانند پردازنده‌های موجود در Google Colab، چیزی کمی کوچک‌تر انتخاب می‌کنیم که بتواند در حافظه جا شود:
```python
chunk_size = 128
```
> WARNING
> توجه داشته باشید که استفاده از اندازه کوچک بخش می‌تواند در سناریوهای دنیای واقعی مضر باشد، بنابراین باید از اندازه‌ای استفاده کنید که با مورد استفاده‌ای که مدل خود را برای آن اعمال خواهید کرد، مطابقت داشته باشد.
حالا به بخش جالب ماجرا می‌رسیم. برای نشان دادن نحوه‌ی عملکرد الحاق، بیایید چند نظر را از مجموعه‌ی آموزشی توکن‌سازی‌شده‌ی خود بگیریم و تعداد توکن‌ها را برای هر نظر چاپ کنیم:
```python
# Slicing produces a list of lists for each feature
tokenized_samples = tokenized_datasets["train"][:3]
for idx, sample in enumerate(tokenized_samples["input_ids"]):
print(f"'>>> Review {idx} length: {len(sample)}'")
```
```python out
'>>> Review 0 length: 200'
'>>> Review 1 length: 559'
'>>> Review 2 length: 192'
```
سپس می‌توانیم تمام این مثال‌ها را با یک درک ساده از فرهنگ لغت، به صورت زیر به هم پیوند دهیم:
```python
concatenated_examples = {
k: sum(tokenized_samples[k], []) for k in tokenized_samples.keys()
}
total_length = len(concatenated_examples["input_ids"])
print(f"'>>> Concatenated reviews length: {total_length}'")
```
```python out
'>>> Concatenated reviews length: 951'
```
عالی، طول کل بررسی شد -- حالا بیایید بررسی‌های به هم پیوسته را به تکه‌هایی با اندازه داده شده توسط `chunk_size` تقسیم کنیم. برای انجام این کار، روی ویژگی‌های موجود در `concatenated_examples` تکرار می‌کنیم و از یک درک لیست برای ایجاد برش‌هایی از هر ویژگی استفاده می‌کنیم. نتیجه، یک دیکشنری از تکه‌ها برای هر ویژگی است:
```python
chunks = {
k: [t[i : i + chunk_size] for i in range(0, total_length, chunk_size)]
for k, t in concatenated_examples.items()
}
for chunk in chunks["input_ids"]:
print(f"'>>> Chunk length: {len(chunk)}'")
```
```python out
'>>> Chunk length: 128'
'>>> Chunk length: 128'
'>>> Chunk length: 128'
'>>> Chunk length: 128'
'>>> Chunk length: 128'
'>>> Chunk length: 128'
'>>> Chunk length: 128'
'>>> Chunk length: 55'
```
همانطور که در این مثال می‌بینید، آخرین قطعه معمولاً کوچکتر از حداکثر اندازه قطعه خواهد بود. دو استراتژی اصلی برای مقابله با این مشکل وجود دارد:
* اگر آخرین تکه کوچکتر از `chunk_size` است، آن را حذف کن.
* آخرین تکه را تا زمانی که طول آن برابر با `chunk_size` شود، لایه گذاری کنید.
ما در اینجا رویکرد اول را در پیش می‌گیریم، بنابراین بیایید تمام منطق فوق را در یک تابع واحد که می‌توانیم روی دیتاسِت‌های توکن‌شده خود اعمال کنیم، قرار دهیم:
```python
def group_texts(examples):
# Concatenate all texts
concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}
# Compute length of concatenated texts
total_length = len(concatenated_examples[list(examples.keys())[0]])
# We drop the last chunk if it's smaller than chunk_size
total_length = (total_length // chunk_size) * chunk_size
# Split by chunks of max_len
result = {
k: [t[i : i + chunk_size] for i in range(0, total_length, chunk_size)]
for k, t in concatenated_examples.items()
}
# Create a new labels column
result["labels"] = result["input_ids"].copy()
return result
```
توجه داشته باشید که در آخرین مرحله از `group_texts()`، یک ستون جدید `labels` ایجاد می‌کنیم که یک کپی از ستون `input_ids` است. همانطور که به زودی خواهیم دید، دلیل این امر آن است که در مدل‌سازی زبان ماسک‌شده، هدف پیش‌بینی توکن‌های ماسک‌شده تصادفی در دسته ورودی است و با ایجاد یک ستون `labels`، حقیقت پایه را برای مدل زبانی خود فراهم می‌کنیم تا از آن یاد بگیرد.
اکنون بیایید `group_texts()` را با استفاده از تابع `Dataset.map()` قابل اعتماد خود، روی دیتاسِت‌های توکن‌سازی شده خود اعمال کنیم:
```python
lm_datasets = tokenized_datasets.map(group_texts, batched=True)
lm_datasets
```
```python out
DatasetDict({
train: Dataset({
features: ['attention_mask', 'input_ids', 'labels', 'word_ids'],
num_rows: 61289
})
test: Dataset({
features: ['attention_mask', 'input_ids', 'labels', 'word_ids'],
num_rows: 59905
})
unsupervised: Dataset({
features: ['attention_mask', 'input_ids', 'labels', 'word_ids'],
num_rows: 122963
})
})
```
می‌توانید ببینید که گروه‌بندی و سپس قطعه‌بندی متون، نمونه‌های بسیار بیشتری نسبت به ۲۵۰۰۰ نمونه‌ی اولیه‌ی ما برای تقسیم‌بندی‌های `train` و `test` تولید کرده است. دلیلش این است که اکنون نمونه‌هایی داریم که شامل _توکن‌های پیوسته_ هستند که در چندین نمونه از مجموعه‌ی اصلی قرار دارند. می‌توانید این را به صراحت با جستجوی توکن‌های ویژه‌ی `[SEP]` و `[CLS]` در یکی از قطعه‌ها مشاهده کنید:
```python
tokenizer.decode(lm_datasets["train"][1]["input_ids"])
```
```python out
".... at.......... high. a classic line : inspector : i'm here to sack one of your teachers. student : welcome to bromwell high. i expect that many adults of my age think that bromwell high is far fetched. what a pity that it isn't! [SEP] [CLS] homelessness ( or houselessness as george carlin stated ) has been an issue for years but never a plan to help those on the street that were once considered human who did everything from going to school, work, or vote for the matter. most people think of the homeless"
```
در این مثال می‌توانید دو نقد فیلم را ببینید که با هم همپوشانی دارند، یکی درباره یک فیلم دبیرستانی و دیگری درباره بی‌خانمانی. بیایید همچنین بررسی کنیم که برچسب‌ها برای مدل‌سازی زبان پنهان چگونه به نظر می‌رسند:
```python out
tokenizer.decode(lm_datasets["train"][1]["labels"])
```
```python out
".... at.......... high. a classic line : inspector : i'm here to sack one of your teachers. student : welcome to bromwell high. i expect that many adults of my age think that bromwell high is far fetched. what a pity that it isn't! [SEP] [CLS] homelessness ( or houselessness as george carlin stated ) has been an issue for years but never a plan to help those on the street that were once considered human who did everything from going to school, work, or vote for the matter. most people think of the homeless"
```
همانطور که از تابع `group_texts()` ما در بالا انتظار می‌رود، این تابع مشابه `input_ids` رمزگشایی شده به نظر می‌رسد -- اما در این صورت مدل ما چگونه می‌تواند چیزی یاد بگیرد؟ ما یک مرحله کلیدی را از دست داده‌ایم: قرار دادن توکن‌های `[MASK]` در موقعیت‌های تصادفی در ورودی‌ها! بیایید ببینیم چگونه می‌توانیم این کار را در حین کوک کردن با استفاده از یک گردآورنده داده ویژه انجام دهیم.
## کوک کردن DistilBERT با رابط برنامه‌نویسی کاربردی `Trainer`[[fine-tuning-distilbert-with-the-trainer-api]]
کوک کردن یک مدل زبان ماسک‌شده تقریباً مشابه کوک کردن یک مدل طبقه‌بندی توالی است، همانطور که در [فصل ۳](/course/chapter3) انجام دادیم. تنها تفاوت این است که ما به یک گردآورنده داده ویژه نیاز داریم که بتواند به طور تصادفی برخی از توکن‌ها را در هر دسته از متون ماسک کند. خوشبختانه، 🤗 ترنسفورمرز با یک `DataCollatorForLanguageModeling` اختصاصی برای این کار ارائه می‌شود. ما فقط باید توکنایزر و یک آرگومان `mlm_probability` را به آن منتقل کنیم. که مشخص می‌کند چه کسری از توکن‌ها باید پنهان شوند. ما ۱۵٪ را انتخاب می‌کنیم، که مقداری است که برای BERT استفاده می‌شود و یک انتخاب رایج در مقالات است:
```python
from transformers import DataCollatorForLanguageModeling
data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm_probability=0.15)
```
برای اینکه ببینیم ماسک تصادفی چگونه کار می‌کند، بیایید چند مثال به گردآورنده داده‌ها بدهیم. از آنجایی که انتظار لیستی از `dict`ها را دارد، که در آن هر `dict` نشان دهنده یک تکه متن پیوسته است، ابتدا قبل از اینکه دسته را به گردآورنده بدهیم، روی دیتاسِت‌ها تکرار می‌کنیم. کلید `"word_ids"` را برای این گردآورنده داده‌ها حذف می‌کنیم زیرا انتظار آن را ندارد:
```python
samples = [lm_datasets["train"][i] for i in range(2)]
for sample in samples:
_ = sample.pop("word_ids")
for chunk in data_collator(samples)["input_ids"]:
print(f"\n'>>> {tokenizer.decode(chunk)}'")
```
```python output
'>>> [CLS] bromwell [MASK] is a cartoon comedy. it ran at the same [MASK] as some other [MASK] about school life, [MASK] as " teachers ". [MASK] [MASK] [MASK] in the teaching [MASK] lead [MASK] to believe that bromwell high\'[MASK] satire is much closer to reality than is " teachers ". the scramble [MASK] [MASK] financially, the [MASK]ful students whogn [MASK] right through [MASK] pathetic teachers\'pomp, the pettiness of the whole situation, distinction remind me of the schools i knew and their students. when i saw [MASK] episode in [MASK] a student repeatedly tried to burn down the school, [MASK] immediately recalled. [MASK]...'
'>>> .... at.. [MASK]... [MASK]... high. a classic line plucked inspector : i\'[MASK] here to [MASK] one of your [MASK]. student : welcome to bromwell [MASK]. i expect that many adults of my age think that [MASK]mwell [MASK] is [MASK] fetched. what a pity that it isn\'t! [SEP] [CLS] [MASK]ness ( or [MASK]lessness as george 宇in stated )公 been an issue for years but never [MASK] plan to help those on the street that were once considered human [MASK] did everything from going to school, [MASK], [MASK] vote for the matter. most people think [MASK] the homeless'
```
عالی بود، کار کرد! می‌توانیم ببینیم که توکن `[MASK]` به صورت تصادفی در مکان‌های مختلف متن ما درج شده است. اینها توکن‌هایی هستند که مدل ما باید در طول آموزش پیش‌بینی کند -- و زیبایی ابزار گردآوری داده‌ها این است که درج `[MASK]` را با هر دسته تصادفی می‌کند!
> نکته
> ✏️ **امتحانش کنید!** قطعه کد بالا را چندین بار اجرا کنید تا ببینید که پوشش تصادفی دقیقاً جلوی چشمانتان اتفاق می‌افتد! همچنین متد `tokenizer.decode()` را با `tokenizer.convert_ids_to_tokens()` جایگزین کنید تا ببینید که گاهی اوقات یک توکن از یک کلمه مشخص پوشش داده می‌شود و بقیه نه.
{#if fw === 'pt'}
یکی از عوارض جانبی پوشش تصادفی این است که معیارهای ارزیابی ما هنگام استفاده از `Trainer` قطعی نخواهند بود، زیرا ما از یک گردآورنده داده برای مجموعه‌های آموزش و آزمایش استفاده می‌کنیم. بعداً، وقتی به کوک کردن با 🤗 Accelerate نگاه می‌کنیم، خواهیم دید که چگونه می‌توانیم از انعطاف‌پذیری یک حلقه ارزیابی سفارشی برای ثابت کردن تصادفی بودن استفاده کنیم.
{/if}
هنگام آموزش مدل‌ها برای مدل‌سازی زبان ماسک‌شده، یکی از تکنیک‌هایی که می‌توان استفاده کرد، ماسک کردن کل کلمات با هم است، نه فقط توکن‌های تکی. این رویکرد _پوشش کل کلمه_ نامیده می‌شود. اگر بخواهیم از پوشش کل کلمه استفاده کنیم، باید خودمان یک گردآورنده داده بسازیم. گردآورنده داده فقط تابعی است که لیستی از نمونه‌ها را می‌گیرد و آنها را به یک دسته تبدیل می‌کند، بنابراین بیایید همین حالا این کار را انجام دهیم! ما از شناسه‌های کلمه محاسبه شده استفاده خواهیم کرد. قبلاً برای ایجاد یک نگاشت بین اندیس‌های کلمات و توکن‌های مربوطه، سپس به صورت تصادفی تصمیم بگیرید که کدام کلمات را ماسک کنید و آن ماسک را روی ورودی‌ها اعمال کنید. توجه داشته باشید که برچسب‌ها همه `-100` هستند، به جز آنهایی که مربوط به کلمات ماسک هستند.
{#if fw === 'pt'}
```py
import collections
import numpy as np
from transformers import default_data_collator
wwm_probability = 0.2
def whole_word_masking_data_collator(features):
for feature in features:
word_ids = feature.pop("word_ids")
# Create a map between words and corresponding token indices
mapping = collections.defaultdict(list)
current_word_index = -1
current_word = None
for idx, word_id in enumerate(word_ids):
if word_id is not None:
if word_id != current_word:
current_word = word_id
current_word_index += 1
mapping[current_word_index].append(idx)
# Randomly mask words
mask = np.random.binomial(1, wwm_probability, (len(mapping),))
input_ids = feature["input_ids"]
labels = feature["labels"]
new_labels = [-100] * len(labels)
for word_id in np.where(mask)[0]:
word_id = word_id.item()
for idx in mapping[word_id]:
new_labels[idx] = labels[idx]
input_ids[idx] = tokenizer.mask_token_id
feature["labels"] = new_labels
return default_data_collator(features)
```
{:else}
```py
import collections
import numpy as np
from transformers.data.data_collator import tf_default_data_collator
wwm_probability = 0.2
def whole_word_masking_data_collator(features):
for feature in features:
word_ids = feature.pop("word_ids")
# Create a map between words and corresponding token indices
mapping = collections.defaultdict(list)
current_word_index = -1
current_word = None
for idx, word_id in enumerate(word_ids):
if word_id is not None:
if word_id != current_word:
current_word = word_id
current_word_index += 1
mapping[current_word_index].append(idx)
# Randomly mask words
mask = np.random.binomial(1, wwm_probability, (len(mapping),))
input_ids = feature["input_ids"]
labels = feature["labels"]
new_labels = [-100] * len(labels)
for word_id in np.where(mask)[0]:
word_id = word_id.item()
for idx in mapping[word_id]:
new_labels[idx] = labels[idx]
input_ids[idx] = tokenizer.mask_token_id
feature["labels"] = new_labels
return tf_default_data_collator(features)
```
{/if}
در مرحله بعد، می‌توانیم آن را روی همان نمونه‌های قبلی امتحان کنیم:
```py
samples = [lm_datasets["train"][i] for i in range(2)]
batch = whole_word_masking_data_collator(samples)
for chunk in batch["input_ids"]:
print(f"\n'>>> {tokenizer.decode(chunk)}'")
```
```python out
'>>> [CLS] bromwell high is a cartoon comedy [MASK] it ran at the same time as some other programs about school life, such as " teachers ". my 35 years in the teaching profession lead me to believe that bromwell high\'s satire is much closer to reality than is " teachers ". the scramble to survive financially, the insightful students who can see right through their pathetic teachers\'pomp, the pettiness of the whole situation, all remind me of the schools i knew and their students. when i saw the episode in which a student repeatedly tried to burn down the school, i immediately recalled.....'
'>>> .... [MASK] [MASK] [MASK] [MASK]....... high. a classic line : inspector : i\'m here to sack one of your teachers. student : welcome to bromwell high. i expect that many adults of my age think that bromwell high is far fetched. what a pity that it isn\'t! [SEP] [CLS] homelessness ( or houselessness as george carlin stated ) has been an issue for years but never a plan to help those on the street that were once considered human who did everything from going to school, work, or vote for the matter. most people think of the homeless'
```
> نکته
> ✏️ **امتحانش کنید!** قطعه کد بالا را چندین بار اجرا کنید تا ببینید که ماسک‌سازی تصادفی دقیقاً جلوی چشمانتان اتفاق می‌افتد! همچنین متد `tokenizer.decode()` را با `tokenizer.convert_ids_to_tokens()` جایگزین کنید تا ببینید که توکن‌های یک کلمه مشخص همیشه با هم ماسک می‌شوند.
حالا که دو جمع‌آوری‌کننده داده داریم، بقیه مراحل کوک کردن استاندارد هستند. اگر به اندازه کافی خوش شانس نباشید که یک پردازنده گرافیکی افسانه‌ای P100 😭 داشته باشید، آموزش در Google Colab می‌تواند مدتی طول بکشد، بنابراین ابتدا اندازه مجموعه آموزشی را به چند هزار مثال کاهش می‌دهیم. نگران نباشید، ما هنوز یک مدل زبان نسبتاً مناسب خواهیم داشت! یک راه سریع برای کاهش نمونه یک دیتاسِت در 🤗 دیتاسِت‌ها از طریق تابع `Dataset.train_test_split()` است که در [فصل ۵](/course/chapter5):
```python
train_size = 10_000
test_size = int(0.1 * train_size)
downsampled_dataset = lm_datasets["train"].train_test_split(
train_size=train_size, test_size=test_size, seed=42
)
downsampled_dataset
```
```python out
DatasetDict({
train: Dataset({
features: ['attention_mask', 'input_ids', 'labels', 'word_ids'],
num_rows: 10000
})
test: Dataset({
features: ['attention_mask', 'input_ids', 'labels', 'word_ids'],
num_rows: 1000
})
})
```
این به طور خودکار تقسیم‌بندی‌های جدید `train` و `test` را ایجاد کرده است، با اندازه مجموعه آموزشی که روی 10000 نمونه تنظیم شده و اعتبارسنجی که روی 10٪ از آن تنظیم شده است -- اگر پردازنده گرافیکی قدرتمندی دارید، می‌توانید این مقدار را افزایش دهید! کار بعدی که باید انجام دهیم این است که به هاگینگ‌فِیس هاب وارد شوید. اگر این کد را در یک نوت‌بوک اجرا می‌کنید، می‌توانید این کار را با تابع کاربردی زیر انجام دهید:
```python
from huggingface_hub import notebook_login
notebook_login()
```
که یک ویجت را نمایش می‌دهد که می‌توانید اطلاعات کاربری خود را در آن وارد کنید. همچنین می‌توانید دستور زیر را اجرا کنید:
```
huggingface-cli login
```
در ترمینال مورد علاقه‌تان و وارد آن شوید.
{#if fw === 'tf'}
پس از ورود به سیستم، می‌توانیم دیتاسِت‌های `tf.data` خود را ایجاد کنیم. برای انجام این کار، از روش `prepare_tf_dataset()` استفاده خواهیم کرد که از مدل ما برای استنباط خودکار ستون‌هایی که باید در دیتاسِت‌ها قرار گیرند، استفاده می‌کند. اگر می‌خواهید دقیقاً کنترل کنید که از کدام ستون‌ها استفاده شود، می‌توانید به جای آن از روش `Dataset.to_tf_dataset()` استفاده کنید. برای ساده نگه داشتن کارها، ما در اینجا فقط از تلفیق‌کننده داده استاندارد استفاده خواهیم کرد، اما می‌توانید تلفیق‌کننده پوشش کامل کلمه را نیز امتحان کنید و نتایج را به عنوان یک تمرین مقایسه کنید:
```python
tf_train_dataset = model.prepare_tf_dataset(
downsampled_dataset["train"],
collate_fn=data_collator,
shuffle=True,
batch_size=32,
)
tf_eval_dataset = model.prepare_tf_dataset(
downsampled_dataset["test"],
collate_fn=data_collator,
shuffle=False,
batch_size=32,
)
```
در مرحله بعد، ابرپارامترهای آموزشی خود را تنظیم کرده و مدل خود را کامپایل می‌کنیم. ما از تابع `create_optimizer()` از کتابخانه 🤗 ترنسفورمرs استفاده می‌کنیم که یک بهینه‌ساز `AdamW` با نرخ یادگیری خطی کاهشی به ما می‌دهد. ما همچنین از تابع زیان داخلی مدل استفاده می‌کنیم که در صورت عدم تعیین زیان به عنوان آرگومان برای `compile()`، پیش‌فرض است و دقت آموزش را روی `"mixed_float16"` تنظیم می‌کنیم. توجه داشته باشید که اگر از یک پردازنده گرافیکی Colab یا پردازنده گرافیکی دیگری که این تابع را ندارد استفاده می‌کنید، پشتیبانی از float16 شتاب‌یافته، احتمالاً باید آن خط را کامنت کنید.
علاوه بر این، ما یک `PushToHubCallback` راه‌اندازی کردیم که مدل را پس از هر دوره در هاب ذخیره می‌کند. می‌توانید نام مخزنی را که می‌خواهید به آن ارسال کنید با آرگومان `hub_model_id` مشخص کنید (به طور خاص، برای ارسال به یک سازمان باید از این آرگومان استفاده کنید). به عنوان مثال، برای ارسال مدل به سازمان [`huggingface-course`](https://huggingface.co/huggingface-course)، ما `hub_model_id="huggingface-course/distilbert-finetuned-imdb"` را اضافه کردیم. به طور پیش‌فرض، مخزن مورد استفاده در فضای نام شما قرار خواهد گرفت و نام آن از ... گرفته می‌شود. دایرکتوری خروجی که شما تنظیم کرده‌اید، بنابراین در مورد ما `"lewtun/distilbert-finetuned-imdb"` خواهد بود.
```python
from transformers import create_optimizer
from transformers.keras_callbacks import PushToHubCallback
import tensorflow as tf
num_train_steps = len(tf_train_dataset)
optimizer, schedule = create_optimizer(
init_lr=2e-5,
num_warmup_steps=1_000,
num_train_steps=num_train_steps,
weight_decay_rate=0.01,
)
model.compile(optimizer=optimizer)
# Train in mixed-precision float16
tf.keras.mixed_precision.set_global_policy("mixed_float16")
model_name = model_checkpoint.split("/")[-1]
callback = PushToHubCallback(
output_dir=f"{model_name}-finetuned-imdb", tokenizer=tokenizer
)
```
اکنون آماده اجرای `model.fit()` هستیم -- اما قبل از انجام این کار، بیایید نگاهی مختصر به _perplexity_ بیندازیم که یک معیار رایج برای ارزیابی عملکرد مدل‌های زبانی است.
{:else}
پس از ورود به سیستم، می‌توانیم آرگومان‌های مربوط به `Trainer` را مشخص کنیم:
```python
from transformers import TrainingArguments
batch_size = 64
# Show the training loss with every epoch
logging_steps = len(downsampled_dataset["train"]) // batch_size
model_name = model_checkpoint.split("/")[-1]
training_args = TrainingArguments(
output_dir=f"{model_name}-finetuned-imdb",
overwrite_output_dir=True,
evaluation_strategy="epoch",
learning_rate=2e-5,
weight_decay=0.01,
per_device_train_batch_size=batch_size,
per_device_eval_batch_size=batch_size,
push_to_hub=True,
fp16=True,
logging_steps=logging_steps,
)
```
در اینجا ما چند گزینه پیش‌فرض، از جمله `logging_steps` را تغییر دادیم تا مطمئن شویم که با هر دوره، افت آموزش را ردیابی می‌کنیم. ما همچنین از `fp16=True` برای فعال کردن آموزش با دقت مختلط استفاده کرده‌ایم که باعث افزایش سرعت ما می‌شود. به طور پیش‌فرض، `Trainer` هر ستونی را که بخشی از روش `forward()` مدل نیست، حذف می‌کند. این بدان معناست که اگر از کل‌نگار پوشش‌دهنده کلمه استفاده می‌کنید، باید `remove_unused_columns=False` را نیز تنظیم کنید تا مطمئن شوید که این کار را انجام نمی‌دهیم. ستون `word_ids` را در طول آموزش از دست بدهید.
توجه داشته باشید که می‌توانید نام مخزنی را که می‌خواهید به آن ارسال کنید با آرگومان `hub_model_id` مشخص کنید (به طور خاص، برای ارسال به یک سازمان باید از این آرگومان استفاده کنید). برای مثال، وقتی مدل را به سازمان [`huggingface-course`](https://huggingface.co/huggingface-course) ارسال کردیم، `hub_model_id="huggingface-course/distilbert-finetuned-imdb"` را به `TrainingArguments` اضافه کردیم. به طور پیش‌فرض، مخزن مورد استفاده در فضای نام شما قرار خواهد گرفت و نام آن از دایرکتوری خروجی که تنظیم کرده‌اید گرفته می‌شود، بنابراین در مورد ما `"lewtun/distilbert-finetuned-imdb"` خواهد بود.
اکنون همه مواد لازم برای نمونه‌سازی `Trainer` را داریم. در اینجا ما فقط از `data_collator` استاندارد استفاده می‌کنیم، اما شما می‌توانید به عنوان تمرین، از ابزار تطبیق‌دهنده پوشش کل کلمه (wor masking collator) استفاده کنید و نتایج را با هم مقایسه کنید:
```python
from transformers import Trainer
trainer = Trainer(
model=model,
args=training_args,
train_dataset=downsampled_dataset["train"],
eval_dataset=downsampled_dataset["test"],
data_collator=data_collator,
tokenizer=tokenizer,
)
```
اکنون آماده اجرای `trainer.train()` هستیم -- اما قبل از انجام این کار، بیایید نگاهی مختصر به _perplexity_ بیندازیم که یک معیار رایج برای ارزیابی عملکرد مدل‌های زبانی است.
{/if}
### سرگشتگی برای مدل‌های زبانی[[perplexity-for-language-models]]
برخلاف سایر وظایف مانند طبقه‌بندی متن یا پاسخ به پرسش که در آن‌ها یک دیتاسِت برچسب‌گذاری شده برای آموزش به ما داده می‌شود، در مدل‌سازی زبان هیچ برچسب صریحی نداریم. بنابراین چگونه می‌توانیم تعیین کنیم که چه چیزی یک مدل زبانی خوب را می‌سازد؟ مانند ویژگی تصحیح خودکار در تلفن شما، یک مدل زبانی خوب، مدلی است که احتمالات بالا را به جملاتی که از نظر دستوری صحیح هستند و احتمالات پایین را به جملات بی‌معنی اختصاص می‌دهد. برای اینکه تصور بهتری از این موضوع داشته باشید، می‌توانید مجموعه کاملی از «شکست‌های تصحیح خودکار» را به صورت آنلاین پیدا کنید، که در آن‌ها مدل موجود در تلفن یک شخص، تکمیل‌های نسبتاً خنده‌دار (و اغلب نامناسب) ایجاد کرده است!
{#if fw === 'pt'}
با فرض اینکه مجموعه تست ما عمدتاً از جملاتی تشکیل شده است که از نظر دستوری صحیح هستند، یک راه برای سنجش کیفیت مدل زبانی ما، محاسبه احتمالاتی است که به کلمه بعدی در تمام جملات مجموعه تست اختصاص می‌دهد. احتمالات بالا نشان می‌دهد که مدل از مثال‌های دیده نشده "متعجب" یا "سردرگم" نشده است و نشان می‌دهد که الگوهای اساسی دستور زبان را در زبان یاد گرفته است. تعاریف ریاضی مختلفی برای سرگشتگی وجود دارد، اما تعریفی که ما استفاده خواهیم کرد، آن را به صورت نمایی از تلفات آنتروپی متقاطع تعریف می‌کند. بنابراین، می‌توانیم سرگشتگی مدل از پیش آموزش دیده خود را با استفاده از تابع `Trainer.evaluate()` برای محاسبه تلفات آنتروپی متقاطع در مجموعه تست و سپس گرفتن نمایی از نتیجه، محاسبه کنیم:
```python
import math
eval_results = trainer.evaluate()
print(f">>> Perplexity: {math.exp(eval_results['eval_loss']):.2f}")
```
{:else}
با فرض اینکه مجموعه تست ما عمدتاً از جملاتی تشکیل شده است که از نظر دستوری صحیح هستند، یک راه برای سنجش کیفیت مدل زبانی ما محاسبه احتمالاتی است که به کلمه بعدی در تمام جملات مجموعه تست اختصاص می‌دهد. احتمالات بالا نشان می‌دهد که مدل از مثال‌های دیده نشده "متعجب" یا "سردرگم" نشده است و نشان می‌دهد که الگوهای اساسی دستور زبان را در ... یاد گرفته است. زبان. تعاریف ریاضی مختلفی از سرگشتگی وجود دارد، اما تعریفی که ما استفاده خواهیم کرد، آن را به صورت نمایی از اتلاف آنتروپی متقاطع تعریف می‌کند. بنابراین، می‌توانیم سرگشتگی مدل از پیش آموزش دیده خود را با استفاده از روش `model.evaluate()` برای محاسبه اتلاف آنتروپی متقاطع روی مجموعه تست و سپس گرفتن نمایی از نتیجه، محاسبه کنیم:
```python
import math
eval_loss = model.evaluate(tf_eval_dataset)
print(f"Perplexity: {math.exp(eval_loss):.2f}")
```
{/if}
```python out
>>> Perplexity: 21.75
```
امتیاز پیچیدگی کمتر به معنای مدل زبانی بهتر است و در اینجا می‌توانیم ببینیم که مدل شروع ما مقدار نسبتاً زیادی دارد. بیایید ببینیم آیا می‌توانیم با کوک کردن آن را کاهش دهیم! برای انجام این کار، ابتدا حلقه آموزشی را اجرا می‌کنیم:
{#if fw === 'pt'}
```python
trainer.train()
```
{:else}
```python
model.fit(tf_train_dataset, validation_data=tf_eval_dataset, callbacks=[callback])
```
{/if}
و سپس مانند قبل، گیجی حاصل را روی مجموعه تست محاسبه کنید:
{#if fw === 'pt'}
```python
eval_results = trainer.evaluate()
print(f">>> Perplexity: {math.exp(eval_results['eval_loss']):.2f}")
```
{:else}
```python
eval_loss = model.evaluate(tf_eval_dataset)
print(f"Perplexity: {math.exp(eval_loss):.2f}")
```
{/if}
```python out
>>> Perplexity: 11.32
```
عالیه -- این کاهش قابل توجهی در سردرگمی ایجاد می‌کند، که به ما می‌گوید مدل چیزی در مورد حوزه نقد فیلم یاد گرفته است!
{#if fw === 'pt'}
پس از اتمام آموزش، می‌توانیم کارت مدل را با اطلاعات آموزشی به هاب ارسال کنیم (چک‌پوینت‌ها در طول خود آموزش ذخیره می‌شوند):
```python
trainer.push_to_hub()
```
{/if}
> نکته
> ✏️ **نوبت شماست!** آموزش بالا را پس از تغییر data collator به whole word masking collator اجرا کنید. آیا نتایج بهتری می‌گیرید؟
{#if fw === 'pt'}
در مورد استفاده ما، نیازی به انجام کار خاصی با حلقه آموزش نداشتیم، اما در برخی موارد ممکن است نیاز به پیاده‌سازی منطق سفارشی داشته باشید. برای این برنامه‌ها، می‌توانید از 🤗 Accelerate استفاده کنید -- بیایید نگاهی به آن بیندازیم!
## کوک کردن DistilBERT با 🤗 Accelerate[[fine-tuning-distilbert-with-accelerate]]
همانطور که با `Trainer` دیدیم، کوک کردن یک مدل زبان پنهان بسیار شبیه به مثال طبقه‌بندی متن از [فصل 3](/course/chapter3) است. در واقع، تنها نکته ظریف، استفاده از یک گردآورنده داده ویژه است و ما قبلاً در این بخش به آن پرداخته‌ایم!
با این حال، دیدیم که `DataCollatorForLanguageModeling` در هر ارزیابی، پوشش تصادفی نیز اعمال می‌کند، بنابراین با هر اجرای آموزش، شاهد نوساناتی در نمرات گیجی خود خواهیم بود. یک راه برای از بین بردن این منبع تصادفی بودن، اعمال پوشش _once_ روی کل مجموعه تست و سپس استفاده از تلفیق‌کننده داده‌های پیش‌فرض در ترنسفورمرs🤗 برای جمع‌آوری دسته‌ها در طول ارزیابی است. برای دیدن نحوه عملکرد این روش، بیایید یک تابع ساده پیاده‌سازی کنیم که اعمال می‌شود پوشش روی یک دسته، مشابه اولین برخورد ما با `DataCollatorForLanguageModeling`:
```python
def insert_random_mask(batch):
features = [dict(zip(batch, t)) for t in zip(*batch.values())]
masked_inputs = data_collator(features)
# Create a new "masked" column for each column in the dataset
return {"masked_" + k: v.numpy() for k, v in masked_inputs.items()}
```
در مرحله بعد، این تابع را روی مجموعه تست خود اعمال می‌کنیم و ستون‌های بدون ماسک را حذف می‌کنیم تا بتوانیم آنها را با ستون‌های ماسک‌شده جایگزین کنیم. می‌توانید با جایگزینی `data_collator` بالا با `data_collator` مناسب، از ماسک کردن کل کلمه استفاده کنید، که در این صورت باید خط اول را در اینجا حذف کنید:
```py
downsampled_dataset = downsampled_dataset.remove_columns(["word_ids"])
eval_dataset = downsampled_dataset["test"].map(
insert_random_mask,
batched=True,
remove_columns=downsampled_dataset["test"].column_names,
)
eval_dataset = eval_dataset.rename_columns(
{
"masked_input_ids": "input_ids",
"masked_attention_mask": "attention_mask",
"masked_labels": "labels",
}
)
```
سپس می‌توانیم دیتالودرها را طبق معمول تنظیم کنیم، اما برای مجموعه ارزیابی از `default_data_collator` از ترنسفورمرs🤗 استفاده خواهیم کرد:
```python
from torch.utils.data import DataLoader
from transformers import default_data_collator
batch_size = 64
train_dataloader = DataLoader(
downsampled_dataset["train"],
shuffle=True,
batch_size=batch_size,
collate_fn=data_collator,
)
eval_dataloader = DataLoader(
eval_dataset, batch_size=batch_size, collate_fn=default_data_collator
)
```
از اینجا، مراحل استاندارد را با 🤗 Accelerate دنبال می‌کنیم. اولین مرحله، بارگذاری یک نسخه جدید از مدل از پیش تعلیم‌دیده است:
```
model = AutoModelForMaskedLM.from_pretrained(model_checkpoint)
```
سپس باید بهینه‌ساز را مشخص کنیم؛ ما از استاندارد `AdamW` استفاده خواهیم کرد:
```python
from torch.optim import AdamW
optimizer = AdamW(model.parameters(), lr=5e-5)
```
با این اشیاء، اکنون می‌توانیم همه چیز را برای آموزش با شیء `Accelerator` آماده کنیم:
```python
from accelerate import Accelerator
accelerator = Accelerator()
model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
model, optimizer, train_dataloader, eval_dataloader
)
```
اکنون که مدل، بهینه‌ساز و بارگذارهای داده ما پیکربندی شده‌اند، می‌توانیم زمانبند نرخ یادگیری را به صورت زیر مشخص کنیم:
```python
from transformers import get_scheduler
num_train_epochs = 3
num_update_steps_per_epoch = len(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch
lr_scheduler = get_scheduler(
"linear",
optimizer=optimizer,
num_warmup_steps=0,
num_training_steps=num_training_steps,
)
```
فقط یک کار دیگر قبل از آموزش باید انجام دهیم: یک مخزن مدل در هاگینگ‌فِیس هاب ایجاد کنید! می‌توانیم از کتابخانه 🤗 هاب برای تولید نام کامل مخزن خود استفاده کنیم:
```python
from huggingface_hub import get_full_repo_name
model_name = "distilbert-base-uncased-finetuned-imdb-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name
```
```python out
'lewtun/distilbert-base-uncased-finetuned-imdb-accelerate'
```
سپس با استفاده از کلاس `Repository` از هاب 🤗، مخزن را ایجاد و کلون کنید:
```python
from huggingface_hub import Repository
output_dir = model_name
repo = Repository(output_dir, clone_from=repo_name)
```
با انجام این کار، فقط کافی است حلقه کامل آموزش و ارزیابی را بنویسید:
```python
from tqdm.auto import tqdm
import torch
import math
progress_bar = tqdm(range(num_training_steps))
for epoch in range(num_train_epochs):
# Training
model.train()
for batch in train_dataloader:
outputs = model(**batch)
loss = outputs.loss
accelerator.backward(loss)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
progress_bar.update(1)
# Evaluation
model.eval()
losses = []
for step, batch in enumerate(eval_dataloader):
with torch.no_grad():
outputs = model(**batch)
loss = outputs.loss
losses.append(accelerator.gather(loss.repeat(batch_size)))
losses = torch.cat(losses)
losses = losses[: len(eval_dataset)]
try:
perplexity = math.exp(torch.mean(losses))
except OverflowError:
perplexity = float("inf")
print(f">>> Epoch {epoch}: Perplexity: {perplexity}")
# Save and upload
accelerator.wait_for_everyone()
unwrapped_model = accelerator.unwrap_model(model)
unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
if accelerator.is_main_process:
tokenizer.save_pretrained(output_dir)
repo.push_to_hub(
commit_message=f"Training in progress epoch {epoch}", blocking=False
)
```
```python out
>>> Epoch 0: Perplexity: 11.397545307900472
>>> Epoch 1: Perplexity: 10.904909330983092
>>> Epoch 2: Perplexity: 10.729503505340409
```
عالیه، ما تونستیم میزان پیچیدگی رو با هر دوره ارزیابی کنیم و مطمئن بشیم که چندین اجرای آموزشی قابل تکرار هستن!
{/if}
## با استفاده از مدل تنظیم‌شده‌ی دقیق ما[[using-our-fine-tuned-model]]
شما می‌توانید با مدل تنظیم‌شده‌ی خود یا با استفاده از ویجت آن در هاب یا به صورت محلی با `pipeline` از ترنسفورمرs 🤗 تعامل داشته باشید. بیایید از مورد دوم برای دانلود مدل خود با استفاده از خط لوله `fill-mask` استفاده کنیم:
```python
from transformers import pipeline
mask_filler = pipeline(
"fill-mask", model="huggingface-course/distilbert-base-uncased-finetuned-imdb"
)
```
سپس می‌توانیم متن نمونه «این یک [MASK] عالی است» را به خط لوله (pipeline) بدهیم و ببینیم ۵ پیش‌بینی برتر کدامند:
```python
preds = mask_filler(text)
for pred in preds:
print(f">>> {pred['sequence']}")
```
```python out
'>>> this is a great movie.'
'>>> this is a great film.'
'>>> this is a great story.'
'>>> this is a great movies.'
'>>> this is a great character.'
```
عالی -- مدل ما به وضوح وزن‌های خود را برای پیش‌بینی کلماتی که ارتباط قوی‌تری با فیلم‌ها دارند، تطبیق داده است!
این اولین آزمایش ما با آموزش یک مدل زبانی را به پایان می‌رساند. در [بخش 6](/course/en/chapter7/6) یاد خواهید گرفت که چگونه یک مدل خود-رگرسیو مانند GPT-2 را از ابتدا آموزش دهید؛ اگر می‌خواهید ببینید که چگونه می‌توانید مدل ترنسفورمر خود را از قبل آموزش دهید، به آنجا سر بزنید!
> نکته
> ✏️ **امتحانش کنید!** برای تعیین کمیت مزایای انطباق دامنه، یک طبقه‌بندی‌کننده را روی برچسب‌های IMDb برای هر دو نقطه بررسی از پیش تعلیم‌دیده و تنظیم‌شده‌ی DistilBERT کوک کردن کنید. اگر به اطلاعات جدیدی در مورد طبقه‌بندی متن نیاز دارید، به [فصل ۳](/course/chapter3) مراجعه کنید.

Xet Storage Details

Size:
67.5 kB
·
Xet hash:
1d6ee1ee1acaa022f7c1cbf559d4932d75e2f6f615123c67d98842d745f6ea2f

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