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}

حالا بیایید به سراغ ترجمه برویم. این یکی دیگر از وظیفه‌های توالی به توالی است، به این معنی که مسئله‌ای است که می‌توان آن را به صورت رفتن از یک توالی به توالی دیگر فرموله کرد. از این نظر، مسئله بسیار نزدیک به خلاصه‌سازی است و می‌توانید آنچه را که در اینجا خواهیم دید با سایر مسائل توالی به توالی مانند موارد زیر تطبیق دهید:

  • انتقال سبک: ایجاد مدلی که متون نوشته شده با یک سبک خاص را به سبک دیگر ترجمه می‌کند (مثلاً، متن رسمی را به متن غیررسمی یا انگلیسی شکسپیر را به انگلیسی مدرن)
  • پاسخ به سوالات مولد: ایجاد مدلی که با توجه به زمینه، پاسخ سوالات را تولید می‌کند

اگر حجم متن شما به دو (یا چند) زبان به اندازه کافی زیاد باشد، می‌توانید یک مدل ترجمه جدید را از ابتدا آموزش دهید، همانطور که در بخش مدل‌سازی زبان سببی انجام خواهیم داد. با این حال، کوک کردن یک مدل ترجمه‌ی موجود، چه یک مدل چندزبانه مانند mT5 یا mBART باشد که می‌خواهید آن را برای یک جفت زبان خاص کوک کنید، یا حتی مدلی تخصصی برای ترجمه از زبانی به زبان دیگر که می‌خواهید آن را با پیکره‌ی خاص خود کوک کنید، سریع‌تر خواهد بود.

در این بخش، ما یک مدل Marian را که از قبل برای ترجمه از انگلیسی به فرانسوی (از آنجایی که بسیاری از کارمندان هاگینگ‌فِیس به هر دو زبان صحبت می‌کنند) در دیتاسِت KDE4 که مجموعه‌ای از فایل‌های محلی برای برنامه‌های KDE است، آموزش دیده است، به دقت تنظیم خواهیم کرد. مدلی که ما استفاده خواهیم کرد، بر روی یک مجموعه بزرگ از متون فرانسوی و انگلیسی گرفته شده از دیتاسِت Opus که در واقع شامل KDE4 است، از قبل آموزش دیده است. دیتاسِت. اما حتی اگر مدل از پیش تعلیم‌دیده‌ای که استفاده می‌کنیم، آن داده‌ها را در طول پیش‌تعلیم خود دیده باشد، خواهیم دید که می‌توانیم پس از کوک کردن، نسخه بهتری از آن را بدست آوریم.

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

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

آماده‌سازی داده‌ها[[preparing-the-data]]

برای کوک کردن یا آموزش یک مدل ترجمه از ابتدا، به یک دیتاسِت مناسب برای این کار نیاز داریم. همانطور که قبلاً ذکر شد، ما در این بخش از دیتاسِت KDE4 استفاده خواهیم کرد، اما شما می‌توانید کد را به راحتی با استفاده از داده‌های خود تطبیق دهید، البته تا زمانی که جفت جملاتی به دو زبانی که می‌خواهید از و به آنها ترجمه کنید، داشته باشید. اگر به یادآوری نحوه بارگذاری کد خود نیاز دارید، به فصل 5 مراجعه کنید. داده‌های سفارشی در یک Dataset.

دیتاسِت KDE4[[the-kde4-dataset]]

طبق معمول، دیتاسِت خود را با استفاده از تابع load_dataset() دانلود می‌کنیم:

from datasets import load_dataset

raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")

اگر می‌خواهید با یک جفت زبان متفاوت کار کنید، می‌توانید آنها را با کدهایشان مشخص کنید. در مجموع ۹۲ زبان برای این دیتاسِت موجود است؛ می‌توانید با باز کردن برچسب‌های زبان در کارت دیتاسِت آن، همه آنها را مشاهده کنید.

