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 رواج یافت، که یکی از اولین معماری‌های عصبی (مبتنی بر LSTMها) بود که یادگیری انتقالی را برای پردازش زبان طبیعی (NLP) واقعاً کارآمد می‌کرد. نمونه‌ای از انطباق دامنه با ULMFiT در تصویر زیر نشان داده شده است؛ در این بخش، کاری مشابه انجام خواهیم داد، اما با یک ترنسفورمر به جای LSTM!

در پایان این بخش، شما یک مدل زبان نقاب‌دار روی هاب خواهید داشت که می‌تواند جملات را به صورت خودکار تکمیل کند، همانطور که در زیر نشان داده شده است:

بیایید شیرجه بزنیم

نکته 🙋 اگر اصطلاحات «مدل‌سازی زبان نقاب‌دار» و «مدل از پیش تعلیم‌دیده» برایتان ناآشنا به نظر می‌رسد، به فصل ۱ مراجعه کنید، جایی که ما تمام این مفاهیم اصلی را به همراه ویدیوها توضیح می‌دهیم!

انتخاب یک مدل از پیش آموزش دیده برای مدل سازی زبان ماسک شده[[picking-a-pretrained-model-for-masked-language-modeling]]

برای شروع، بیایید یک مدل از پیش تعلیم‌دیده مناسب برای مدل‌سازی زبان ماسک‌شده انتخاب کنیم. همانطور که در تصویر زیر نشان داده شده است، می‌توانید با اعمال فیلتر "Fill-Mask" در هاگینگ‌فِیس هاب لیستی از کاندیداها را پیدا کنید:

اگرچه خانواده مدل‌های BERT و RoBERTa بیشترین دانلود را دارند، ما از مدلی به نام DistilBERT استفاده خواهیم کرد. که می‌تواند خیلی سریع‌تر و با کمترین یا بدون هیچ افتی در عملکرد پایین‌دستی تعلیم داده شود. این مدل با استفاده از تکنیک خاصی به نام knowledge distillation تعلیم داده شده است، که در آن از یک "مدل معلم" بزرگ مانند BERT برای هدایت آموزش یک "مدل دانش‌آموز" که پارامترهای بسیار کمتری دارد استفاده می‌شود. توضیح جزئیات تقطیر دانش ما را در این بخش خیلی از بحث اصلی دور می‌کند، اما اگر علاقه‌مند هستید می‌توانید می‌توانید همه چیز را در مورد آن در پردازش زبان طبیعی با ترنسفورمرها (که به صورت محاوره‌ای به عنوان کتاب درسی ترنسفورمرها شناخته می‌شود) بخوانید.

{#if fw === 'pt'}

بیایید با استفاده از کلاس AutoModelForMaskedLM، DistilBERT را دانلود کنیم:

from transformers import AutoModelForMaskedLM

model_checkpoint = "distilbert-base-uncased"
model = AutoModelForMaskedLM.from_pretrained(model_checkpoint)

می‌توانیم با فراخوانی متد num_parameters() ببینیم که این مدل چند پارامتر دارد:

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'")
'>>> DistilBERT number of parameters: 67M'
'>>> BERT number of parameters: 110M'

{:else}

بیایید با استفاده از کلاس AutoModelForMaskedLM، DistilBERT را دانلود کنیم:

from transformers import TFAutoModelForMaskedLM

model_checkpoint = "distilbert-base-uncased"
model = TFAutoModelForMaskedLM.from_pretrained(model_checkpoint)

می‌توانیم با فراخوانی متد summary() ببینیم که این مدل چند پارامتر دارد:

model.summary()
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 است، که تقریباً به معنای افزایش دو برابری سرعت آموزش است -- عالی! حال بیایید ببینیم این مدل چه نوع توکن‌هایی را پیش‌بینی می‌کند که محتمل‌ترین تکمیل‌های یک نمونه کوچک از متن هستند:

text = "This is a great [MASK]."

ما به عنوان انسان، می‌توانیم احتمالات زیادی را برای توکن [MASK] تصور کنیم، مانند "روز"، "سوار شدن" یا "نقاشی". برای مدل‌های از پیش تعلیم‌دیده، پیش‌بینی‌ها به پیکره‌ای که مدل بر اساس آن آموزش دیده است بستگی دارد، زیرا یاد می‌گیرد الگوهای آماری موجود در داده‌ها را انتخاب کند. مانند BERT، DistilBERT نیز بر روی دیتاسِت‌های ویکی‌پدیای انگلیسی و BookCorpus از پیش آموزش دیده است، بنابراین انتظار داریم پیش‌بینی‌های [MASK] بازتاب‌دهنده‌ی این حوزه‌ها باشند. برای پیش‌بینی ماسک، به توکن‌ساز DistilBERT نیاز داریم تا ورودی‌های مدل را تولید کند، بنابراین بیایید آن را نیز از هاب دانلود کنیم:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

با یک توکن‌ساز و یک مدل، اکنون می‌توانیم مثال متنی خود را به مدل ارسال کنیم، لوجیت‌ها را استخراج کنیم و ۵ کاندید برتر را چاپ کنیم:

{#if fw === 'pt'}

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}

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}

