Buckets:

|
download
raw
58.4 kB
# ترجمه[[translation]]
{#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/section4_pt.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter7/section4_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/section4_tf.ipynb"},
{label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter7/section4_tf.ipynb"},
]} />
{/if}
حالا بیایید به سراغ ترجمه برویم. این یکی دیگر از [وظیفه‌های توالی به توالی](/course/chapter1/7) است، به این معنی که مسئله‌ای است که می‌توان آن را به صورت رفتن از یک توالی به توالی دیگر فرموله کرد. از این نظر، مسئله بسیار نزدیک به [خلاصه‌سازی](/course/chapter7/6) است و می‌توانید آنچه را که در اینجا خواهیم دید با سایر مسائل توالی به توالی مانند موارد زیر تطبیق دهید:
- **انتقال سبک**: ایجاد مدلی که متون نوشته شده با یک سبک خاص را به سبک دیگر *ترجمه* می‌کند (مثلاً، متن رسمی را به متن غیررسمی یا انگلیسی شکسپیر را به انگلیسی مدرن)
- **پاسخ به سوالات مولد**: ایجاد مدلی که با توجه به زمینه، پاسخ سوالات را تولید می‌کند
اگر حجم متن شما به دو (یا چند) زبان به اندازه کافی زیاد باشد، می‌توانید یک مدل ترجمه جدید را از ابتدا آموزش دهید، همانطور که در بخش [مدل‌سازی زبان سببی](/course/chapter7/6) انجام خواهیم داد. با این حال، کوک کردن یک مدل ترجمه‌ی موجود، چه یک مدل چندزبانه مانند mT5 یا mBART باشد که می‌خواهید آن را برای یک جفت زبان خاص کوک کنید، یا حتی مدلی تخصصی برای ترجمه از زبانی به زبان دیگر که می‌خواهید آن را با پیکره‌ی خاص خود کوک کنید، سریع‌تر خواهد بود.
در این بخش، ما یک مدل Marian را که از قبل برای ترجمه از انگلیسی به فرانسوی (از آنجایی که بسیاری از کارمندان هاگینگ‌فِیس به هر دو زبان صحبت می‌کنند) در [دیتاسِت KDE4](https://huggingface.co/datasets/kde4) که مجموعه‌ای از فایل‌های محلی برای [برنامه‌های KDE](https://apps.kde.org/) است، آموزش دیده است، به دقت تنظیم خواهیم کرد. مدلی که ما استفاده خواهیم کرد، بر روی یک مجموعه بزرگ از متون فرانسوی و انگلیسی گرفته شده از [دیتاسِت Opus](https://opus.nlpl.eu/) که در واقع شامل KDE4 است، از قبل آموزش دیده است. دیتاسِت. اما حتی اگر مدل از پیش تعلیم‌دیده‌ای که استفاده می‌کنیم، آن داده‌ها را در طول پیش‌تعلیم خود دیده باشد، خواهیم دید که می‌توانیم پس از کوک کردن، نسخه بهتری از آن را بدست آوریم.
وقتی کارمان تمام شد، مدلی خواهیم داشت که می‌تواند پیش‌بینی‌هایی مانند این انجام دهد:
همانند بخش‌های قبلی، می‌توانید مدل واقعی که ما آموزش خواهیم داد و با استفاده از کد زیر در هاب آپلود خواهیم کرد را پیدا کنید و پیش‌بینی‌های آن را [اینجا](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.) دوباره بررسی کنید.
## آماده‌سازی داده‌ها[[preparing-the-data]]
برای کوک کردن یا آموزش یک مدل ترجمه از ابتدا، به یک دیتاسِت مناسب برای این کار نیاز داریم. همانطور که قبلاً ذکر شد، ما در این بخش از دیتاسِت [KDE4](https://huggingface.co/datasets/kde4) استفاده خواهیم کرد، اما شما می‌توانید کد را به راحتی با استفاده از داده‌های خود تطبیق دهید، البته تا زمانی که جفت جملاتی به دو زبانی که می‌خواهید از و به آنها ترجمه کنید، داشته باشید. اگر به یادآوری نحوه بارگذاری کد خود نیاز دارید، به [فصل 5](/course/chapter5) مراجعه کنید. داده‌های سفارشی در یک `Dataset`.
### دیتاسِت KDE4[[the-kde4-dataset]]
طبق معمول، دیتاسِت خود را با استفاده از تابع `load_dataset()` دانلود می‌کنیم:
```py
from datasets import load_dataset
raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
```
اگر می‌خواهید با یک جفت زبان متفاوت کار کنید، می‌توانید آنها را با کدهایشان مشخص کنید. در مجموع ۹۲ زبان برای این دیتاسِت موجود است؛ می‌توانید با باز کردن برچسب‌های زبان در [کارت دیتاسِت](https://huggingface.co/datasets/kde4) آن، همه آنها را مشاهده کنید.
بیایید نگاهی به دیتاسِت‌ها بیندازیم:
```py
raw_datasets
```
```python out
DatasetDict({
train: Dataset({
features: ['id', 'translation'],
num_rows: 210173
})
})
```
ما ۲۱۰٬۱۷۳ جفت جمله داریم، اما همه در یک بخش قرار دارند؛ بنابراین باید مجموعه‌ی اعتبارسنجی خودمان را بسازیم. همان‌طور که در [فصل ۵](/course/chapter5) دیدیم، یک `Dataset` متد `train_test_split()` دارد که به ما کمک می‌کند. برای تکرارپذیری یک seed هم می‌دهیم:
```py
split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20)
split_datasets
```
```python out
DatasetDict({
train: Dataset({
features: ['id', 'translation'],
num_rows: 189155
})
test: Dataset({
features: ['id', 'translation'],
num_rows: 21018
})
})
```
می‌توانیم کلید `"test"` را به `"validation"` به این صورت تغییر نام دهیم:
```py
split_datasets["validation"] = split_datasets.pop("test")
```
حالا بیایید نگاهی به یکی از عناصر دیتاسِت‌ها بیندازیم:
```py
split_datasets["train"][1]["translation"]
```
```python out
{'en': 'Default to expanded threads',
'fr': 'Par défaut, développer les fils de discussion'}
```
ما یک فرهنگ لغت با دو جمله در دو زبانی که درخواست کردیم دریافت می‌کنیم. یکی از ویژگی‌های این دیتاسِت پر از اصطلاحات فنی علوم کامپیوتر این است که همه آنها به طور کامل به زبان فرانسوی ترجمه شده‌اند. با این حال، مهندسان فرانسوی هنگام صحبت کردن، بیشتر کلمات خاص علوم کامپیوتر را به انگلیسی باقی می‌گذارند. برای مثال، در اینجا، کلمه "threads" ممکن است در یک جمله فرانسوی، به خصوص در یک مکالمه فنی، ظاهر شود. اما در این دیتاسِت‌ای که به عبارت صحیح‌تر «fils de discussion» ترجمه شده است. مدل از پیش تعلیم‌دیده‌ای که ما استفاده می‌کنیم، که بر روی مجموعه‌ای بزرگتر از جملات فرانسوی و انگلیسی تعلیم‌دیده است، گزینه آسان‌ترِ باقی گذاشتن کلمه به همان شکل فعلی را انتخاب می‌کند:
```py
from transformers import pipeline
model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
translator = pipeline("translation", model=model_checkpoint)
translator("Default to expanded threads")
```
```python out
[{'translation_text': 'Par défaut pour les threads élargis'}]
```
نمونه دیگری از این رفتار را می‌توان با کلمه "plugin" مشاهده کرد که رسماً یک کلمه فرانسوی نیست اما اکثر گویشوران بومی آن را می‌فهمند و زحمت ترجمه آن را به خود نمی‌دهند.
در دیتاسِت KDE4 این کلمه در زبان فرانسوی به صورت رسمی‌تر «module d'extension» ترجمه شده است:
```py
split_datasets["train"][172]["translation"]
```
```python out
{'en': 'Unable to import %1 using the OFX importer plugin. This file is not the correct format.',
'fr': "Impossible d'importer %1 en utilisant le module d'extension d'importation OFX. Ce fichier n'a pas un format correct."}
```
با این حال، مدل از پیش تعلیم‌دیده‌ی ما به کلمه‌ی انگلیسی فشرده و آشنا پایبند است:
```py
translator(
"Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)
```
```python out
[{'translation_text': "Impossible d'importer %1 en utilisant le plugin d'importateur OFX. Ce fichier n'est pas le bon format."}]
```
جالب خواهد بود ببینیم که آیا مدل تنظیم‌شده‌ی ما آن ویژگی‌های خاص دیتاسِت‌ها را تشخیص می‌دهد یا خیر (هشدار لو رفتن داستان: بله، تشخیص خواهد داد).
> نکته
> ✏️ **نوبت شماست!** یکی دیگر از کلمات انگلیسی که اغلب در زبان فرانسه استفاده می‌شود، «email» است. اولین نمونه‌ای را که در دیتاسِت‌های آموزشی از این کلمه استفاده می‌کند، پیدا کنید. چگونه ترجمه می‌شود؟ مدل از پیش تعلیم‌دیده چگونه همان جمله انگلیسی را ترجمه می‌کند؟
### پردازش داده‌ها[[processing-the-data]]
شما باید تا الان با مراحل کار آشنا شده باشید: همه متن‌ها باید به مجموعه‌ای از شناسه‌های توکن تبدیل شوند تا مدل بتواند آنها را درک کند. برای این کار، باید ورودی‌ها و اهداف را توکن‌سازی کنیم. اولین کار ما ایجاد شیء `tokenizer` است. همانطور که قبلاً اشاره شد، ما از یک مدل از پیش تعلیم‌دیده انگلیسی به فرانسوی استفاده خواهیم کرد. اگر این کد را با دو زبان دیگر امتحان می‌کنید، حتماً چک‌پوینت مدل را تطبیق دهید. سازمان [Helsinki-NLP](https://huggingface.co/Helsinki-NLP) بیش از هزار مدل را به زبان‌های مختلف ارائه می‌دهد.
```python
from transformers import AutoTokenizer
model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint, return_tensors="pt")
```
همچنین می‌توانید `model_checkpoint` را با هر مدل دیگری که از [هاب](https://huggingface.co/models) ترجیح می‌دهید، یا یک پوشه محلی که در آن یک مدل از پیش آموزش دیده و یک توکنایزر ذخیره کرده‌اید، جایگزین کنید.
> نکته
> 💡 اگر از یک توکن‌ساز چندزبانه مانند mBART، mBART-50 یا M2M100 استفاده می‌کنید، باید کدهای زبان ورودی‌ها و اهداف خود را در توکن‌ساز با تنظیم `tokenizer.src_lang` و `tokenizer.tgt_lang` روی مقادیر صحیح تنظیم کنید.
آماده‌سازی داده‌های ما بسیار ساده است. فقط یک نکته وجود دارد که باید به خاطر داشته باشید؛ باید مطمئن شوید که توکن‌ساز، اهداف را به زبان خروجی (در اینجا، فرانسوی) پردازش می‌کند. می‌توانید این کار را با ارسال اهداف به آرگومان `text_targets` از متد `__call__` توکن‌ساز انجام دهید.
برای دیدن نحوه‌ی عملکرد این روش، بیایید یک نمونه از هر زبان در مجموعه‌ی آموزشی را پردازش کنیم:
```python
en_sentence = split_datasets["train"][1]["translation"]["en"]
fr_sentence = split_datasets["train"][1]["translation"]["fr"]
inputs = tokenizer(en_sentence, text_target=fr_sentence)
inputs
```
```python out
{'input_ids': [47591, 12, 9842, 19634, 9, 0], 'attention_mask': [1, 1, 1, 1, 1, 1], 'labels': [577, 5891, 2, 3184, 16, 2542, 5, 1710, 0]}
```
همانطور که می‌بینیم، خروجی شامل شناسه‌های ورودی مرتبط با جمله انگلیسی است، در حالی که شناسه‌های مرتبط با جمله فرانسوی در فیلد `labels` ذخیره شده‌اند. اگر فراموش کنید که مشخص کنید در حال توکن‌سازی برچسب‌ها هستید، آنها توسط توکن‌ساز ورودی توکن‌سازی می‌شوند، که در مورد مدل Marian به هیچ وجه خوب پیش نخواهد رفت:
```python
wrong_targets = tokenizer(fr_sentence)
print(tokenizer.convert_ids_to_tokens(wrong_targets["input_ids"]))
print(tokenizer.convert_ids_to_tokens(inputs["labels"]))
```
```python out
['▁Par', '▁dé', 'f', 'aut', ',', '▁dé', 've', 'lop', 'per', '▁les', '▁fil', 's', '▁de', '▁discussion', '</s>']
['▁Par', '▁défaut', ',', '▁développer', '▁les', '▁fils', '▁de', '▁discussion', '</s>']
```
همانطور که می‌بینیم، استفاده از توکن‌ساز انگلیسی برای پیش‌پردازش یک جمله فرانسوی منجر به توکن‌های بسیار بیشتری می‌شود، زیرا توکن‌ساز هیچ کلمه فرانسوی نمی‌شناسد (به جز کلماتی که در زبان انگلیسی نیز وجود دارند، مانند "discussion").
از آنجایی که `inputs` یک دیکشنری با کلیدهای معمول ما (شناسه‌های ورودی، ماسک توجه و غیره) است، آخرین مرحله تعریف تابع پیش‌پردازشی است که روی دیتاسِت‌ها اعمال خواهیم کرد:
```python
max_length = 128
def preprocess_function(examples):
inputs = [ex["en"] for ex in examples["translation"]]
targets = [ex["fr"] for ex in examples["translation"]]
model_inputs = tokenizer(
inputs, text_target=targets, max_length=max_length, truncation=True
)
return model_inputs
```
توجه داشته باشید که ما حداکثر طول یکسانی را برای ورودی‌ها و خروجی‌های خود تعیین می‌کنیم. از آنجایی که متن‌هایی که با آنها سروکار داریم بسیار کوتاه به نظر می‌رسند، از ۱۲۸ استفاده می‌کنیم.
> نکته
> 💡 اگر از مدل T5 استفاده می‌کنید (به طور خاص، یکی از نقاط بررسی `t5-xxx`)، مدل انتظار دارد ورودی‌های متنی پیشوندی داشته باشند که نشان دهنده وظیفه مورد نظر باشد، مانند `translate: English to French:`.
> WARNING
> ⚠️ ما به ماسک توجه اهداف توجه نمی‌کنیم، زیرا مدل انتظار آن را ندارد. در عوض، برچسب‌های مربوط به یک نشانه‌ی بالشتک باید روی `-100` تنظیم شوند تا در محاسبه‌ی زیان نادیده گرفته شوند. این کار بعداً توسط گردآورنده‌ی داده‌های ما انجام خواهد شد زیرا ما در حال اعمال بالشتک پویا هستیم، اما اگر در اینجا از بالشتک استفاده می‌کنید، باید تابع پیش‌پردازش را طوری تنظیم کنید که تمام برچسب‌های مربوط به نشانه‌ی بالشتک را روی `-100` تنظیم کند.
اکنون می‌توانیم آن پیش‌پردازش را به‌طور یکجا روی تمام بخش‌های دیتاسِت خود اعمال کنیم:
```py
tokenized_datasets = split_datasets.map(
preprocess_function,
batched=True,
remove_columns=split_datasets["train"].column_names,
)
```
اکنون که داده‌ها پیش‌پردازش شده‌اند، آماده‌ایم تا مدل از پیش تعلیم‌دیده خود را تنظیم کنیم!
{#if fw === 'pt'}
## کوک کردن مدل با رابط برنامه‌نویسی کاربردی `Trainer`[[fine-tuning-the-model-with-the-trainer-api]]
کد واقعی با استفاده از `Trainer` مانند قبل خواهد بود، تنها با یک تغییر کوچک: ما در اینجا از یک [`Seq2SeqTrainer`](https://huggingface.co/transformers/main_classes/trainer.html#seq2seqtrainer) استفاده می‌کنیم که یک زیرکلاس از `Trainer` است و به ما امکان می‌دهد تا با استفاده از روش `generate()` برای پیش‌بینی خروجی‌ها از ورودی‌ها، به درستی با ارزیابی برخورد کنیم. وقتی در مورد محاسبه متریک صحبت می‌کنیم، با جزئیات بیشتری به این موضوع خواهیم پرداخت.
اول از همه، برای کوک کردن به یک مدل واقعی نیاز داریم. ما از API معمول `AutoModel` استفاده خواهیم کرد:
```py
from transformers import AutoModelForSeq2SeqLM
model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)
```
{:else}
## کوک کردن مدل با Keras[[fine-tuning-the-model-with-keras]]
اول از همه، برای کوک کردن به یک مدل واقعی نیاز داریم. ما از API معمول `AutoModel` استفاده خواهیم کرد:
```py
from transformers import TFAutoModelForSeq2SeqLM
model = TFAutoModelForSeq2SeqLM.from_pretrained(model_checkpoint, from_pt=True)
```
💡 نقطه بررسی `Helsinki-NLP/opus-mt-en-fr` فقط وزن‌های PyTorch را دارد، بنابراین
اگر سعی کنید مدل را بدون استفاده از ... بارگذاری کنید، با خطا مواجه خواهید شد.
آرگومان `from_pt=True` در متد `from_pretrained()`. وقتی مشخص می‌کنید
`from_pt=True`، کتابخانه به طور خودکار دانلود و تبدیل خواهد شد
وزن‌های PyTorch برای شما. همانطور که می‌بینید، جابجایی بین آنها بسیار ساده است.
چارچوب‌ها در 🤗 ترنسفورمرز!
{/if}
توجه کنید که این بار از مدلی استفاده می‌کنیم که برای وظیفه‌ی ترجمه تعلیم داده شده و همین حالا قابل استفاده است؛ بنابراین هشداری درباره‌ی وزن‌های مفقود یا تازه مقداردهی‌شده دریافت نمی‌کنیم.
### گردآوری داده‌ها[[data-collation]]
برای هم‌طول‌سازی بتچ‌های پویا به یک جمع‌کننده‌ی داده نیاز داریم. اینجا نمی‌توانیم مانند [فصل ۳](/course/chapter3) فقط از `DataCollatorWithPadding` استفاده کنیم، چون آن فقط ورودی‌ها (شناسه‌های ورودی، ماسک توجه و شناسه‌های نوع توکِن) را هم‌طول می‌کند. برچسب‌ها نیز باید تا بیشترین طول موجود در برچسب‌ها هم‌طول شوند. همان‌طور که پیش‌تر گفتیم، مقدار padding برای برچسب‌ها باید `-100` باشد، نه توکِن padding توکِن‌ساز، تا مقادیر padding در محاسبه‌ی هزینه نادیده گرفته شوند.
همه این کارها توسط یک [`DataCollatorForSeq2Seq`](https://huggingface.co/transformers/main_classes/data_collator.html#datacollatorforseq2seq) انجام می‌شود. مانند `DataCollatorWithPadding`، این واحد از `tokenizer` برای پیش‌پردازش ورودی‌ها استفاده می‌کند، اما `model` را نیز دریافت می‌کند. دلیل این امر آن است که این گردآورنده داده‌ها مسئول آماده‌سازی شناسه‌های ورودی رمزگشا نیز خواهد بود که نسخه‌های تغییر یافته برچسب‌ها با یک توکن ویژه در ابتدا هستند. از آنجایی که این تغییر برای معماری‌های مختلف کمی متفاوت انجام می‌شود، `DataCollatorForSeq2Seq` باید شیء `model` را بشناسد:
{#if fw === 'pt'}
```py
from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)
```
{:else}
```py
from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer, model=model, return_tensors="tf")
```
{/if}
برای آزمایش این مورد روی چند نمونه، آن را در فهرستی از مثال‌های مجموعه آموزشی توکن‌سازی‌شده خود فراخوانی می‌کنیم:
```py
batch = data_collator([tokenized_datasets["train"][i] for i in range(1, 3)])
batch.keys()
```
```python out
dict_keys(['attention_mask', 'input_ids', 'labels', 'decoder_input_ids'])
```
می‌توانیم با استفاده از `-100` بررسی کنیم که برچسب‌های ما به حداکثر طول دسته اضافه شده‌اند:
```py
batch["labels"]
```
```python out
tensor([[ 577, 5891, 2, 3184, 16, 2542, 5, 1710, 0, -100,
-100, -100, -100, -100, -100, -100],
[ 1211, 3, 49, 9409, 1211, 3, 29140, 817, 3124, 817,
550, 7032, 5821, 7907, 12649, 0]])
```
و همچنین می‌توانیم نگاهی به شناسه‌های ورودی رمزگشا بیندازیم تا ببینیم که آنها نسخه‌های تغییر یافته برچسب‌ها هستند:
```py
batch["decoder_input_ids"]
```
```python out
tensor([[59513, 577, 5891, 2, 3184, 16, 2542, 5, 1710, 0,
59513, 59513, 59513, 59513, 59513, 59513],
[59513, 1211, 3, 49, 9409, 1211, 3, 29140, 817, 3124,
817, 550, 7032, 5821, 7907, 12649]])
```
در اینجا برچسب‌های عناصر اول و دوم در دیتاسِت ما آمده است:
```py
for i in range(1, 3):
print(tokenized_datasets["train"][i]["labels"])
```
```python out
[577, 5891, 2, 3184, 16, 2542, 5, 1710, 0]
[1211, 3, 49, 9409, 1211, 3, 29140, 817, 3124, 817, 550, 7032, 5821, 7907, 12649, 0]
```
{#if fw === 'pt'}
این `data_collator` را به `Seq2SeqTrainer` می‌دهیم. حالا نگاهی به معیار بیندازیم.
{:else}
اکنون می‌توانیم از این `data_collator` برای تبدیل هر یک از دیتاسِت‌های خود به `tf.data.Dataset` استفاده کنیم که آماده آموزش است:
```python
tf_train_dataset = model.prepare_tf_dataset(
tokenized_datasets["train"],
collate_fn=data_collator,
shuffle=True,
batch_size=32,
)
tf_eval_dataset = model.prepare_tf_dataset(
tokenized_datasets["validation"],
collate_fn=data_collator,
shuffle=False,
batch_size=16,
)
```
{/if}
### معیارها[[metrics]]
{#if fw === 'pt'}
ویژگی‌ای که `Seq2SeqTrainer` به سوپرکلاس خود `Trainer` اضافه می‌کند، قابلیت استفاده از روش `generate()` در طول ارزیابی یا پیش‌بینی است. در طول آموزش، مدل از `decoder_input_ids` با یک ماسک توجه استفاده می‌کند تا اطمینان حاصل شود که از توکن‌های پس از توکنی که سعی در پیش‌بینی آن دارد استفاده نمی‌کند تا آموزش را سرعت بخشد. در طول استنتاج، ما نمی‌توانیم از آنها استفاده کنیم زیرا برچسب نخواهیم داشت، بنابراین ایده خوبی است که مدل خود را با همان تنظیمات ارزیابی کنیم.
همانطور که در [فصل ۱](/course/chapter1/6) دیدیم، رمزگشا با پیش‌بینی توکن‌ها به صورت یک به یک، استنتاج را انجام می‌دهد -- چیزی که در پشت صحنه در ترنسفورمرهای 🤗 با روش `generate()` پیاده‌سازی شده است. `Seq2SeqTrainer` به ما اجازه می‌دهد در صورت تنظیم `predict_with_generate=True` از آن روش برای ارزیابی استفاده کنیم.
{/if}
معیار سنتی مورد استفاده برای ترجمه، [امتیاز BLEU](https://en.wikipedia.org/wiki/BLEU) است که در [مقاله‌ای در سال ۲۰۰۲](https://aclanthology.org/P02-1040.pdf) توسط کیشور پاپیننی و همکارانش معرفی شد. امتیاز BLEU میزان نزدیکی ترجمه‌ها به برچسب‌هایشان را ارزیابی می‌کند. این معیار، میزان فهم یا صحت دستوری خروجی‌های تولید شده توسط مدل را اندازه‌گیری نمی‌کند، بلکه از قوانین آماری برای اطمینان از اینکه تمام کلمات موجود در خروجی‌های تولید شده در اهداف نیز ظاهر می‌شوند، استفاده می‌کند. در علاوه بر این، قوانینی وجود دارد که تکرار کلمات یکسان را جریمه می‌کند، اگر آنها در اهداف نیز تکرار نشده باشند (برای جلوگیری از تولید جملاتی مانند `"the the the the the"` توسط مدل) و جملاتی را تولید می‌کند که کوتاه‌تر از جملات موجود در اهداف هستند (برای جلوگیری از تولید جملاتی مانند `"the"` توسط مدل).
یکی از نقاط ضعف BLEU این است که انتظار دارد متن از قبل توکن‌سازی شده باشد، که مقایسه امتیازها بین مدل‌هایی که از توکن‌سازهای مختلف استفاده می‌کنند را دشوار می‌کند. بنابراین، رایج‌ترین معیار مورد استفاده برای ارزیابی مدل‌های ترجمه امروزی [SacreBLEU](https://github.com/mjpost/sacrebleu) است که با استانداردسازی مرحله توکن‌سازی، این نقطه ضعف (و نقاط ضعف دیگر) را برطرف می‌کند. برای استفاده از این معیار، ابتدا باید کتابخانه SacreBLEU را نصب کنیم:
```py
!pip install sacrebleu
```
سپس می‌توانیم آن را از طریق `evaluate.load()` مانند کاری که در [فصل 3](/course/chapter3) انجام دادیم، بارگذاری کنیم:
```py
import evaluate
metric = evaluate.load("sacrebleu")
```
این معیار متن‌ها را به‌عنوان ورودی و هدف می‌گیرد. برای چند هدف قابل قبول طراحی شده است، چون معمولاً برای یک جمله چند ترجمه‌ی پذیرفتنی وجود دارد؛ دیتاسِتی که استفاده می‌کنیم فقط یکی ارائه می‌دهد، اما در NLP دیتاسِت‌هایی با چند جمله به‌عنوان برچسب هم کم نیستند. بنابراین پیش‌بینی‌ها باید فهرستی از جمله‌ها و مراجع باید فهرستی از فهرست جمله‌ها باشند.
بیایید یک مثال را امتحان کنیم:
```py
predictions = [
"This plugin lets you translate web pages between several languages automatically."
]
references = [
[
"This plugin allows you to automatically translate web pages between several languages."
]
]
metric.compute(predictions=predictions, references=references)
```
```python out
{'score': 46.750469682990165,
'counts': [11, 6, 4, 3],
'totals': [12, 11, 10, 9],
'precisions': [91.67, 54.54, 40.0, 33.33],
'bp': 0.9200444146293233,
'sys_len': 12,
'ref_len': 13}
```
این مدل امتیاز BLEU معادل ۴۶.۷۵ را کسب می‌کند که نسبتاً خوب است -- برای مرجع، مدل اصلی ترنسفورمر در مقاله ["توجه، تمام چیزی است که نیاز دارید"](https://arxiv.org/pdf/1706.03762.pdf) در یک کار ترجمه مشابه بین انگلیسی و فرانسوی، امتیاز BLEU معادل ۴۱.۸ را کسب کرد! (برای اطلاعات بیشتر در مورد معیارهای جداگانه، مانند `counts` و `bp`، به مخزن [SacreBLEU](https://github.com/mjpost/sacrebleu/blob/078c440168c6adc89ba75fe6d63f0d922d42bcfe/sacrebleu/metrics/bleu.py#L74) مراجعه کنید.) از سوی دیگر، اگر با دو نوع پیش‌بینی بد امتحان کنیم (با تکرارهای زیاد یا خیلی کوتاه) که اغلب از مدل‌های ترجمه حاصل می‌شوند، امتیازهای BLEU نسبتاً بدی خواهیم گرفت:
```py
predictions = ["This This This This"]
references = [
[
"This plugin allows you to automatically translate web pages between several languages."
]
]
metric.compute(predictions=predictions, references=references)
```
```python out
{'score': 1.683602693167689,
'counts': [1, 0, 0, 0],
'totals': [4, 3, 2, 1],
'precisions': [25.0, 16.67, 12.5, 12.5],
'bp': 0.10539922456186433,
'sys_len': 4,
'ref_len': 13}
```
```py
predictions = ["This plugin"]
references = [
[
"This plugin allows you to automatically translate web pages between several languages."
]
]
metric.compute(predictions=predictions, references=references)
```
```python out
{'score': 0.0,
'counts': [2, 1, 0, 0],
'totals': [2, 1, 0, 0],
'precisions': [100.0, 100.0, 0.0, 0.0],
'bp': 0.004086771438464067,
'sys_len': 2,
'ref_len': 13}
```
این امتیاز می‌تواند از ۰ تا ۱۰۰ باشد و هر چه بالاتر باشد بهتر است.
{#if fw === 'tf'}
برای تبدیل خروجی‌های مدل به متن قابل استفاده برای معیار، از متد `tokenizer.batch_decode()` استفاده می‌کنیم. فقط باید همه‌ی `-100`ها را از برچسب‌ها پاک کنیم؛ توکِن‌ساز همین کار را برای توکِن padding خودکار انجام می‌دهد. تابعی تعریف می‌کنیم که مدل و دیتاسِت را بگیرد و معیارها را محاسبه کند. همچنین برای افزایش چشمگیر عملکرد، کد تولید را با [XLA](https://www.tensorflow.org/xla)، کامپایلر جبر خطی شتاب‌یافته‌ی TensorFlow، کامپایل می‌کنیم. XLA نمودار محاسباتی مدل را بهینه می‌کند و سرعت و مصرف حافظه را بهبود می‌دهد. طبق توضیح [وبلاگ](https://huggingface.co/blog/tf-xla-generate)، چون XLA با شکل‌های ورودی مشابه بهتر کار می‌کند، ورودی‌ها را به مضرب‌های ۱۲۸ هم‌طول می‌کنیم و دیتاسِت تازه‌ای می‌سازیم. دکوراتور `@tf.function(jit_compile=True)` کل تابع تولید را برای کامپایل با XLA علامت می‌زند.
```py
import numpy as np
import tensorflow as tf
from tqdm import tqdm
generation_data_collator = DataCollatorForSeq2Seq(
tokenizer, model=model, return_tensors="tf", pad_to_multiple_of=128
)
tf_generate_dataset = model.prepare_tf_dataset(
tokenized_datasets["validation"],
collate_fn=generation_data_collator,
shuffle=False,
batch_size=8,
)
@tf.function(jit_compile=True)
def generate_with_xla(batch):
return model.generate(
input_ids=batch["input_ids"],
attention_mask=batch["attention_mask"],
max_new_tokens=128,
)
def compute_metrics():
all_preds = []
all_labels = []
for batch, labels in tqdm(tf_generate_dataset):
predictions = generate_with_xla(batch)
decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
labels = labels.numpy()
labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
decoded_preds = [pred.strip() for pred in decoded_preds]
decoded_labels = [[label.strip()] for label in decoded_labels]
all_preds.extend(decoded_preds)
all_labels.extend(decoded_labels)
result = metric.compute(predictions=all_preds, references=all_labels)
return {"bleu": result["score"]}
```
{:else}
برای اینکه از خروجی‌های مدل، متن‌هایی که معیار می‌تواند استفاده کند را دریافت کنیم، از متد `tokenizer.batch_decode()` استفاده خواهیم کرد. فقط باید تمام `-100`های موجود در برچسب‌ها را پاک کنیم (توکن‌ساز به طور خودکار همین کار را برای توکن padding انجام می‌دهد):
```py
import numpy as np
def compute_metrics(eval_preds):
preds, labels = eval_preds
# In case the model returns more than the prediction logits
if isinstance(preds, tuple):
preds = preds[0]
decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
# Replace -100s in the labels as we can't decode them
labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
# Some simple post-processing
decoded_preds = [pred.strip() for pred in decoded_preds]
decoded_labels = [[label.strip()] for label in decoded_labels]
result = metric.compute(predictions=decoded_preds, references=decoded_labels)
return {"bleu": result["score"]}
```
{/if}
حالا که این کار انجام شد، آماده‌ایم تا مدل خود را دقیق‌تر تنظیم کنیم!
### کوک کردن مدل[[fine-tuning-the-model]]
اولین قدم ورود به هاگینگ‌فِیس است تا بتوانید نتایج خود را در Model هاب آپلود کنید. یک تابع کمکی برای کمک به شما در این زمینه در یک دفترچه یادداشت وجود دارد:
```python
from huggingface_hub import notebook_login
notebook_login()
```
این یک ویجت نمایش می‌دهد که می‌توانید اطلاعات ورود به سیستم هاگینگ‌فِیس خود را در آن وارد کنید.
اگر در نوت‌بوک کار نمی‌کنید، این خط را در ترمینال خود بنویسید:
```bash
huggingface-cli login
```
{#if fw === 'tf'}
قبل از شروع، بیایید ببینیم بدون هیچ آموزشی چه نتایجی از مدل خود می‌گیریم:
```py
print(compute_metrics())
```
```
{'bleu': 33.26983701454733}
```
پس از این کار همه‌چیز را برای کامپایل و تعلیم مدل آماده می‌کنیم. توجه کنید که `tf.keras.mixed_precision.set_global_policy("mixed_float16")` به کِراس می‌گوید از float16 استفاده کند؛ این کار روی GPUهای پشتیبان (Nvidia 20xx/V100 یا جدیدتر) می‌تواند سرعت را بسیار افزایش دهد.
```python
from transformers import create_optimizer
from transformers.keras_callbacks import PushToHubCallback
import tensorflow as tf
# The number of training steps is the number of samples in the dataset, divided by the batch size then multiplied
# by the total number of epochs. Note that the tf_train_dataset here is a batched tf.data.Dataset,
# not the original Hugging Face Dataset, so its len() is already num_samples // batch_size.
num_epochs = 3
num_train_steps = len(tf_train_dataset) * num_epochs
optimizer, schedule = create_optimizer(
init_lr=5e-5,
num_warmup_steps=0,
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")
```
در مرحله بعد، همان‌طور که در [بخش ۲](/course/chapter7/2) دیدیم، یک `PushToHubCallback` تعریف می‌کنیم تا مدل ما را در طول آموزش در هاب آپلود کند، و سپس به‌سادگی مدل را با آن callback برازش می‌دهیم:
```python
from transformers.keras_callbacks import PushToHubCallback
callback = PushToHubCallback(
output_dir="marian-finetuned-kde4-en-to-fr", tokenizer=tokenizer
)
model.fit(
tf_train_dataset,
validation_data=tf_eval_dataset,
callbacks=[callback],
epochs=num_epochs,
)
```
توجه کنید که با آرگومان `hub_model_id` می‌توانید نام مخزن مقصد را مشخص کنید؛ برای پوش به سازمان به آن نیاز دارید. برای نمونه، هنگام پوش کردن مدل به سازمان [`huggingface-course`](https://huggingface.co/huggingface-course)، مقدار `hub_model_id="huggingface-course/marian-finetuned-kde4-en-to-fr"` را به `Seq2SeqTrainingArguments` افزودیم. به‌طور پیش‌فرض مخزن در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود؛ در اینجا `"sgugger/marian-finetuned-kde4-en-to-fr"` خواهد بود.
> نکته
> 💡 اگر دایرکتوری خروجی که استفاده می‌کنید از قبل وجود دارد، باید یک کلون محلی از مخزنی باشد که می‌خواهید داده‌ها را به آن ارسال کنید. اگر اینطور نیست، هنگام فراخوانی `model.fit()` با خطا مواجه خواهید شد و باید نام جدیدی تنظیم کنید.
در نهایت، بیایید ببینیم معیارهای ما اکنون که آموزش به پایان رسیده است، چگونه به نظر می‌رسند:
```py
print(compute_metrics())
```
```
{'bleu': 57.334066271545865}
```
در این مرحله، می‌توانید از ویجت استنتاج در Model هاب برای آزمایش مدل خود و به اشتراک گذاری آن با دوستان خود استفاده کنید. شما با موفقیت یک مدل را در یک کار ترجمه تنظیم کرده‌اید -- تبریک می‌گویم!
{:else}
پس از انجام این کار، می‌توانیم `Seq2SeqTrainingArguments` خود را تعریف کنیم. مانند `Trainer`، از یک زیرکلاس `TrainingArguments` استفاده می‌کنیم که شامل چند فیلد دیگر است:
```python
from transformers import Seq2SeqTrainingArguments
args = Seq2SeqTrainingArguments(
f"marian-finetuned-kde4-en-to-fr",
evaluation_strategy="no",
save_strategy="epoch",
learning_rate=2e-5,
per_device_train_batch_size=32,
per_device_eval_batch_size=64,
weight_decay=0.01,
save_total_limit=3,
num_train_epochs=3,
predict_with_generate=True,
fp16=True,
push_to_hub=True,
)
```
علاوه بر ابرپارامترهای معمول مانند نرخ یادگیری، تعداد دوره‌ها، اندازه‌ی بتچ و مقداری کاهش وزن، چند تغییر نسبت به بخش‌های قبلی داریم:
- ما هیچ ارزیابی منظمی تنظیم نمی‌کنیم، زیرا ارزیابی مدتی طول می‌کشد؛ ما فقط مدل خود را یک بار قبل و بعد از آموزش ارزیابی خواهیم کرد.
- ما `fp16=True` را تنظیم کردیم که سرعت آموزش را در پردازنده‌های گرافیکی مدرن افزایش می‌دهد.
- ما `predict_with_generate=True` را همانطور که در بالا بحث شد، تنظیم می‌کنیم.
- ما از `push_to_hub=True` برای آپلود مدل به هاب در پایان هر دوره استفاده می‌کنیم.
با آرگومان `hub_model_id` می‌توانید نام کامل مخزن مقصد را مشخص کنید؛ برای پوش به سازمان به آن نیاز دارید. برای نمونه، سازمان [huggingface-course](https://huggingface.co/huggingface-course) را می‌توان به‌عنوان مقصد تعیین کرد. به‌طور پیش‌فرض مخزن در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود؛ در اینجا `"sgugger/marian-finetuned-kde4-en-to-fr"` خواهد بود.
> نکته
> 💡 اگر دایرکتوری خروجی که استفاده می‌کنید از قبل وجود دارد، باید یک کلون محلی از مخزنی باشد که می‌خواهید داده‌ها را به آن ارسال کنید. اگر اینطور نیست، هنگام تعریف `Seq2SeqTrainer` خود با خطا مواجه خواهید شد و باید نام جدیدی تنظیم کنید.
در نهایت، همه چیز را به `Seq2SeqTrainer` ارسال می‌کنیم:
```python
from transformers import Seq2SeqTrainer
trainer = Seq2SeqTrainer(
model,
args,
train_dataset=tokenized_datasets["train"],
eval_dataset=tokenized_datasets["validation"],
data_collator=data_collator,
tokenizer=tokenizer,
compute_metrics=compute_metrics,
)
```
قبل از آموزش، ابتدا به امتیازی که مدل ما دریافت می‌کند نگاه می‌کنیم تا دوباره بررسی کنیم که با کوک کردن خود اوضاع را بدتر نمی‌کنیم. این دستور کمی زمان می‌برد، بنابراین می‌توانید در حین اجرای آن یک قهوه بنوشید:
```python
trainer.evaluate(max_length=max_length)
```
```python out
{'eval_loss': 1.6964408159255981,
'eval_bleu': 39.26865061007616,
'eval_runtime': 965.8884,
'eval_samples_per_second': 21.76,
'eval_steps_per_second': 0.341}
```
امتیاز ۳۹ در BLEU خیلی بد نیست، که نشان دهنده این واقعیت است که مدل ما در حال حاضر در ترجمه جملات انگلیسی به فرانسوی خوب عمل می‌کند.
مرحله بعدی آموزش است که آن هم کمی زمان‌بر خواهد بود:
```python
trainer.train()
```
توجه داشته باشید که در حین آموزش، هر بار که مدل ذخیره می‌شود (در اینجا، هر دوره) در پس‌زمینه در هاب آپلود می‌شود. به این ترتیب، در صورت لزوم می‌توانید آموزش خود را روی دستگاه دیگری از سر بگیرید.
پس از پایان تعلیم، دوباره مدل را ارزیابی می‌کنیم؛ امیدواریم امتیاز BLEU بهتر شده باشد!
```py
trainer.evaluate(max_length=max_length)
```
```python out
{'eval_loss': 0.8558505773544312,
'eval_bleu': 52.94161337775576,
'eval_runtime': 714.2576,
'eval_samples_per_second': 29.426,
'eval_steps_per_second': 0.461,
'epoch': 3.0}
```
این یعنی تقریباً ۱۴ امتیاز پیشرفت، که خیلی خوب است.
در پایان، از متد `push_to_hub()` استفاده می‌کنیم تا جدیدترین نسخه‌ی مدل روی هاب بارگذاری شود. `Trainer` همچنین کارت مدلی با همه‌ی نتایج ارزیابی می‌سازد و آن را بارگذاری می‌کند. این کارت مدل فراداده‌ای دارد که به هاب مدل کمک می‌کند ویجت مناسب نمونه‌ی استنتاج را انتخاب کند. معمولاً کلاس مدل برای تشخیص ویجت کافی است، اما اینجا یک کلاس مدل برای انواع مسائل دنباله‌به‌دنباله به کار می‌رود؛ پس مشخص می‌کنیم مدل برای ترجمه است:
```py
trainer.push_to_hub(tags="translation", commit_message="Training complete")
```
این دستور، آدرس URL مربوط به کامیتی که اخیراً انجام داده است را برمی‌گرداند، اگر می‌خواهید آن را بررسی کنید:
```python out
'https://huggingface.co/sgugger/marian-finetuned-kde4-en-to-fr/commit/3601d621e3baae2bc63d3311452535f8f58f6ef3'
```
در این مرحله، می‌توانید از ویجت استنتاج در Model هاب برای آزمایش مدل خود و به اشتراک گذاری آن با دوستان خود استفاده کنید. شما با موفقیت یک مدل را در یک کار ترجمه تنظیم کرده‌اید -- تبریک می‌گویم!
اگر می‌خواهید کمی عمیق‌تر به حلقه آموزش بپردازید، اکنون به شما نشان خواهیم داد که چگونه همین کار را با استفاده از 🤗 Accelerate انجام دهید.
{/if}
{#if fw === 'pt'}
## یک حلقه آموزشی سفارشی[[a-custom-training-loop]]
حالا حلقه‌ی کامل تعلیم را بررسی می‌کنیم تا بتوانید بخش‌های لازم را به‌سادگی سفارشی کنید. این حلقه بسیار شبیه کاری است که در [بخش ۲](/course/chapter7/2) و [فصل ۳](/course/chapter3/4) انجام دادیم.
### آماده‌سازی همه‌چیز برای آموزش[[preparing-everything-for-training]]
شما همه این‌ها را چندین بار دیده‌اید، بنابراین خیلی سریع کد را بررسی می‌کنیم. ابتدا `DataLoader`ها را از دیتاسِت‌های خود می‌سازیم، پس از تنظیم دیتاسِت‌ها به فرمت `"torch"`، تانسورهای PyTorch را دریافت می‌کنیم:
```py
from torch.utils.data import DataLoader
tokenized_datasets.set_format("torch")
train_dataloader = DataLoader(
tokenized_datasets["train"],
shuffle=True,
collate_fn=data_collator,
batch_size=8,
)
eval_dataloader = DataLoader(
tokenized_datasets["validation"], collate_fn=data_collator, batch_size=8
)
```
سپس مدل را دوباره نمونه‌سازی می‌کنیم تا کوک کردن قبلی را ادامه ندهیم و دوباره از مدل از پیش تعلیم‌دیده شروع کنیم:
```py
model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)
```
سپس به یک بهینه‌ساز نیاز داریم:
```py
from torch.optim import AdamW
optimizer = AdamW(model.parameters(), lr=2e-5)
```
وقتی همه آن اشیاء را داشتیم، می‌توانیم آنها را به متد `accelerator.prepare()` ارسال کنیم. به یاد داشته باشید که اگر می‌خواهید روی TPUها در یک نوت‌بوک Colab آموزش دهید، باید تمام این کد را به یک تابع آموزشی منتقل کنید و این تابع نباید هیچ سلولی را که یک `Accelerator` را نمونه‌سازی می‌کند، اجرا کند.
```py
from accelerate import Accelerator
accelerator = Accelerator()
model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
model, optimizer, train_dataloader, eval_dataloader
)
```
حالا که `train_dataloader` خود را به `accelerator.prepare()` ارسال کرده‌ایم، می‌توانیم از طول آن برای محاسبه تعداد مراحل آموزش استفاده کنیم. به یاد داشته باشید که همیشه باید این کار را پس از آماده‌سازی dataloader انجام دهیم، زیرا این روش طول `DataLoader` را تغییر می‌دهد. ما از یک زمانبندی خطی کلاسیک از نرخ یادگیری تا ۰ استفاده می‌کنیم:
```py
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,
)
```
در پایان، برای پوش کردن مدل به هاب باید در یک پوشه‌ی کاری شیء `Repository` بسازیم. ابتدا اگر هنوز وارد هاب هاگینگ‌فِیس نشده‌اید، وارد شوید. نام مخزن را از شناسه‌ی مدلی که می‌خواهیم تعیین می‌کنیم؛ می‌توانید `repo_name` را با انتخاب خود جایگزین کنید، فقط باید نام کاربری شما را داشته باشد؛ تابع `get_full_repo_name()` این کار را انجام می‌دهد:
```py
from huggingface_hub import Repository, get_full_repo_name
model_name = "marian-finetuned-kde4-en-to-fr-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name
```
```python out
'sgugger/marian-finetuned-kde4-en-to-fr-accelerate'
```
سپس می‌توانیم آن مخزن را در یک پوشه محلی کپی کنیم. اگر از قبل وجود داشته باشد، این پوشه محلی باید یک کپی از مخزنی باشد که با آن کار می‌کنیم:
```py
output_dir = "marian-finetuned-kde4-en-to-fr-accelerate"
repo = Repository(output_dir, clone_from=repo_name)
```
اکنون می‌توانیم هر چیزی را که در `output_dir` ذخیره می‌کنیم، با فراخوانی متد `repo.push_to_hub()` آپلود کنیم. این به ما کمک می‌کند تا مدل‌های میانی را در پایان هر دوره آپلود کنیم.
### حلقه آموزشی[[training-loop]]
اکنون آماده‌ایم حلقه‌ی کامل تعلیم را بنویسیم. برای ساده کردن ارزیابی، تابع `postprocess()` را تعریف می‌کنیم که پیش‌بینی‌ها و برچسب‌ها را می‌گیرد و به فهرست رشته‌هایی تبدیل می‌کند که شیء `metric` انتظار دارد:
```py
def postprocess(predictions, labels):
predictions = predictions.cpu().numpy()
labels = labels.cpu().numpy()
decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
# Replace -100 in the labels as we can't decode them.
labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
# Some simple post-processing
decoded_preds = [pred.strip() for pred in decoded_preds]
decoded_labels = [[label.strip()] for label in decoded_labels]
return decoded_preds, decoded_labels
```
حلقه آموزشی بسیار شبیه به حلقه‌های موجود در [بخش ۲](/course/chapter7/2) و [فصل ۳](/course/chapter3) است، با چند تفاوت در بخش ارزیابی -- پس بیایید روی آن تمرکز کنیم!
نخست توجه کنید که برای محاسبه‌ی پیش‌بینی‌ها از متد `generate()` استفاده می‌کنیم، اما این متد روی مدل پایه قرار دارد، نه مدل پوشانده‌شده‌ای که 🤗 Accelerate در متد `prepare()` ساخته است. بنابراین ابتدا مدل را از پوشش خارج می‌کنیم و سپس این متد را فراخوانی می‌کنیم.
نکته دوم این است که، مانند [توکِن classification](/course/chapter7/2)، ممکن است دو فرآیند ورودی‌ها و برچسب‌ها را به شکل‌های مختلف پر کرده باشند، بنابراین ما از `accelerator.pad_across_processes()` استفاده می‌کنیم تا پیش‌بینی‌ها و برچسب‌ها را قبل از فراخوانی متد `gather()` به شکل یکسانی درآوریم. اگر این کار را نکنیم، ارزیابی یا با خطا مواجه می‌شود یا برای همیشه متوقف می‌شود.
```py
from tqdm.auto import tqdm
import torch
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()
for batch in tqdm(eval_dataloader):
with torch.no_grad():
generated_tokens = accelerator.unwrap_model(model).generate(
batch["input_ids"],
attention_mask=batch["attention_mask"],
max_length=128,
)
labels = batch["labels"]
# Necessary to pad predictions and labels for being gathered
generated_tokens = accelerator.pad_across_processes(
generated_tokens, dim=1, pad_index=tokenizer.pad_token_id
)
labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100)
predictions_gathered = accelerator.gather(generated_tokens)
labels_gathered = accelerator.gather(labels)
decoded_preds, decoded_labels = postprocess(predictions_gathered, labels_gathered)
metric.add_batch(predictions=decoded_preds, references=decoded_labels)
results = metric.compute()
print(f"epoch {epoch}, BLEU score: {results['score']:.2f}")
# 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, BLEU score: 53.47
epoch 1, BLEU score: 54.24
epoch 2, BLEU score: 54.44
```
پس از انجام این کار، باید مدلی داشته باشید که نتایج آن بسیار شبیه به مدلی باشد که با `Seq2SeqTrainer` آموزش دیده است. می‌توانید مدلی را که ما با استفاده از این کد تعلیم داده‌ایم، در [*huggingface-course/marian-finetuned-kde4-en-to-fr-accelerate*](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr-accelerate) بررسی کنید. و اگر می‌خواهید هرگونه تغییری را در حلقه آموزش آزمایش کنید، می‌توانید مستقیماً آنها را با ویرایش کد نشان داده شده در بالا پیاده‌سازی کنید!
{/if}
## استفاده از مدل کوک‌شده[[using-the-fine-tuned-model]]
قبلاً نشان دادیم چگونه می‌توانید مدل کوک‌شده روی هاب مدل را با ویجت استنتاج به کار ببرید. برای استفاده‌ی محلی از آن در یک `pipeline`، فقط باید شناسه‌ی درست مدل را مشخص کنید:
```py
from transformers import pipeline
# Replace this with your own checkpoint
model_checkpoint = "huggingface-course/marian-finetuned-kde4-en-to-fr"
translator = pipeline("translation", model=model_checkpoint)
translator("Default to expanded threads")
```
```python out
[{'translation_text': 'Par défaut, développer les fils de discussion'}]
```
همانطور که انتظار می‌رفت، مدل از پیش تعلیم‌دیده ما دانش خود را با مجموعه‌ای که آن را روی آن کوک کردن کردیم، تطبیق داد و به جای اینکه کلمه انگلیسی "threads" را به حال خود رها کند، اکنون آن را به نسخه رسمی فرانسوی ترجمه می‌کند. برای "plugin" نیز به همین صورت است:
```py
translator(
"Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)
```
```python out
[{'translation_text': "Impossible d'importer %1 en utilisant le module externe d'importation OFX. Ce fichier n'est pas le bon format."}]
```
یک مثال عالی دیگر از تطبیق دامنه!
> [!TIP]
> ✏️ **نوبت شماست!** مدل برای نمونه‌ای که پیش‌تر واژهٔ «email» را در آن شناسایی کردید چه خروجی‌ای برمی‌گرداند؟

Xet Storage Details

Size:
58.4 kB
·
Xet hash:
cb117b2b606cb9e1b84076ca11f0bb0bc7ff76fdb61f1cb7867848f8e2c8bb7d

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