بیایید نگاهی به دیتاسِت‌ها بیندازیم:

raw_datasets
DatasetDict({
    train: Dataset({
        features: ['id', 'translation'],
        num_rows: 210173
    })
})

ما ۲۱۰٬۱۷۳ جفت جمله داریم، اما همه در یک بخش قرار دارند؛ بنابراین باید مجموعه‌ی اعتبارسنجی خودمان را بسازیم. همان‌طور که در فصل ۵ دیدیم، یک Dataset متد train_test_split() دارد که به ما کمک می‌کند. برای تکرارپذیری یک seed هم می‌دهیم:

split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20)
split_datasets
DatasetDict({
    train: Dataset({
        features: ['id', 'translation'],
        num_rows: 189155
    })
    test: Dataset({
        features: ['id', 'translation'],
        num_rows: 21018
    })
})

می‌توانیم کلید "test" را به "validation" به این صورت تغییر نام دهیم:

split_datasets["validation"] = split_datasets.pop("test")

حالا بیایید نگاهی به یکی از عناصر دیتاسِت‌ها بیندازیم:

split_datasets["train"][1]["translation"]
{'en': 'Default to expanded threads',
 'fr': 'Par défaut, développer les fils de discussion'}

ما یک فرهنگ لغت با دو جمله در دو زبانی که درخواست کردیم دریافت می‌کنیم. یکی از ویژگی‌های این دیتاسِت پر از اصطلاحات فنی علوم کامپیوتر این است که همه آنها به طور کامل به زبان فرانسوی ترجمه شده‌اند. با این حال، مهندسان فرانسوی هنگام صحبت کردن، بیشتر کلمات خاص علوم کامپیوتر را به انگلیسی باقی می‌گذارند. برای مثال، در اینجا، کلمه "threads" ممکن است در یک جمله فرانسوی، به خصوص در یک مکالمه فنی، ظاهر شود. اما در این دیتاسِت‌ای که به عبارت صحیح‌تر «fils de discussion» ترجمه شده است. مدل از پیش تعلیم‌دیده‌ای که ما استفاده می‌کنیم، که بر روی مجموعه‌ای بزرگتر از جملات فرانسوی و انگلیسی تعلیم‌دیده است، گزینه آسان‌ترِ باقی گذاشتن کلمه به همان شکل فعلی را انتخاب می‌کند:

from transformers import pipeline

model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
translator = pipeline("translation", model=model_checkpoint)
translator("Default to expanded threads")
[{'translation_text': 'Par défaut pour les threads élargis'}]

نمونه دیگری از این رفتار را می‌توان با کلمه "plugin" مشاهده کرد که رسماً یک کلمه فرانسوی نیست اما اکثر گویشوران بومی آن را می‌فهمند و زحمت ترجمه آن را به خود نمی‌دهند. در دیتاسِت KDE4 این کلمه در زبان فرانسوی به صورت رسمی‌تر «module d'extension» ترجمه شده است:

split_datasets["train"][172]["translation"]
{'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."}

با این حال، مدل از پیش تعلیم‌دیده‌ی ما به کلمه‌ی انگلیسی فشرده و آشنا پایبند است:

translator(
    "Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)
[{'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 بیش از هزار مدل را به زبان‌های مختلف ارائه می‌دهد.

from transformers import AutoTokenizer

model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint, return_tensors="pt")

همچنین می‌توانید model_checkpoint را با هر مدل دیگری که از هاب ترجیح می‌دهید، یا یک پوشه محلی که در آن یک مدل از پیش آموزش دیده و یک توکنایزر ذخیره کرده‌اید، جایگزین کنید.

نکته 💡 اگر از یک توکن‌ساز چندزبانه مانند mBART، mBART-50 یا M2M100 استفاده می‌کنید، باید کدهای زبان ورودی‌ها و اهداف خود را در توکن‌ساز با تنظیم tokenizer.src_lang و tokenizer.tgt_lang روی مقادیر صحیح تنظیم کنید.

آماده‌سازی داده‌های ما بسیار ساده است. فقط یک نکته وجود دارد که باید به خاطر داشته باشید؛ باید مطمئن شوید که توکن‌ساز، اهداف را به زبان خروجی (در اینجا، فرانسوی) پردازش می‌کند. می‌توانید این کار را با ارسال اهداف به آرگومان text_targets از متد __call__ توکن‌ساز انجام دهید.

برای دیدن نحوه‌ی عملکرد این روش، بیایید یک نمونه از هر زبان در مجموعه‌ی آموزشی را پردازش کنیم:

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
{'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 به هیچ وجه خوب پیش نخواهد رفت:

wrong_targets = tokenizer(fr_sentence)
print(tokenizer.convert_ids_to_tokens(wrong_targets["input_ids"]))
print(tokenizer.convert_ids_to_tokens(inputs["labels"]))
['▁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 یک دیکشنری با کلیدهای معمول ما (شناسه‌های ورودی، ماسک توجه و غیره) است، آخرین مرحله تعریف تابع پیش‌پردازشی است که روی دیتاسِت‌ها اعمال خواهیم کرد:

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 تنظیم کند.

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

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 استفاده می‌کنیم که یک زیرکلاس از Trainer است و به ما امکان می‌دهد تا با استفاده از روش generate() برای پیش‌بینی خروجی‌ها از ورودی‌ها، به درستی با ارزیابی برخورد کنیم. وقتی در مورد محاسبه متریک صحبت می‌کنیم، با جزئیات بیشتری به این موضوع خواهیم پرداخت.

اول از همه، برای کوک کردن به یک مدل واقعی نیاز داریم. ما از API معمول AutoModel استفاده خواهیم کرد:

from transformers import AutoModelForSeq2SeqLM

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

{:else}

کوک کردن مدل با Keras[[fine-tuning-the-model-with-keras]]

اول از همه، برای کوک کردن به یک مدل واقعی نیاز داریم. ما از API معمول AutoModel استفاده خواهیم کرد:

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]]

برای هم‌طول‌سازی بتچ‌های پویا به یک جمع‌کننده‌ی داده نیاز داریم. اینجا نمی‌توانیم مانند فصل ۳ فقط از DataCollatorWithPadding استفاده کنیم، چون آن فقط ورودی‌ها (شناسه‌های ورودی، ماسک توجه و شناسه‌های نوع توکِن) را هم‌طول می‌کند. برچسب‌ها نیز باید تا بیشترین طول موجود در برچسب‌ها هم‌طول شوند. همان‌طور که پیش‌تر گفتیم، مقدار padding برای برچسب‌ها باید -100 باشد، نه توکِن padding توکِن‌ساز، تا مقادیر padding در محاسبه‌ی هزینه نادیده گرفته شوند.

همه این کارها توسط یک DataCollatorForSeq2Seq انجام می‌شود. مانند DataCollatorWithPadding، این واحد از tokenizer برای پیش‌پردازش ورودی‌ها استفاده می‌کند، اما model را نیز دریافت می‌کند. دلیل این امر آن است که این گردآورنده داده‌ها مسئول آماده‌سازی شناسه‌های ورودی رمزگشا نیز خواهد بود که نسخه‌های تغییر یافته برچسب‌ها با یک توکن ویژه در ابتدا هستند. از آنجایی که این تغییر برای معماری‌های مختلف کمی متفاوت انجام می‌شود، DataCollatorForSeq2Seq باید شیء model را بشناسد:

{#if fw === 'pt'}

from transformers import DataCollatorForSeq2Seq

data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)

{:else}

from transformers import DataCollatorForSeq2Seq

data_collator = DataCollatorForSeq2Seq(tokenizer, model=model, return_tensors="tf")

{/if}

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

batch = data_collator([tokenized_datasets["train"][i] for i in range(1, 3)])
batch.keys()
dict_keys(['attention_mask', 'input_ids', 'labels', 'decoder_input_ids'])

می‌توانیم با استفاده از -100 بررسی کنیم که برچسب‌های ما به حداکثر طول دسته اضافه شده‌اند:

batch["labels"]
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]])