'>>> 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 (یا به اختصار IMDb) استفاده خواهیم کرد، که مجموعه‌ای از نقدهای فیلم است که اغلب برای سنجش مدل‌های تحلیل احساسات استفاده می‌شود. با کوک کردن DistilBERT روی این دیتاسِت، انتظار داریم مدل زبانی واژگان خود را از داده‌های واقعی ویکی‌پدیا که از قبل روی آن آموزش دیده است، با عناصر ذهنی‌تر نقدهای فیلم تطبیق دهد. می‌توانیم داده‌ها از هاگینگ‌فِیس هاب با تابع load_dataset() از دیتاسِت‌های 🤗:

from datasets import load_dataset

imdb_dataset = load_dataset("imdb")
imdb_dataset
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() را برای ایجاد یک نمونه تصادفی زنجیره می‌کنیم:

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']}'")

'>>> 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 دیدیم، مراحل دیگری نیز وجود دارد که باید انجام شود. شروع می‌کنیم!

پیش‌پردازش داده‌ها[[preprocessing-the-data]]

برای هر دو مدل‌سازی زبان خودرگرسیون و ماسک‌شده، یک مرحله پیش‌پردازش رایج، الحاق همه مثال‌ها و سپس تقسیم کل مجموعه به قطعاتی با اندازه مساوی است. این کاملاً با رویکرد معمول ما که در آن صرفاً مثال‌های منفرد را توکنیزه می‌کنیم، متفاوت است. چرا همه چیز را با هم الحاق کنیم؟ دلیلش این است که اگر مثال‌های منفرد خیلی طولانی باشند، ممکن است کوتاه شوند و این منجر به از دست رفتن ... می‌شود. اطلاعاتی که ممکن است برای کار مدل‌سازی زبان مفید باشد!

بنابراین برای شروع، ابتدا طبق معمول، دیتاسِت‌های خود را توکنیزه می‌کنیم، اما بدون تنظیم گزینه truncation=True در توکن‌ساز خود. همچنین شناسه‌های کلمات را در صورت موجود بودن، دریافت خواهیم کرد ((که اگر از یک توکن‌ساز سریع استفاده کنیم، همانطور که در فصل 6 توضیح داده شده است، این کار را انجام خواهیم داد)، زیرا بعداً برای انجام پوشش کامل کلمه به آنها نیاز خواهیم داشت. این را در یک تابع ساده قرار می‌دهیم و در حین انجام این کار، text و label را حذف می‌کنیم. ستون‌ها، چون دیگر به آنها نیازی نداریم:

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
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 توکنایزر استنباط کرد:

tokenizer.model_max_length
512

این مقدار از فایل توکِن‌ساز_config.json مرتبط با یک Checkpoint گرفته شده است؛ در این حالت می‌توانیم ببینیم که اندازه context، درست مانند BERT، 512 توکن است.

نکته ✏️ امتحانش کنید! برخی از مدل‌های ترنسفورمر، مانند BigBird و Longformer، طول متن بسیار طولانی‌تری نسبت به BERT و سایر مدل‌های اولیه ترنسفورمر دارند. توکن‌ساز را برای یکی از این نقاط بررسی نمونه‌سازی کنید و تأیید کنید که model_max_length با آنچه در کارت مدل آن ذکر شده است، مطابقت دارد.

بنابراین، برای اجرای آزمایش‌هایمان روی پردازنده‌های گرافیکی مانند پردازنده‌های موجود در Google Colab، چیزی کمی کوچک‌تر انتخاب می‌کنیم که بتواند در حافظه جا شود:

chunk_size = 128

WARNING توجه داشته باشید که استفاده از اندازه کوچک بخش می‌تواند در سناریوهای دنیای واقعی مضر باشد، بنابراین باید از اندازه‌ای استفاده کنید که با مورد استفاده‌ای که مدل خود را برای آن اعمال خواهید کرد، مطابقت داشته باشد.

حالا به بخش جالب ماجرا می‌رسیم. برای نشان دادن نحوه‌ی عملکرد الحاق، بیایید چند نظر را از مجموعه‌ی آموزشی توکن‌سازی‌شده‌ی خود بگیریم و تعداد توکن‌ها را برای هر نظر چاپ کنیم:

# 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)}'")
'>>> Review 0 length: 200'
'>>> Review 1 length: 559'
'>>> Review 2 length: 192'

سپس می‌توانیم تمام این مثال‌ها را با یک درک ساده از فرهنگ لغت، به صورت زیر به هم پیوند دهیم:

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}'")
'>>> Concatenated reviews length: 951'

عالی، طول کل بررسی شد -- حالا بیایید بررسی‌های به هم پیوسته را به تکه‌هایی با اندازه داده شده توسط chunk_size تقسیم کنیم. برای انجام این کار، روی ویژگی‌های موجود در concatenated_examples تکرار می‌کنیم و از یک درک لیست برای ایجاد برش‌هایی از هر ویژگی استفاده می‌کنیم. نتیجه، یک دیکشنری از تکه‌ها برای هر ویژگی است:

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)}'")
'>>> 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 شود، لایه گذاری کنید.

ما در اینجا رویکرد اول را در پیش می‌گیریم، بنابراین بیایید تمام منطق فوق را در یک تابع واحد که می‌توانیم روی دیتاسِت‌های توکن‌شده خود اعمال کنیم، قرار دهیم:

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() قابل اعتماد خود، روی دیتاسِت‌های توکن‌سازی شده خود اعمال کنیم:

lm_datasets = tokenized_datasets.map(group_texts, batched=True)
lm_datasets
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] در یکی از قطعه‌ها مشاهده کنید:

tokenizer.decode(lm_datasets["train"][1]["input_ids"])
".... 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"

در این مثال می‌توانید دو نقد فیلم را ببینید که با هم همپوشانی دارند، یکی درباره یک فیلم دبیرستانی و دیگری درباره بی‌خانمانی. بیایید همچنین بررسی کنیم که برچسب‌ها برای مدل‌سازی زبان پنهان چگونه به نظر می‌رسند:

tokenizer.decode(lm_datasets["train"][1]["labels"])
".... 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]]