و همچنین می‌توانیم نگاهی به شناسه‌های ورودی رمزگشا بیندازیم تا ببینیم که آنها نسخه‌های تغییر یافته برچسب‌ها هستند:

batch["decoder_input_ids"]
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]])

در اینجا برچسب‌های عناصر اول و دوم در دیتاسِت ما آمده است:

for i in range(1, 3):
    print(tokenized_datasets["train"][i]["labels"])
[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 استفاده کنیم که آماده آموزش است:

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 با یک ماسک توجه استفاده می‌کند تا اطمینان حاصل شود که از توکن‌های پس از توکنی که سعی در پیش‌بینی آن دارد استفاده نمی‌کند تا آموزش را سرعت بخشد. در طول استنتاج، ما نمی‌توانیم از آنها استفاده کنیم زیرا برچسب نخواهیم داشت، بنابراین ایده خوبی است که مدل خود را با همان تنظیمات ارزیابی کنیم.

همانطور که در فصل ۱ دیدیم، رمزگشا با پیش‌بینی توکن‌ها به صورت یک به یک، استنتاج را انجام می‌دهد -- چیزی که در پشت صحنه در ترنسفورمرهای 🤗 با روش generate() پیاده‌سازی شده است. Seq2SeqTrainer به ما اجازه می‌دهد در صورت تنظیم predict_with_generate=True از آن روش برای ارزیابی استفاده کنیم.

{/if}

معیار سنتی مورد استفاده برای ترجمه، امتیاز BLEU است که در مقاله‌ای در سال ۲۰۰۲ توسط کیشور پاپیننی و همکارانش معرفی شد. امتیاز BLEU میزان نزدیکی ترجمه‌ها به برچسب‌هایشان را ارزیابی می‌کند. این معیار، میزان فهم یا صحت دستوری خروجی‌های تولید شده توسط مدل را اندازه‌گیری نمی‌کند، بلکه از قوانین آماری برای اطمینان از اینکه تمام کلمات موجود در خروجی‌های تولید شده در اهداف نیز ظاهر می‌شوند، استفاده می‌کند. در علاوه بر این، قوانینی وجود دارد که تکرار کلمات یکسان را جریمه می‌کند، اگر آنها در اهداف نیز تکرار نشده باشند (برای جلوگیری از تولید جملاتی مانند "the the the the the" توسط مدل) و جملاتی را تولید می‌کند که کوتاه‌تر از جملات موجود در اهداف هستند (برای جلوگیری از تولید جملاتی مانند "the" توسط مدل).

یکی از نقاط ضعف BLEU این است که انتظار دارد متن از قبل توکن‌سازی شده باشد، که مقایسه امتیازها بین مدل‌هایی که از توکن‌سازهای مختلف استفاده می‌کنند را دشوار می‌کند. بنابراین، رایج‌ترین معیار مورد استفاده برای ارزیابی مدل‌های ترجمه امروزی SacreBLEU است که با استانداردسازی مرحله توکن‌سازی، این نقطه ضعف (و نقاط ضعف دیگر) را برطرف می‌کند. برای استفاده از این معیار، ابتدا باید کتابخانه SacreBLEU را نصب کنیم:

!pip install sacrebleu

سپس می‌توانیم آن را از طریق evaluate.load() مانند کاری که در فصل 3 انجام دادیم، بارگذاری کنیم:

import evaluate

metric = evaluate.load("sacrebleu")

این معیار متن‌ها را به‌عنوان ورودی و هدف می‌گیرد. برای چند هدف قابل قبول طراحی شده است، چون معمولاً برای یک جمله چند ترجمه‌ی پذیرفتنی وجود دارد؛ دیتاسِتی که استفاده می‌کنیم فقط یکی ارائه می‌دهد، اما در NLP دیتاسِت‌هایی با چند جمله به‌عنوان برچسب هم کم نیستند. بنابراین پیش‌بینی‌ها باید فهرستی از جمله‌ها و مراجع باید فهرستی از فهرست جمله‌ها باشند.

بیایید یک مثال را امتحان کنیم:

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)
{'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 معادل ۴۶.۷۵ را کسب می‌کند که نسبتاً خوب است -- برای مرجع، مدل اصلی ترنسفورمر در مقاله "توجه، تمام چیزی است که نیاز دارید" در یک کار ترجمه مشابه بین انگلیسی و فرانسوی، امتیاز BLEU معادل ۴۱.۸ را کسب کرد! (برای اطلاعات بیشتر در مورد معیارهای جداگانه، مانند counts و bp، به مخزن SacreBLEU مراجعه کنید.) از سوی دیگر، اگر با دو نوع پیش‌بینی بد امتحان کنیم (با تکرارهای زیاد یا خیلی کوتاه) که اغلب از مدل‌های ترجمه حاصل می‌شوند، امتیازهای BLEU نسبتاً بدی خواهیم گرفت:

predictions = ["This This This This"]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)
{'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}
predictions = ["This plugin"]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)
{'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، کامپایلر جبر خطی شتاب‌یافته‌ی TensorFlow، کامپایل می‌کنیم. XLA نمودار محاسباتی مدل را بهینه می‌کند و سرعت و مصرف حافظه را بهبود می‌دهد. طبق توضیح وبلاگ، چون XLA با شکل‌های ورودی مشابه بهتر کار می‌کند، ورودی‌ها را به مضرب‌های ۱۲۸ هم‌طول می‌کنیم و دیتاسِت تازه‌ای می‌سازیم. دکوراتور @tf.function(jit_compile=True) کل تابع تولید را برای کامپایل با XLA علامت می‌زند.

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 انجام می‌دهد):

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 هاب آپلود کنید. یک تابع کمکی برای کمک به شما در این زمینه در یک دفترچه یادداشت وجود دارد:

from huggingface_hub import notebook_login

notebook_login()

این یک ویجت نمایش می‌دهد که می‌توانید اطلاعات ورود به سیستم هاگینگ‌فِیس خود را در آن وارد کنید.

اگر در نوت‌بوک کار نمی‌کنید، این خط را در ترمینال خود بنویسید:

huggingface-cli login

{#if fw === 'tf'}

قبل از شروع، بیایید ببینیم بدون هیچ آموزشی چه نتایجی از مدل خود می‌گیریم:

print(compute_metrics())
{'bleu': 33.26983701454733}

پس از این کار همه‌چیز را برای کامپایل و تعلیم مدل آماده می‌کنیم. توجه کنید که tf.keras.mixed_precision.set_global_policy("mixed_float16") به کِراس می‌گوید از float16 استفاده کند؛ این کار روی GPUهای پشتیبان (Nvidia 20xx/V100 یا جدیدتر) می‌تواند سرعت را بسیار افزایش دهد.

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

در مرحله بعد، همان‌طور که در بخش ۲ دیدیم، یک PushToHubCallback تعریف می‌کنیم تا مدل ما را در طول آموزش در هاب آپلود کند، و سپس به‌سادگی مدل را با آن callback برازش می‌دهیم:

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، مقدار hub_model_id="huggingface-course/marian-finetuned-kde4-en-to-fr" را به Seq2SeqTrainingArguments افزودیم. به‌طور پیش‌فرض مخزن در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود؛ در اینجا "sgugger/marian-finetuned-kde4-en-to-fr" خواهد بود.

نکته 💡 اگر دایرکتوری خروجی که استفاده می‌کنید از قبل وجود دارد، باید یک کلون محلی از مخزنی باشد که می‌خواهید داده‌ها را به آن ارسال کنید. اگر اینطور نیست، هنگام فراخوانی model.fit() با خطا مواجه خواهید شد و باید نام جدیدی تنظیم کنید.

در نهایت، بیایید ببینیم معیارهای ما اکنون که آموزش به پایان رسیده است، چگونه به نظر می‌رسند:

print(compute_metrics())
{'bleu': 57.334066271545865}

در این مرحله، می‌توانید از ویجت استنتاج در Model هاب برای آزمایش مدل خود و به اشتراک گذاری آن با دوستان خود استفاده کنید. شما با موفقیت یک مدل را در یک کار ترجمه تنظیم کرده‌اید -- تبریک می‌گویم!

{:else}

پس از انجام این کار، می‌توانیم Seq2SeqTrainingArguments خود را تعریف کنیم. مانند Trainer، از یک زیرکلاس TrainingArguments استفاده می‌کنیم که شامل چند فیلد دیگر است:

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 را می‌توان به‌عنوان مقصد تعیین کرد. به‌طور پیش‌فرض مخزن در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود؛ در اینجا "sgugger/marian-finetuned-kde4-en-to-fr" خواهد بود.

نکته 💡 اگر دایرکتوری خروجی که استفاده می‌کنید از قبل وجود دارد، باید یک کلون محلی از مخزنی باشد که می‌خواهید داده‌ها را به آن ارسال کنید. اگر اینطور نیست، هنگام تعریف Seq2SeqTrainer خود با خطا مواجه خواهید شد و باید نام جدیدی تنظیم کنید.

در نهایت، همه چیز را به Seq2SeqTrainer ارسال می‌کنیم:

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

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

trainer.evaluate(max_length=max_length)
{'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 خیلی بد نیست، که نشان دهنده این واقعیت است که مدل ما در حال حاضر در ترجمه جملات انگلیسی به فرانسوی خوب عمل می‌کند.

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

trainer.train()

توجه داشته باشید که در حین آموزش، هر بار که مدل ذخیره می‌شود (در اینجا، هر دوره) در پس‌زمینه در هاب آپلود می‌شود. به این ترتیب، در صورت لزوم می‌توانید آموزش خود را روی دستگاه دیگری از سر بگیرید.

پس از پایان تعلیم، دوباره مدل را ارزیابی می‌کنیم؛ امیدواریم امتیاز BLEU بهتر شده باشد!

trainer.evaluate(max_length=max_length)
{'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 همچنین کارت مدلی با همه‌ی نتایج ارزیابی می‌سازد و آن را بارگذاری می‌کند. این کارت مدل فراداده‌ای دارد که به هاب مدل کمک می‌کند ویجت مناسب نمونه‌ی استنتاج را انتخاب کند. معمولاً کلاس مدل برای تشخیص ویجت کافی است، اما اینجا یک کلاس مدل برای انواع مسائل دنباله‌به‌دنباله به کار می‌رود؛ پس مشخص می‌کنیم مدل برای ترجمه است:

trainer.push_to_hub(tags="translation", commit_message="Training complete")

این دستور، آدرس URL مربوط به کامیتی که اخیراً انجام داده است را برمی‌گرداند، اگر می‌خواهید آن را بررسی کنید:

'https://huggingface.co/sgugger/marian-finetuned-kde4-en-to-fr/commit/3601d621e3baae2bc63d3311452535f8f58f6ef3'

در این مرحله، می‌توانید از ویجت استنتاج در Model هاب برای آزمایش مدل خود و به اشتراک گذاری آن با دوستان خود استفاده کنید. شما با موفقیت یک مدل را در یک کار ترجمه تنظیم کرده‌اید -- تبریک می‌گویم!

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

{/if}

{#if fw === 'pt'}

یک حلقه آموزشی سفارشی[[a-custom-training-loop]]

حالا حلقه‌ی کامل تعلیم را بررسی می‌کنیم تا بتوانید بخش‌های لازم را به‌سادگی سفارشی کنید. این حلقه بسیار شبیه کاری است که در بخش ۲ و فصل ۳ انجام دادیم.

آماده‌سازی همه‌چیز برای آموزش[[preparing-everything-for-training]]

شما همه این‌ها را چندین بار دیده‌اید، بنابراین خیلی سریع کد را بررسی می‌کنیم. ابتدا DataLoaderها را از دیتاسِت‌های خود می‌سازیم، پس از تنظیم دیتاسِت‌ها به فرمت "torch"، تانسورهای PyTorch را دریافت می‌کنیم:

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
)

سپس مدل را دوباره نمونه‌سازی می‌کنیم تا کوک کردن قبلی را ادامه ندهیم و دوباره از مدل از پیش تعلیم‌دیده شروع کنیم:

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

سپس به یک بهینه‌ساز نیاز داریم:

from torch.optim import AdamW

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

وقتی همه آن اشیاء را داشتیم، می‌توانیم آنها را به متد accelerator.prepare() ارسال کنیم. به یاد داشته باشید که اگر می‌خواهید روی TPUها در یک نوت‌بوک Colab آموزش دهید، باید تمام این کد را به یک تابع آموزشی منتقل کنید و این تابع نباید هیچ سلولی را که یک Accelerator را نمونه‌سازی می‌کند، اجرا کند.

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 را تغییر می‌دهد. ما از یک زمانبندی خطی کلاسیک از نرخ یادگیری تا ۰ استفاده می‌کنیم:

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() این کار را انجام می‌دهد:

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
'sgugger/marian-finetuned-kde4-en-to-fr-accelerate'

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

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 انتظار دارد:

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

حلقه آموزشی بسیار شبیه به حلقه‌های موجود در بخش ۲ و فصل ۳ است، با چند تفاوت در بخش ارزیابی -- پس بیایید روی آن تمرکز کنیم!

نخست توجه کنید که برای محاسبه‌ی پیش‌بینی‌ها از متد generate() استفاده می‌کنیم، اما این متد روی مدل پایه قرار دارد، نه مدل پوشانده‌شده‌ای که 🤗 Accelerate در متد prepare() ساخته است. بنابراین ابتدا مدل را از پوشش خارج می‌کنیم و سپس این متد را فراخوانی می‌کنیم.

نکته دوم این است که، مانند توکِن classification، ممکن است دو فرآیند ورودی‌ها و برچسب‌ها را به شکل‌های مختلف پر کرده باشند، بنابراین ما از accelerator.pad_across_processes() استفاده می‌کنیم تا پیش‌بینی‌ها و برچسب‌ها را قبل از فراخوانی متد gather() به شکل یکسانی درآوریم. اگر این کار را نکنیم، ارزیابی یا با خطا مواجه می‌شود یا برای همیشه متوقف می‌شود.

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
        )
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 بررسی کنید. و اگر می‌خواهید هرگونه تغییری را در حلقه آموزش آزمایش کنید، می‌توانید مستقیماً آنها را با ویرایش کد نشان داده شده در بالا پیاده‌سازی کنید!

{/if}

استفاده از مدل کوک‌شده[[using-the-fine-tuned-model]]

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

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")
[{'translation_text': 'Par défaut, développer les fils de discussion'}]

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

translator(
    "Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)
[{'translation_text': "Impossible d'importer %1 en utilisant le module externe d'importation OFX. Ce fichier n'est pas le bon format."}]

یک مثال عالی دیگر از تطبیق دامنه!

✏️ نوبت شماست! مدل برای نمونه‌ای که پیش‌تر واژهٔ «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.