کوک کردن یک مدل زبان ماسک‌شده تقریباً مشابه کوک کردن یک مدل طبقه‌بندی توالی است، همانطور که در فصل ۳ انجام دادیم. تنها تفاوت این است که ما به یک گردآورنده داده ویژه نیاز داریم که بتواند به طور تصادفی برخی از توکن‌ها را در هر دسته از متون ماسک کند. خوشبختانه، 🤗 ترنسفورمرز با یک DataCollatorForLanguageModeling اختصاصی برای این کار ارائه می‌شود. ما فقط باید توکنایزر و یک آرگومان mlm_probability را به آن منتقل کنیم. که مشخص می‌کند چه کسری از توکن‌ها باید پنهان شوند. ما ۱۵٪ را انتخاب می‌کنیم، که مقداری است که برای BERT استفاده می‌شود و یک انتخاب رایج در مقالات است:

from transformers import DataCollatorForLanguageModeling

data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm_probability=0.15)

برای اینکه ببینیم ماسک تصادفی چگونه کار می‌کند، بیایید چند مثال به گردآورنده داده‌ها بدهیم. از آنجایی که انتظار لیستی از dictها را دارد، که در آن هر dict نشان دهنده یک تکه متن پیوسته است، ابتدا قبل از اینکه دسته را به گردآورنده بدهیم، روی دیتاسِت‌ها تکرار می‌کنیم. کلید "word_ids" را برای این گردآورنده داده‌ها حذف می‌کنیم زیرا انتظار آن را ندارد:

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)}'")
'>>> [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'}

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}

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}

در مرحله بعد، می‌توانیم آن را روی همان نمونه‌های قبلی امتحان کنیم:

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)}'")
'>>> [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() است که در فصل ۵:

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
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٪ از آن تنظیم شده است -- اگر پردازنده گرافیکی قدرتمندی دارید، می‌توانید این مقدار را افزایش دهید! کار بعدی که باید انجام دهیم این است که به هاگینگ‌فِیس هاب وارد شوید. اگر این کد را در یک نوت‌بوک اجرا می‌کنید، می‌توانید این کار را با تابع کاربردی زیر انجام دهید:

from huggingface_hub import notebook_login

notebook_login()

که یک ویجت را نمایش می‌دهد که می‌توانید اطلاعات کاربری خود را در آن وارد کنید. همچنین می‌توانید دستور زیر را اجرا کنید:

huggingface-cli login

در ترمینال مورد علاقه‌تان و وارد آن شوید.

{#if fw === 'tf'}

پس از ورود به سیستم، می‌توانیم دیتاسِت‌های tf.data خود را ایجاد کنیم. برای انجام این کار، از روش prepare_tf_dataset() استفاده خواهیم کرد که از مدل ما برای استنباط خودکار ستون‌هایی که باید در دیتاسِت‌ها قرار گیرند، استفاده می‌کند. اگر می‌خواهید دقیقاً کنترل کنید که از کدام ستون‌ها استفاده شود، می‌توانید به جای آن از روش Dataset.to_tf_dataset() استفاده کنید. برای ساده نگه داشتن کارها، ما در اینجا فقط از تلفیق‌کننده داده استاندارد استفاده خواهیم کرد، اما می‌توانید تلفیق‌کننده پوشش کامل کلمه را نیز امتحان کنید و نتایج را به عنوان یک تمرین مقایسه کنید:

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، ما hub_model_id="huggingface-course/distilbert-finetuned-imdb" را اضافه کردیم. به طور پیش‌فرض، مخزن مورد استفاده در فضای نام شما قرار خواهد گرفت و نام آن از ... گرفته می‌شود. دایرکتوری خروجی که شما تنظیم کرده‌اید، بنابراین در مورد ما "lewtun/distilbert-finetuned-imdb" خواهد بود.

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 را مشخص کنیم:

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 ارسال کردیم، hub_model_id="huggingface-course/distilbert-finetuned-imdb" را به TrainingArguments اضافه کردیم. به طور پیش‌فرض، مخزن مورد استفاده در فضای نام شما قرار خواهد گرفت و نام آن از دایرکتوری خروجی که تنظیم کرده‌اید گرفته می‌شود، بنابراین در مورد ما "lewtun/distilbert-finetuned-imdb" خواهد بود.

اکنون همه مواد لازم برای نمونه‌سازی Trainer را داریم. در اینجا ما فقط از data_collator استاندارد استفاده می‌کنیم، اما شما می‌توانید به عنوان تمرین، از ابزار تطبیق‌دهنده پوشش کل کلمه (wor masking collator) استفاده کنید و نتایج را با هم مقایسه کنید:

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() برای محاسبه تلفات آنتروپی متقاطع در مجموعه تست و سپس گرفتن نمایی از نتیجه، محاسبه کنیم:

import math

eval_results = trainer.evaluate()
print(f">>> Perplexity: {math.exp(eval_results['eval_loss']):.2f}")

{:else}

با فرض اینکه مجموعه تست ما عمدتاً از جملاتی تشکیل شده است که از نظر دستوری صحیح هستند، یک راه برای سنجش کیفیت مدل زبانی ما محاسبه احتمالاتی است که به کلمه بعدی در تمام جملات مجموعه تست اختصاص می‌دهد. احتمالات بالا نشان می‌دهد که مدل از مثال‌های دیده نشده "متعجب" یا "سردرگم" نشده است و نشان می‌دهد که الگوهای اساسی دستور زبان را در ... یاد گرفته است. زبان. تعاریف ریاضی مختلفی از سرگشتگی وجود دارد، اما تعریفی که ما استفاده خواهیم کرد، آن را به صورت نمایی از اتلاف آنتروپی متقاطع تعریف می‌کند. بنابراین، می‌توانیم سرگشتگی مدل از پیش آموزش دیده خود را با استفاده از روش model.evaluate() برای محاسبه اتلاف آنتروپی متقاطع روی مجموعه تست و سپس گرفتن نمایی از نتیجه، محاسبه کنیم:

import math

eval_loss = model.evaluate(tf_eval_dataset)
print(f"Perplexity: {math.exp(eval_loss):.2f}")

{/if}

>>> Perplexity: 21.75

امتیاز پیچیدگی کمتر به معنای مدل زبانی بهتر است و در اینجا می‌توانیم ببینیم که مدل شروع ما مقدار نسبتاً زیادی دارد. بیایید ببینیم آیا می‌توانیم با کوک کردن آن را کاهش دهیم! برای انجام این کار، ابتدا حلقه آموزشی را اجرا می‌کنیم:

{#if fw === 'pt'}

trainer.train()

{:else}

model.fit(tf_train_dataset, validation_data=tf_eval_dataset, callbacks=[callback])

{/if}

و سپس مانند قبل، گیجی حاصل را روی مجموعه تست محاسبه کنید:

{#if fw === 'pt'}

eval_results = trainer.evaluate()
print(f">>> Perplexity: {math.exp(eval_results['eval_loss']):.2f}")

{:else}

eval_loss = model.evaluate(tf_eval_dataset)
print(f"Perplexity: {math.exp(eval_loss):.2f}")

{/if}

>>> Perplexity: 11.32

عالیه -- این کاهش قابل توجهی در سردرگمی ایجاد می‌کند، که به ما می‌گوید مدل چیزی در مورد حوزه نقد فیلم یاد گرفته است!

{#if fw === 'pt'}

پس از اتمام آموزش، می‌توانیم کارت مدل را با اطلاعات آموزشی به هاب ارسال کنیم (چک‌پوینت‌ها در طول خود آموزش ذخیره می‌شوند):

trainer.push_to_hub()

{/if}

نکته ✏️ نوبت شماست! آموزش بالا را پس از تغییر data collator به whole word masking collator اجرا کنید. آیا نتایج بهتری می‌گیرید؟

{#if fw === 'pt'}

در مورد استفاده ما، نیازی به انجام کار خاصی با حلقه آموزش نداشتیم، اما در برخی موارد ممکن است نیاز به پیاده‌سازی منطق سفارشی داشته باشید. برای این برنامه‌ها، می‌توانید از 🤗 Accelerate استفاده کنید -- بیایید نگاهی به آن بیندازیم!

کوک کردن DistilBERT با 🤗 Accelerate[[fine-tuning-distilbert-with-accelerate]]

همانطور که با Trainer دیدیم، کوک کردن یک مدل زبان پنهان بسیار شبیه به مثال طبقه‌بندی متن از فصل 3 است. در واقع، تنها نکته ظریف، استفاده از یک گردآورنده داده ویژه است و ما قبلاً در این بخش به آن پرداخته‌ایم!

با این حال، دیدیم که DataCollatorForLanguageModeling در هر ارزیابی، پوشش تصادفی نیز اعمال می‌کند، بنابراین با هر اجرای آموزش، شاهد نوساناتی در نمرات گیجی خود خواهیم بود. یک راه برای از بین بردن این منبع تصادفی بودن، اعمال پوشش once روی کل مجموعه تست و سپس استفاده از تلفیق‌کننده داده‌های پیش‌فرض در ترنسفورمرs🤗 برای جمع‌آوری دسته‌ها در طول ارزیابی است. برای دیدن نحوه عملکرد این روش، بیایید یک تابع ساده پیاده‌سازی کنیم که اعمال می‌شود پوشش روی یک دسته، مشابه اولین برخورد ما با DataCollatorForLanguageModeling:

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 مناسب، از ماسک کردن کل کلمه استفاده کنید، که در این صورت باید خط اول را در اینجا حذف کنید:

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🤗 استفاده خواهیم کرد:

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 استفاده خواهیم کرد:

from torch.optim import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)

با این اشیاء، اکنون می‌توانیم همه چیز را برای آموزش با شیء Accelerator آماده کنیم:

from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)

اکنون که مدل، بهینه‌ساز و بارگذارهای داده ما پیکربندی شده‌اند، می‌توانیم زمانبند نرخ یادگیری را به صورت زیر مشخص کنیم:

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,
)

فقط یک کار دیگر قبل از آموزش باید انجام دهیم: یک مخزن مدل در هاگینگ‌فِیس هاب ایجاد کنید! می‌توانیم از کتابخانه 🤗 هاب برای تولید نام کامل مخزن خود استفاده کنیم:

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
'lewtun/distilbert-base-uncased-finetuned-imdb-accelerate'

سپس با استفاده از کلاس Repository از هاب 🤗، مخزن را ایجاد و کلون کنید:

from huggingface_hub import Repository

output_dir = model_name
repo = Repository(output_dir, clone_from=repo_name)

با انجام این کار، فقط کافی است حلقه کامل آموزش و ارزیابی را بنویسید:

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
        )
>>> 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 استفاده کنیم:

from transformers import pipeline

mask_filler = pipeline(
    "fill-mask", model="huggingface-course/distilbert-base-uncased-finetuned-imdb"
)

سپس می‌توانیم متن نمونه «این یک [MASK] عالی است» را به خط لوله (pipeline) بدهیم و ببینیم ۵ پیش‌بینی برتر کدامند:

preds = mask_filler(text)

for pred in preds:
    print(f">>> {pred['sequence']}")
'>>> 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 یاد خواهید گرفت که چگونه یک مدل خود-رگرسیو مانند GPT-2 را از ابتدا آموزش دهید؛ اگر می‌خواهید ببینید که چگونه می‌توانید مدل ترنسفورمر خود را از قبل آموزش دهید، به آنجا سر بزنید!

نکته ✏️ امتحانش کنید! برای تعیین کمیت مزایای انطباق دامنه، یک طبقه‌بندی‌کننده را روی برچسب‌های IMDb برای هر دو نقطه بررسی از پیش تعلیم‌دیده و تنظیم‌شده‌ی DistilBERT کوک کردن کنید. اگر به اطلاعات جدیدی در مورد طبقه‌بندی متن نیاز دارید، به فصل ۳ مراجعه کنید.

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.