Buckets:

|
download
raw
76.5 kB

خلاصه‌سازی[[summarization]]

{#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/section5_pt.ipynb"}, {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter7/section5_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/section5_tf.ipynb"}, {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter7/section5_tf.ipynb"}, ]} />

{/if}

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

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

همانطور که خواهیم دید، این خلاصه‌ها مختصر هستند زیرا از عناوینی که مشتریان در بررسی‌های محصول خود ارائه می‌دهند، استخراج شده‌اند. بیایید با جمع‌آوری یک دیتاسِت دوزبانه مناسب برای این کار شروع کنیم.

آماده‌سازی یک پیکره چندزبانه[[preparing-a-multilingual-corpus]]

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

from datasets import load_dataset

spanish_dataset = load_dataset("amazon_reviews_multi", "es")
english_dataset = load_dataset("amazon_reviews_multi", "en")
english_dataset
DatasetDict({
    train: Dataset({
        features: ['review_id', 'product_id', 'reviewer_id', 'stars', 'review_body', 'review_title', 'language', 'product_category'],
        num_rows: 200000
    })
    validation: Dataset({
        features: ['review_id', 'product_id', 'reviewer_id', 'stars', 'review_body', 'review_title', 'language', 'product_category'],
        num_rows: 5000
    })
    test: Dataset({
        features: ['review_id', 'product_id', 'reviewer_id', 'stars', 'review_body', 'review_title', 'language', 'product_category'],
        num_rows: 5000
    })
})

همانطور که می‌بینید، برای هر زبان، ۲۰۰۰۰۰ نقد برای تقسیم‌بندی train و ۵۰۰۰ نقد برای هر یک از تقسیم‌بندی‌های validation و test وجود دارد. اطلاعات نقد و بررسی که ما به آنها علاقه‌مندیم در ستون‌های review_body و review_title قرار دارد. بیایید با ایجاد یک تابع ساده که با تکنیک‌هایی که در فصل ۵ یاد گرفتیم، یک نمونه تصادفی از مجموعه آموزشی می‌گیرد، نگاهی به چند مثال بیندازیم:

def show_samples(dataset, num_samples=3, seed=42):
    sample = dataset["train"].shuffle(seed=seed).select(range(num_samples))
    for example in sample:
        print(f"\n'>> Title: {example['review_title']}'")
        print(f"'>> Review: {example['review_body']}'")

show_samples(english_dataset)
'>> Title: Worked in front position, not rear'
'>> Review: 3 stars because these are not rear brakes as stated in the item description. At least the mount adapter only worked on the front fork of the bike that I got it for.'

'>> Title: meh'
'>> Review: Does it’s job and it’s gorgeous but mine is falling apart, I had to basically put it together again with hot glue'

'>> Title: Can\'t beat these for the money'
'>> Review: Bought this for handling miscellaneous aircraft parts and hanger "stuff" that I needed to organize; it really fit the bill. The unit arrived quickly, was well packaged and arrived intact (always a good sign). There are five wall mounts-- three on the top and two on the bottom. I wanted to mount it on the wall, so all I had to do was to remove the top two layers of plastic drawers, as well as the bottom corner drawers, place it when I wanted and mark it; I then used some of the new plastic screw in wall anchors (the 50 pound variety) and it easily mounted to the wall. Some have remarked that they wanted dividers for the drawers, and that they made those. Good idea. My application was that I needed something that I can see the contents at about eye level, so I wanted the fuller-sized drawers. I also like that these are the new plastic that doesn\'t get brittle and split like my older plastic drawers did. I like the all-plastic construction. It\'s heavy duty enough to hold metal parts, but being made of plastic it\'s not as heavy as a metal frame, so you can easily mount it to the wall and still load it up with heavy stuff, or light stuff. No problem there. For the money, you can\'t beat it. Best one of these I\'ve bought to date-- and I\'ve been using some version of these for over forty years.'

نکته ✏️ امتحانش کنید! برای بررسی سایر نقدهای موجود در مجموعه، مقدار تصادفی را در دستور Dataset.shuffle() تغییر دهید. اگر اسپانیایی زبان هستید، به برخی از نقدهای موجود در spanish_dataset نگاهی بیندازید تا ببینید آیا عناوین آنها نیز خلاصه‌های معقولی به نظر می‌رسند یا خیر.

این نمونه، تنوع نقدهایی را که معمولاً به‌صورت آنلاین پیدا می‌کنید، از مثبت تا منفی (و هر چیزی بین این دو!) نشان می‌دهد. اگرچه مثال با عنوان «معمولی» خیلی آموزنده نیست، اما عناوین دیگر خلاصه‌های مناسبی از خود نقدها به نظر می‌رسند. آموزش یک مدل خلاصه‌سازی روی تمام ۴۰۰۰۰۰ نقد روی یک پردازنده گرافیکی واحد، زمان بسیار زیادی می‌برد، بنابراین در عوض، ما بر تولید خلاصه برای یک نقد واحد تمرکز خواهیم کرد. دامنه محصولات. برای اینکه بفهمیم از بین چه دامنه‌هایی می‌توانیم انتخاب کنیم، بیایید english_dataset را به pandas.DataFrame تبدیل کنیم و تعداد نظرات را برای هر دسته محصول محاسبه کنیم:

english_dataset.set_format("pandas")
english_df = english_dataset["train"][:]
# Show counts for top 20 products
english_df["product_category"].value_counts()[:20]
home                      17679
apparel                   15951
wireless                  15717
other                     13418
beauty                    12091
drugstore                 11730
kitchen                   10382
toy                        8745
sports                     8277
automotive                 7506
lawn_and_garden            7327
home_improvement           7136
pet_products               7082
digital_ebook_purchase     6749
pc                         6401
electronics                6186
office_product             5521
shoes                      5197
grocery                    4730
book                       3756
Name: product_category, dtype: int64

محبوب‌ترین محصولات در دیتاسِت انگلیسی مربوط به لوازم خانه، پوشاک و تجهیزات بی‌سیم هستند. برای ماندن در فضای آمازون، روی خلاصه‌سازی مرور کتاب‌ها تمرکز می‌کنیم؛ بالاخره شرکت با همین کار آغاز شد! دو دسته‌ی مناسب، book و digital_ebook_purchase، را می‌بینیم؛ پس دیتاسِت‌های هر دو زبان را فقط برای همین محصولات فیلتر می‌کنیم. همان‌طور که در فصل ۵ دیدیم، متد Dataset.filter() امکان برش کارآمد دیتاسِت را می‌دهد و می‌توانیم تابع ساده‌ای برای این کار تعریف کنیم:

def filter_books(example):
    return (
        example["product_category"] == "book"
        or example["product_category"] == "digital_ebook_purchase"
    )

حالا وقتی این تابع را روی english_dataset و spanish_dataset اعمال کنیم، نتیجه فقط شامل ردیف‌هایی خواهد بود که شامل دسته‌های کتاب هستند. قبل از اعمال فیلتر، بیایید قالب english_dataset را از "pandas" به "arrow" تغییر دهیم:

english_dataset.reset_format()

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

spanish_books = spanish_dataset.filter(filter_books)
english_books = english_dataset.filter(filter_books)
show_samples(english_books)
'>> Title: I\'m dissapointed.'
'>> Review: I guess I had higher expectations for this book from the reviews. I really thought I\'d at least like it. The plot idea was great. I loved Ash but, it just didnt go anywhere. Most of the book was about their radio show and talking to callers. I wanted the author to dig deeper so we could really get to know the characters. All we know about Grace is that she is attractive looking, Latino and is kind of a brat. I\'m dissapointed.'

'>> Title: Good art, good price, poor design'
'>> Review: I had gotten the DC Vintage calendar the past two years, but it was on backorder forever this year and I saw they had shrunk the dimensions for no good reason. This one has good art choices but the design has the fold going through the picture, so it\'s less aesthetically pleasing, especially if you want to keep a picture to hang. For the price, a good calendar'

'>> Title: Helpful'
'>> Review: Nearly all the tips useful and. I consider myself an intermediate to advanced user of OneNote. I would highly recommend.'

خب، می‌بینیم که نقدها صرفاً مربوط به کتاب‌ها نیستند و ممکن است به چیزهایی مانند تقویم‌ها و برنامه‌های الکترونیکی مانند OneNote اشاره داشته باشند. با این وجود، به نظر می‌رسد این دامنه برای آموزش یک مدل خلاصه‌سازی مناسب باشد. قبل از اینکه به مدل‌های مختلف مناسب برای این کار نگاه کنیم، یک مرحله آماده‌سازی داده‌ها داریم: ترکیب نقدهای انگلیسی و اسپانیایی به عنوان یک شیء واحد DatasetDict. 🤗 دیتاسِت‌ها یک تابع مفید concatenate_datasets() ارائه می‌دهد که (همانطور که از نامش پیداست) دو شیء Dataset را روی هم قرار می‌دهد. بنابراین، برای ایجاد دیتاسِت دوزبانه خود، روی هر تقسیم‌بندی حلقه می‌زنیم، دیتاسِت‌های مربوط به آن تقسیم‌بندی را به هم متصل می‌کنیم و نتیجه را تغییر می‌دهیم تا مطمئن شویم مدل ما به یک زبان واحد بیش‌برازش (overfit) نمی‌شود:

from datasets import concatenate_datasets, DatasetDict

books_dataset = DatasetDict()

for split in english_books.keys():
    books_dataset[split] = concatenate_datasets(
        [english_books[split], spanish_books[split]]
    )
    books_dataset[split] = books_dataset[split].shuffle(seed=42)

# Peek at a few examples
show_samples(books_dataset)
'>> Title: Easy to follow!!!!'
'>> Review: I loved The dash diet weight loss Solution. Never hungry. I would recommend this diet. Also the menus are well rounded. Try it. Has lots of the information need thanks.'

'>> Title: PARCIALMENTE DAÑADO'
'>> Review: Me llegó el día que tocaba, junto a otros libros que pedí, pero la caja llegó en mal estado lo cual dañó las esquinas de los libros porque venían sin protección (forro).'

'>> Title: no lo he podido descargar'
'>> Review: igual que el anterior'

این قطعاً شبیه ترکیبی از نقدهای انگلیسی و اسپانیایی به نظر می‌رسد! حالا که یک مجموعه آموزشی داریم، یک نکته نهایی که باید بررسی کنیم، توزیع کلمات در نقدها و عناوین آنهاست. این امر به ویژه برای وظایف خلاصه‌سازی مهم است، جایی که خلاصه‌های مرجع کوتاه در داده‌ها می‌توانند مدل را به گونه‌ای منحرف کنند که فقط یک یا دو کلمه را در خلاصه‌های تولید شده نمایش دهد. نمودارهای زیر توزیع کلمات را نشان می‌دهند و می‌توانیم آن را ببینیم. عناوین به شدت به سمت ۱-۲ کلمه متمایل شده‌اند:

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

books_dataset = books_dataset.filter(lambda x: len(x["review_title"].split()) > 2)

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

مدل‌های خلاصه‌سازی متن[[models-for-text-summarization]]

اگر در مورد آن فکر کنید، خلاصه‌سازی متن نوعی کار مشابه ترجمه ماشینی است: ما مجموعه‌ای از متن مانند یک نقد و بررسی داریم که می‌خواهیم آن را به نسخه‌ای کوتاه‌تر که ویژگی‌های برجسته ورودی را در بر می‌گیرد، "ترجمه" کنیم. بر این اساس، اکثر مدل‌های ترنسفورمر برای خلاصه‌سازی، معماری رمزگذار-رمزگشا را که برای اولین بار در فصل 1 با آن مواجه شدیم، اتخاذ می‌کنند، اگرچه استثنائاتی مانند ... نیز وجود دارد. خانواده مدل‌های GPT که می‌توانند برای خلاصه‌سازی در تنظیمات چند مرحله‌ای نیز استفاده شوند. جدول زیر برخی از مدل‌های از پیش تعلیم‌دیده محبوب را که می‌توانند برای خلاصه‌سازی کوک کردن شوند، فهرست می‌کند.

مدل ترنسفورمر توضیحات چندزبانه؟
GPT-2 اگرچه به عنوان یک مدل زبانی خود-رگرسیون آموزش دیده است، می‌توانید با افزودن "TL;DR" به انتهای متن ورودی، GPT-2 را وادار به تولید خلاصه کنید. ❌
PEGASUS از یک هدف پیش‌آموزشی برای پیش‌بینی جمله‌های ماسک‌شده در متن‌های چندجمله‌ای استفاده می‌کند. این هدف پیش‌آموزشی به خلاصه‌سازی نزدیک‌تر از مدل‌سازی زبانی معمولی است و در معیارهای رایج امتیاز بالایی می‌گیرد. ❌
T5 یک معماری ترنسفورمر جهانی که تمام وظایف را در یک چارچوب متن به متن فرموله می‌کند؛ به عنوان مثال، قالب ورودی برای مدل جهت خلاصه کردن یک سند summarize: ARTICLE است. ❌
mT5 یک نسخه چندزبانه از T5، که از قبل روی دیتاسِت‌های چندزبانه Common Crawl (mC4) آموزش دیده و ۱۰۱ زبان را پوشش می‌دهد. ✅
BART یک معماری ترنسفورمر جدید با پشته رمزگذار و رمزگشا که برای بازسازی ورودی خراب آموزش دیده است و طرح‌های پیش‌تعلیم BERT و GPT-2 را ترکیب می‌کند. ❌
mBART-50 یک نسخه چند زبانه از BART، از پیش آموزش دیده بر روی 50 زبان. ✅

همانطور که از این جدول مشاهده می‌کنید، اکثر مدل‌های ترنسفورمر برای خلاصه‌سازی (و در واقع اکثر وظایف NLP) تک‌زبانه هستند. اگر وظیفه شما به زبانی با «منابع بالا» مانند انگلیسی یا آلمانی باشد، این عالی است، اما برای هزاران زبان دیگر که در سراسر جهان استفاده می‌شوند، این‌طور نیست. خوشبختانه، دسته‌ای از مدل‌های ترنسفورمر چندزبانه، مانند mT5 و mBART، وجود دارند که به کمک می‌آیند. این مدل‌ها از قبل آموزش دیده‌اند با استفاده از مدل‌سازی زبان، اما با یک تغییر: به جای آموزش روی مجموعه‌ای از یک زبان، آنها به طور مشترک روی متون بیش از ۵۰ زبان به طور همزمان آموزش می‌بینند!

ما بر روی mT5 تمرکز خواهیم کرد، یک معماری جالب مبتنی بر T5 که در یک چارچوب متن به متن از پیش تعلیم داده شده است. در T5، هر وظیفه NLP بر اساس یک پیشوند اعلان مانند summarize: فرموله می‌شود که مدل را برای تطبیق متن تولید شده با اعلان شرطی می‌کند. همانطور که در شکل زیر نشان داده شده است، این امر T5 را بسیار متنوع می‌کند، زیرا می‌توانید بسیاری از وظایف را با یک مدل واحد حل کنید!

mT5 از پیشوندها استفاده نمی‌کند، اما بسیاری از تطبیق‌پذیری T5 را به اشتراک می‌گذارد و از مزیت چندزبانه بودن نیز برخوردار است. اکنون که یک مدل انتخاب کرده‌ایم، بیایید نگاهی به آماده‌سازی داده‌های خود برای آموزش بیندازیم.

✏️ امتحانش کنید! پس از اتمام این بخش، با کوک کردن mT5 با همان تکنیک‌ها، ببینید mBART در مقایسه با mT5 چقدر خوب عمل می‌کند. برای امتیاز بیشتر، می‌توانید T5 را فقط روی نقدهای انگلیسی تنظیم کنید. از آنجایی که T5 یک پیش‌وند خاص دارد، باید در مراحل پیش‌پردازش زیر، summarize: را به مثال‌های ورودی اضافه کنید.

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

کار بعدی توکِن‌سازی و کدگذاری مرورها و عنوان‌های آن‌هاست. طبق معمول، ابتدا توکِن‌ساز مربوط به نقطه‌ی بررسی مدل از پیش تعلیم‌دیده را بارگذاری می‌کنیم. از mt5-small استفاده می‌کنیم تا بتوانیم مدل را در زمانی معقول کوک کنیم:

from transformers import AutoTokenizer

model_checkpoint = "google/mt5-small"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

نکته 💡 در مراحل اولیه پروژه‌های NLP خود، یک روش خوب این است که یک کلاس از مدل‌های "کوچک" را روی یک نمونه کوچک از داده‌ها آموزش دهید. این به شما امکان می‌دهد تا سریع‌تر اشکال‌زدایی کنید و به سمت یک گردش کار سرتاسری تکرار کنید. هنگامی که از نتایج مطمئن شدید، همیشه می‌توانید مدل را با تغییر ساده نقطه بررسی مدل، مقیاس‌بندی کنید!

بیایید توکن‌ساز mT5 را روی یک مثال کوچک آزمایش کنیم:

inputs = tokenizer("I loved reading the Hunger Games!")
inputs
{'input_ids': [336, 259, 28387, 11807, 287, 62893, 295, 12507, 1], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}

در اینجا می‌توانیم input_ids و attention_mask آشنا را که در اولین آزمایش‌های کوک کردن خود در فصل 3 با آنها مواجه شدیم، ببینیم. بیایید این شناسه‌های ورودی را با تابع convert_ids_to_tokens() توکن‌ساز رمزگشایی کنیم تا ببینیم با چه نوع توکن‌سازی سروکار داریم:

tokenizer.convert_ids_to_tokens(inputs.input_ids)
['▁I', '▁', 'loved', '▁reading', '▁the', '▁Hung', 'er', '▁Games', '</s>']

کاراکتر یونیکد ویژه ▁ و توکن پایان توالی </s> نشان می‌دهند که ما با توکن‌ساز SentencePiece سروکار داریم که مبتنی بر الگوریتم قطعه‌بندی Unigram است که در فصل 6 مورد بحث قرار گرفته است. Unigram به ویژه برای پیکره‌های چندزبانه مفید است زیرا به SentencePiece اجازه می‌دهد تا نسبت به لهجه‌ها، علائم نگارشی و این واقعیت که بسیاری از زبان‌ها، مانند ژاپنی، کاراکترهای فاصله ندارند، بی‌تفاوت باشد.

برای توکنیزه کردن دیتاسِت‌هایمان، باید با یک نکتهٔ ظریف مرتبط با خلاصه‌سازی سر و کار داشته باشیم: از آنجا که برچسب‌های ما نیز متن هستند، ممکن است از حداکثر اندازهٔ متن مدل فراتر روند. این بدان معناست که باید هم بر روی نظرات و هم بر روی عناوین آن‌ها کوتاه‌سازی اعمال کنیم تا مطمئن شویم ورودی‌های بیش از حد طولانی به مدل خود ارسال نمی‌کنیم. توکنایزرها در ترنسفورمرهای 🤗 یک آرگومان text_target ارائه می‌دهند که به شما امکان می‌دهد برچسب‌ها را هم‌زمان با ورودی‌ها توکنیزه کنید. در اینجا مثالی از نحوهٔ پردازش ورودی‌ها و اهداف برای mT5 آورده شده است:

max_input_length = 512
max_target_length = 30

def preprocess_function(examples):
    model_inputs = tokenizer(
        examples["review_body"],
        max_length=max_input_length,
        truncation=True,
    )
    labels = tokenizer(
        examples["review_title"], max_length=max_target_length, truncation=True
    )
    model_inputs["labels"] = labels["input_ids"]
    return model_inputs

بیایید این کد را بررسی کنیم تا بفهمیم چه اتفاقی می‌افتد. اولین کاری که انجام داده‌ایم، تعریف مقادیری برای max_input_length و max_target_length است که حداکثر طول نقدها و عناوین ما را تعیین می‌کنند. از آنجایی که متن نقد معمولاً بسیار بزرگتر از عنوان است، این مقادیر را بر این اساس مقیاس‌بندی کرده‌ایم.

با preprocess_function()، توکِن‌سازی کل پیکره با تابع کاربردی Dataset.map() که در این دوره بسیار استفاده کرده‌ایم ساده است:

tokenized_datasets = books_dataset.map(preprocess_function, batched=True)

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

نکته 💡 شاید متوجه شده باشید که ما در تابع Dataset.map() بالا از batched=True استفاده کردیم. این تابع مثال‌ها را در دسته‌های ۱۰۰۰تایی (به‌صورت پیش‌فرض) کدگذاری می‌کند و به شما امکان می‌دهد از قابلیت‌های چندنخی توکنایزرهای سریع در ترنسفورمرهای 🤗 استفاده کنید. در صورت امکان، سعی کنید از batched=True استفاده کنید تا از پیش‌پردازش خود نهایت استفاده را ببرید!

معیارهای خلاصه‌سازی متن[[metrics-for-text-summarization]]

در مقایسه با اکثر وظایف دیگری که در این دوره پوشش داده‌ایم، اندازه‌گیری عملکرد وظایف تولید متن مانند خلاصه‌سازی یا ترجمه به این سادگی نیست. برای مثال، با توجه به نقدی مانند «من عاشق خواندن بازی‌های گرسنگی بودم»، چندین خلاصه معتبر وجود دارد، مانند «من عاشق بازی‌های گرسنگی بودم» یا «بازی‌های گرسنگی یک اثر عالی برای خواندن است». واضح است که اعمال نوعی تطابق دقیق بین خلاصه تولید شده و این برچسب راه حل خوبی نیست -- حتی انسان‌ها هم تحت چنین معیاری عملکرد ضعیفی خواهند داشت، زیرا همه ما سبک نوشتاری خودمان را داریم.

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

generated_summary = "I absolutely loved reading the Hunger Games"
reference_summary = "I loved reading the Hunger Games"

یک راه برای مقایسه آنها می‌تواند شمارش تعداد کلمات همپوشانی باشد که در این مورد ۶ خواهد بود. با این حال، این کمی خام است، بنابراین در عوض ROUGE مبتنی بر محاسبه نمرات precision و recall برای همپوشانی است.

نکته 🙋 اگر این اولین باری است که در مورد دقت و فراخوانی می‌شنوید، نگران نباشید -- ما با هم چند مثال واضح را بررسی خواهیم کرد تا همه چیز روشن شود. این معیارها معمولاً در وظایف طبقه‌بندی با هم مواجه می‌شوند، بنابراین اگر می‌خواهید بفهمید که دقت و فراخوانی در آن زمینه چگونه تعریف می‌شوند، توصیه می‌کنیم راهنماهای scikit-learn را بررسی کنید.

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

Recall=Number of overlapping wordsTotal number of words in reference summary \mathrm{Recall} = \frac{\mathrm{Number\,of\,overlapping\, words}}{\mathrm{Total\, number\, of\, words\, in\, reference\, summary}}

برای مثال ساده‌ی بالا، این فرمول میزان یادآوری کاملی برابر با ۶/۶ = ۱ ارائه می‌دهد؛ یعنی تمام کلمات موجود در خلاصه‌ی مرجع توسط مدل تولید شده‌اند. این ممکن است عالی به نظر برسد، اما تصور کنید اگر خلاصه‌ی تولید شده‌ی ما این بود: «من واقعاً واقعاً عاشق خواندن بازی‌های گرسنگی در تمام طول شب بودم». این نیز میزان یادآوری کاملی داشت، اما مسلماً خلاصه‌ی بدتری است زیرا طولانی است. برای مقابله با این سناریوها، ما همچنین محاسبه می‌کنیم دقت، که در زمینه ROUGE میزان مرتبط بودن خلاصه تولید شده را اندازه‌گیری می‌کند:

Precision=Number of overlapping wordsTotal number of words in generated summary \mathrm{Precision} = \frac{\mathrm{Number\,of\,overlapping\, words}}{\mathrm{Total\, number\, of\, words\, in\, generated\, summary}}

اعمال این مورد بر خلاصه‌ی طولانی ما، دقتی برابر با ۶/۱۰ = ۰.۶ را ارائه می‌دهد که به طور قابل توجهی بدتر از دقت ۶/۷ = ۰.۸۶ است که توسط خلاصه‌ی کوتاه‌تر ما به دست آمده است. در عمل، معمولاً هم دقت و هم فراخوانی محاسبه می‌شوند و سپس امتیاز F1 (میانگین هارمونیک دقت و فراخوانی) گزارش می‌شود. ما می‌توانیم این کار را به راحتی در دیتاسِت‌های 🤗 با نصب اولیه‌ی بسته‌ی rouge_score انجام دهیم:

!pip install rouge_score

و سپس بارگذاری متریک ROUGE به شرح زیر:

import evaluate

rouge_score = evaluate.load("rouge")

سپس می‌توانیم از تابع rouge_score.compute() برای محاسبه‌ی همزمان تمام معیارها استفاده کنیم:

scores = rouge_score.compute(
    predictions=[generated_summary], references=[reference_summary]
)
scores
{'rouge1': AggregateScore(low=Score(precision=0.86, recall=1.0, fmeasure=0.92), mid=Score(precision=0.86, recall=1.0, fmeasure=0.92), high=Score(precision=0.86, recall=1.0, fmeasure=0.92)),
 'rouge2': AggregateScore(low=Score(precision=0.67, recall=0.8, fmeasure=0.73), mid=Score(precision=0.67, recall=0.8, fmeasure=0.73), high=Score(precision=0.67, recall=0.8, fmeasure=0.73)),
 'rougeL': AggregateScore(low=Score(precision=0.86, recall=1.0, fmeasure=0.92), mid=Score(precision=0.86, recall=1.0, fmeasure=0.92), high=Score(precision=0.86, recall=1.0, fmeasure=0.92)),
 'rougeLsum': AggregateScore(low=Score(precision=0.86, recall=1.0, fmeasure=0.92), mid=Score(precision=0.86, recall=1.0, fmeasure=0.92), high=Score(precision=0.86, recall=1.0, fmeasure=0.92))}

وای، اطلاعات زیادی در این خروجی وجود دارد -- معنی همه اینها چیست؟ اول، 🤗 Datasets در واقع فواصل اطمینان را برای دقت، فراخوانی و امتیاز F1 محاسبه می‌کند؛ اینها ویژگی‌های low، mid و high هستند که می‌توانید اینجا ببینید. علاوه بر این، 🤗 Datasets انواع مختلفی از امتیازات ROUGE را محاسبه می‌کند که بر اساس انواع مختلف جزئیات متن هنگام مقایسه خلاصه‌های تولید شده و مرجع هستند. نوع rouge1 همپوشانی یونیگرام‌ها است -- این فقط یک روش فانتزی برای بیان همپوشانی کلمات است و دقیقاً همان معیاری است که در بالا در مورد آن صحبت کردیم. برای تأیید این موضوع، بیایید مقدار mid را از امتیازات خود استخراج کنیم:

scores["rouge1"].mid
Score(precision=0.86, recall=1.0, fmeasure=0.92)

عالی، اعداد دقت و فراخوانی با هم مطابقت دارند! حالا در مورد سایر نمرات ROUGE چطور؟ rouge2 همپوشانی بین دو رشته (همپوشانی جفت کلمات) را اندازه‌گیری می‌کند، در حالی که rougeL و rougeLsum طولانی‌ترین توالی‌های منطبق از کلمات را با جستجوی طولانی‌ترین زیررشته‌های مشترک در خلاصه‌های تولید شده و مرجع اندازه‌گیری می‌کنند. "جمع" در rougeLsum به این واقعیت اشاره دارد که این معیار بر روی کل خلاصه محاسبه می‌شود، در حالی که rougeL به عنوان میانگین روی تک تک جملات محاسبه می‌شود.

✏️ امتحانش کنید! مثال خودتان را از یک خلاصه تولید شده و مرجع ایجاد کنید و ببینید آیا نمرات ROUGE حاصل با محاسبه دستی بر اساس فرمول‌های دقت و فراخوانی مطابقت دارد یا خیر. برای امتیاز بیشتر، متن را به دو قسمت تقسیم کنید و دقت و فراخوانی را برای معیار rouge2 مقایسه کنید.

ما از این نمرات ROUGE برای ردیابی عملکرد مدل خود استفاده خواهیم کرد، اما قبل از انجام این کار، بیایید کاری را انجام دهیم که هر متخصص خوب NLP باید انجام دهد: ایجاد یک خط پایه قوی و در عین حال ساده!

ایجاد یک خط مبنای قوی[[creating-a-strong-baseline]]

یک خط پایه‌ی رایج برای خلاصه‌سازی متن، گرفتن سه جمله‌ی نخست مقاله است که معمولاً خط پایه‌ی lead-3 نامیده می‌شود. می‌توانیم با نقطه پایان جمله‌ها را پیدا کنیم، اما این روش برای سرواژه‌هایی مانند «U.S.» یا «U.N.» شکست می‌خورد؛ بنابراین از کتابخانه‌ی nltk استفاده می‌کنیم که الگوریتم بهتری برای این موارد دارد. بسته را با pip نصب کنید:

!pip install nltk

و سپس قواعد نشانه‌گذاری را دانلود می‌کنیم:

import nltk

nltk.download("punkt")

در مرحله بعد، توکن‌ساز جمله را از nltk وارد می‌کنیم و یک تابع ساده برای استخراج سه جمله اول در یک بررسی ایجاد می‌کنیم. رسم در خلاصه‌سازی متن این است که هر خلاصه را با یک خط جدید جدا کنیم، بنابراین بیایید این را نیز لحاظ کنیم و آن را روی یک مثال آموزشی آزمایش کنیم:

from nltk.tokenize import sent_tokenize

def three_sentence_summary(text):
    return "\n".join(sent_tokenize(text)[:3])

print(three_sentence_summary(books_dataset["train"][1]["review_body"]))
'I grew up reading Koontz, and years ago, I stopped,convinced i had "outgrown" him.'
'Still,when a friend was looking for something suspenseful too read, I suggested Koontz.'
'She found Strangers.'

به نظر می‌رسد که این روش جواب می‌دهد، بنابراین بیایید تابعی پیاده‌سازی کنیم که این «خلاصه‌ها» را از یک دیتاسِت استخراج کرده و امتیازات ROUGE را برای خط مبنا محاسبه کند:

def evaluate_baseline(dataset, metric):
    summaries = [three_sentence_summary(text) for text in dataset["review_body"]]
    return metric.compute(predictions=summaries, references=dataset["review_title"])

سپس با این تابع امتیازهای ROUGE را روی مجموعه‌ی اعتبارسنجی محاسبه و با Pandas کمی مرتب می‌کنیم:

import pandas as pd

score = evaluate_baseline(books_dataset["validation"], rouge_score)
rouge_names = ["rouge1", "rouge2", "rougeL", "rougeLsum"]
rouge_dict = dict((rn, round(score[rn].mid.fmeasure * 100, 2)) for rn in rouge_names)
rouge_dict
{'rouge1': 16.74, 'rouge2': 8.83, 'rougeL': 15.6, 'rougeLsum': 15.96}

می‌توانیم ببینیم که امتیاز rouge2 به طور قابل توجهی کمتر از بقیه است؛ این احتمالاً نشان دهنده این واقعیت است که عناوین نقد و بررسی معمولاً مختصر هستند و بنابراین خط پایه لید ۳ بیش از حد طولانی است. حالا که یک خط پایه خوب برای کار داریم، بیایید توجه خود را به کوک کردن mT5 معطوف کنیم!

{#if fw === 'pt'}

کوک کردن mT5 با رابط برنامه‌نویسی کاربردی Trainer[[fine-tuning-mt5-with-the-trainer-api]]

کوک کردن مدل برای خلاصه‌سازی بسیار شبیه وظایف دیگر این فصل است. ابتدا مدل از پیش تعلیم‌دیده را از نقطه‌ی بررسی mt5-small بارگذاری می‌کنیم. چون خلاصه‌سازی وظیفه‌ای دنباله‌به‌دنباله است، می‌توانیم مدل را با کلاس AutoModelForSeq2SeqLM بارگذاری کنیم؛ این کلاس وزن‌ها را خودکار دانلود و در کش ذخیره می‌کند:

from transformers import AutoModelForSeq2SeqLM

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

{:else}

کوک دقیق mT5 با Keras[[fine-tuning-mt5-with-keras]]

کوک کردن یک مدل برای خلاصه‌سازی بسیار شبیه به سایر کارهایی است که در این فصل پوشش داده‌ایم. اولین کاری که باید انجام دهیم بارگذاری مدل از پیش تعلیم‌دیده از نقطه بررسی mt5-small است. از آنجایی که خلاصه‌سازی یک کار توالی به توالی است، می‌توانیم مدل را با کلاس TFAutoModelForSeq2SeqLM بارگذاری کنیم که به طور خودکار وزن‌ها را دانلود و ذخیره می‌کند:

from transformers import TFAutoModelForSeq2SeqLM

model = TFAutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

{/if}

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

کار بعدی که باید انجام دهیم این است که به هاگینگ‌فِیس هاب وارد شویم. اگر این کد را در یک نوت‌بوک اجرا می‌کنید، می‌توانید این کار را با تابع کاربردی زیر انجام دهید:

from huggingface_hub import notebook_login

notebook_login()

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

huggingface-cli login

{#if fw === 'pt'}

برای محاسبه‌ی امتیازهای ROUGE هنگام تعلیم باید خلاصه تولید کنیم. خوشبختانه 🤗 Transformers کلاس‌های اختصاصی Seq2SeqTrainingArguments و Seq2SeqTrainer را دارد که این کار را خودکار انجام می‌دهند! ابتدا ابرپارامترها و آرگومان‌های آزمایش را تعریف می‌کنیم:

from transformers import Seq2SeqTrainingArguments

batch_size = 8
num_train_epochs = 8
# Show the training loss with every epoch
logging_steps = len(tokenized_datasets["train"]) // batch_size
model_name = model_checkpoint.split("/")[-1]

args = Seq2SeqTrainingArguments(
    output_dir=f"{model_name}-finetuned-amazon-en-es",
    evaluation_strategy="epoch",
    learning_rate=5.6e-5,
    per_device_train_batch_size=batch_size,
    per_device_eval_batch_size=batch_size,
    weight_decay=0.01,
    save_total_limit=3,
    num_train_epochs=num_train_epochs,
    predict_with_generate=True,
    logging_steps=logging_steps,
    push_to_hub=True,
)

در اینجا، آرگومان predict_with_generate طوری تنظیم شده است که نشان دهد ما باید در طول ارزیابی خلاصه‌هایی تولید کنیم تا بتوانیم نمرات ROUGE را برای هر دوره محاسبه کنیم. همانطور که در فصل 1 بحث شد، رمزگشا با پیش‌بینی توکن‌ها به صورت یک به یک، استنتاج را انجام می‌دهد و این توسط روش generate() مدل پیاده‌سازی می‌شود. تنظیم predict_with_generate=True به Seq2SeqTrainer می‌گوید که از آن روش برای ارزیابی استفاده کند. همچنین ابرپارامترهای پیش‌فرضی مانند نرخ یادگیری، تعداد دوره‌ها و کاهش وزن را تنظیم کرده‌ایم و گزینه‌ی save_total_limit را طوری تنظیم کرده‌ایم که حداکثر ۳ نقطه‌ی بررسی را در طول تعلیم ذخیره کند؛ زیرا حتی نسخه‌ی «کوچک» mT5 حدود یک گیگابایت از فضای دیسک را مصرف می‌کند و با محدود کردن تعداد نسخه‌های ذخیره‌شده، کمی فضا آزاد می‌کنیم.

آرگومان push_to_hub=True به ما این امکان را می‌دهد که مدل را پس از آموزش به هاب ارسال کنیم؛ مخزن را در زیر پروفایل کاربری خود، در مکانی که توسط output_dir تعریف شده است، خواهید یافت. توجه داشته باشید که می‌توانید نام مخزنی را که می‌خواهید به آن ارسال کنید، با آرگومان hub_model_id مشخص کنید (به طور خاص، برای ارسال به یک سازمان باید از این آرگومان استفاده کنید). به عنوان مثال، وقتی مدل را به سازمان huggingface-course ارسال کردیم، ما hub_model_id="huggingface-course/mt5-finetuned-amazon-en-es" به Seq2SeqTrainingArguments اضافه شد.

کار بعدی که باید انجام دهیم این است که یک تابع compute_metrics() به مربی ارائه دهیم تا بتوانیم مدل خود را در طول آموزش ارزیابی کنیم. به طور خلاصه، این کار کمی پیچیده‌تر از فراخوانی ساده rouge_score.compute() روی پیش‌بینی‌های مدل است، زیرا قبل از محاسبه امتیازات ROUGE، باید خروجی‌ها و برچسب‌ها را به متن رمزگشایی کنیم. تابع زیر دقیقاً همین کار را انجام می‌دهد و همچنین از تابع sent_tokenize() از nltk برای جدا کردن جمله‌های خلاصه با خط‌های جدید استفاده می‌کند:

import numpy as np

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    # Decode generated summaries into text
    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)
    # Decode reference summaries into text
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
    # ROUGE expects a newline after each sentence
    decoded_preds = ["\n".join(sent_tokenize(pred.strip())) for pred in decoded_preds]
    decoded_labels = ["\n".join(sent_tokenize(label.strip())) for label in decoded_labels]
    # Compute ROUGE scores
    result = rouge_score.compute(
        predictions=decoded_preds, references=decoded_labels, use_stemmer=True
    )
    # Extract the median scores
    result = {key: value.mid.fmeasure * 100 for key, value in result.items()}
    return {k: round(v, 4) for k, v in result.items()}

{/if}

در مرحله بعد، باید یک تطبیق‌دهنده داده برای وظیفه توالی به توالی خود تعریف کنیم. از آنجایی که mT5 یک مدل تبدیل‌کننده رمزگذار-رمزگشا است، یک نکته ظریف در آماده‌سازی دسته‌های ما این است که در طول رمزگشایی باید برچسب‌ها را یکی یکی به سمت راست جابجا کنیم. این کار برای اطمینان از این لازم است که رمزگشا فقط برچسب‌های حقیقت پایه قبلی را می‌بیند و نه برچسب‌های فعلی یا آینده را، که به خاطر سپردن آن برای مدل آسان خواهد بود. این شبیه نحوه‌ی اعمال توجهِ خودیِ ماسک‌شده بر ورودی‌ها در مسئله‌ای مانند مدل‌سازی زبان علّی است.

خوشبختانه، 🤗 ترنسفورمرز یک کامپایلر DataCollatorForSeq2Seq ارائه می‌دهد که به صورت پویا ورودی‌ها و برچسب‌ها را برای ما لایه‌گذاری می‌کند. برای نمونه‌سازی این کامپایلر، کافی است tokenizer و 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}

بیایید ببینیم این جمع‌کننده وقتی به یک دسته کوچک از مثال‌ها داده می‌شود چه چیزی تولید می‌کند. ابتدا، باید ستون‌های دارای رشته را حذف کنیم زیرا جمع‌کننده نمی‌داند چگونه این عناصر را لایه‌گذاری کند:

tokenized_datasets = tokenized_datasets.remove_columns(
    books_dataset["train"].column_names
)

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

features = [tokenized_datasets["train"][i] for i in range(2)]
data_collator(features)
{'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
         1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]), 'input_ids': tensor([[  1494,    259,   8622,    390,    259,    262,   2316,   3435,    955,
            772,    281,    772,   1617,    263,    305,  14701,    260,   1385,
           3031,    259,  24146,    332,   1037,    259,  43906,    305,    336,
            260,      1,      0,      0,      0,      0,      0,      0],
        [   259,  27531,  13483,    259,   7505,    260, 112240,  15192,    305,
          53198,    276,    259,  74060,    263,    260,    459,  25640,    776,
           2119,    336,    259,   2220,    259,  18896,    288,   4906,    288,
           1037,   3931,    260,   7083, 101476,   1143,    260,      1]]), 'labels': tensor([[ 7483,   259,  2364, 15695,     1,  -100],
        [  259, 27531, 13483,   259,  7505,     1]]), 'decoder_input_ids': tensor([[    0,  7483,   259,  2364, 15695,     1],
        [    0,   259, 27531, 13483,   259,  7505]])}

نکته‌ی اصلی این است که نمونه‌ی اول از دوم طولانی‌تر است؛ بنابراین input_ids و attention_mask نمونه‌ی دوم در سمت راست با توکِن [PAD] (با شناسه‌ی 0) هم‌طول شده‌اند. همچنین labels با -100ها پر شده‌اند تا توکِن‌های padding در تابع هزینه نادیده گرفته شوند. در پایان decoder_input_ids تازه‌ای می‌بینیم که با قرار دادن توکِن [PAD] در ابتدای ورودی، برچسب‌ها را به راست منتقل کرده است.

{#if fw === 'pt'}

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

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.train()

در طول آموزش، باید شاهد کاهش تلفات آموزش و افزایش امتیازات ROUGE با هر دوره باشید. پس از اتمام آموزش، می‌توانید امتیازات نهایی ROUGE را با اجرای Trainer.evaluate() مشاهده کنید:

trainer.evaluate()
{'eval_loss': 3.028524398803711,
 'eval_rouge1': 16.9728,
 'eval_rouge2': 8.2969,
 'eval_rougeL': 16.8366,
 'eval_rougeLsum': 16.851,
 'eval_gen_len': 10.1597,
 'eval_runtime': 6.1054,
 'eval_samples_per_second': 38.982,
 'eval_steps_per_second': 4.914}

از روی امتیازات می‌توانیم ببینیم که مدل ما به راحتی از خط پایه‌ی سوم خود بهتر عمل کرده است -- عالی! آخرین کاری که باید انجام دهیم این است که وزن‌های مدل را به صورت زیر به هاب منتقل کنیم:

trainer.push_to_hub(commit_message="Training complete", tags="summarization")
'https://huggingface.co/huggingface-course/mt5-finetuned-amazon-en-es/commit/aa0536b829b28e73e1e4b94b8a5aacec420d40e0'

این کار، فایل‌های Checkpoint و پیکربندی را قبل از آپلود همه فایل‌ها در هاب، در output_dir ذخیره می‌کند. با مشخص کردن آرگومان tags، همچنین اطمینان حاصل می‌کنیم که ویجت روی هاب، به جای خط تولید متن پیش‌فرض مرتبط با معماری mT5، ​​برای خط تولید خلاصه‌سازی خواهد بود (برای اطلاعات بیشتر در مورد تگ‌های مدل، به 🤗 مستندات هاب مراجعه کنید). خروجی trainer.push_to_hub() یک URL به ... است. هش کامیت گیت، بنابراین می‌توانید به راحتی تغییراتی که در مخزن مدل ایجاد شده است را مشاهده کنید!

برای پایان این بخش، ببینیم چگونه می‌توانیم mT5 را با قابلیت‌های سطح پایین 🤗 Accelerate نیز کوک کنیم.

{:else}

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

tf_train_dataset = model.prepare_tf_dataset(
    tokenized_datasets["train"],
    collate_fn=data_collator,
    shuffle=True,
    batch_size=8,
)
tf_eval_dataset = model.prepare_tf_dataset(
    tokenized_datasets["validation"],
    collate_fn=data_collator,
    shuffle=False,
    batch_size=8,
)

حالا ابرپارامترهای تعلیم را تعریف و مدل را کامپایل می‌کنیم:

from transformers import create_optimizer
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_train_epochs = 8
num_train_steps = len(tf_train_dataset) * num_train_epochs
model_name = model_checkpoint.split("/")[-1]

optimizer, schedule = create_optimizer(
    init_lr=5.6e-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 برای ذخیره مدل در هاب پس از هر دوره استفاده می‌کنیم که به ما امکان می‌دهد بعداً از آن برای استنتاج استفاده کنیم:

from transformers.keras_callbacks import PushToHubCallback

callback = PushToHubCallback(
    output_dir=f"{model_name}-finetuned-amazon-en-es", tokenizer=tokenizer
)

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

در طول تعلیم چند مقدار هزینه گرفتیم، اما می‌خواهیم معیارهای ROUGE قبلی را ببینیم. برای این کار باید خروجی‌های مدل را تولید و به رشته تبدیل کنیم و فهرست‌هایی از برچسب‌ها و پیش‌بینی‌ها برای مقایسه بسازیم؛ اگر در این بخش خطای import گرفتید، شاید به !pip install tqdm نیاز داشته باشید. برای افزایش چشمگیر عملکرد، کد تولید را با XLA، کامپایلر جبر خطی شتاب‌یافته‌ی TensorFlow، کامپایل می‌کنیم. XLA نمودار محاسباتی مدل را بهینه می‌کند و سرعت و مصرف حافظه را بهتر می‌کند. طبق توضیح وبلاگ، چون XLA با شکل‌های ورودی مشابه بهتر کار می‌کند، ورودی‌ها را به مضرب‌های ۱۲۸ هم‌طول می‌کنیم و جمع‌کننده‌ی padding تازه‌ای می‌سازیم و دکوراتور @tf.function(jit_compile=True) را روی تابع تولید می‌گذاریم.

from tqdm import tqdm
import numpy as np

generation_data_collator = DataCollatorForSeq2Seq(
    tokenizer, model=model, return_tensors="tf", pad_to_multiple_of=320
)

tf_generate_dataset = model.prepare_tf_dataset(
    tokenized_datasets["validation"],
    collate_fn=generation_data_collator,
    shuffle=False,
    batch_size=8,
    drop_remainder=True,
)

@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=32,
    )

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 = ["\n".join(sent_tokenize(pred.strip())) for pred in decoded_preds]
    decoded_labels = ["\n".join(sent_tokenize(label.strip())) for label in decoded_labels]
    all_preds.extend(decoded_preds)
    all_labels.extend(decoded_labels)

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

result = rouge_score.compute(
    predictions=decoded_preds, references=decoded_labels, use_stemmer=True
)
result = {key: value.mid.fmeasure * 100 for key, value in result.items()}
{k: round(v, 4) for k, v in result.items()}
{'rouge1': 31.4815, 'rouge2': 25.4386, 'rougeL': 31.4815, 'rougeLsum': 31.4815}

{/if}

{#if fw === 'pt'}

کوک کردن mT5 با 🤗 شتاب‌دهی[[fine-tuning-mt5-with-accelerate]]

کوک کردن مدل با 🤗 Accelerate بسیار شبیه به مثال طبقه‌بندی متن است که در فصل ۳ با آن مواجه شدیم. تفاوت‌های اصلی، نیاز به تولید صریح خلاصه‌های ما در طول آموزش و تعریف نحوه محاسبه امتیازات ROUGE خواهد بود (به یاد داشته باشید که Seq2SeqTrainer تولید را برای ما انجام داد). بیایید نگاهی به نحوه پیاده‌سازی این دو الزام در 🤗 Accelerate بیندازیم!

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

اولین کاری که باید انجام دهیم این است که برای هر یک از تقسیم‌بندی‌هایمان یک DataLoader ایجاد کنیم. از آنجایی که بارگذارهای داده PyTorch انتظار دسته‌هایی از تانسورها را دارند، باید قالب را در دیتاسِت‌های خود روی "torch" تنظیم کنیم:

tokenized_datasets.set_format("torch")

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

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

سپس می‌توانیم از گردآورنده‌ی داده‌ها نمونه‌سازی کنیم و از آن برای تعریف بارگذارهای داده‌ی خود استفاده کنیم:

from torch.utils.data import DataLoader

batch_size = 8
train_dataloader = DataLoader(
    tokenized_datasets["train"],
    shuffle=True,
    collate_fn=data_collator,
    batch_size=batch_size,
)
eval_dataloader = DataLoader(
    tokenized_datasets["validation"], collate_fn=data_collator, batch_size=batch_size
)

کار بعدی که باید انجام دهیم، تعریف بهینه‌ساز مورد نظرمان است. همانند مثال‌های دیگرمان، از AdamW استفاده خواهیم کرد که برای اکثر مسائل به خوبی کار می‌کند:

from torch.optim import AdamW

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

در نهایت، مدل، بهینه‌ساز و بارگذارهای داده خود را به متد accelerator.prepare() می‌دهیم:

from accelerate import Accelerator

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

نکته 🚨 اگر روی یک TPU آموزش می‌بینید، باید تمام کد بالا را به یک تابع آموزش اختصاصی منتقل کنید. برای جزئیات بیشتر به فصل ۳ مراجعه کنید.

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

  • جدول نرخ یادگیری را تعریف کنید.
  • تابعی را برای پس‌پردازش خلاصه‌ها جهت ارزیابی پیاده‌سازی کنید.
  • مخزنی در هاب ایجاد کنید تا بتوانیم مدل خود را در آن بارگذاری کنیم.

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

from transformers import get_scheduler

num_train_epochs = 10
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,
)

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

def postprocess_text(preds, labels):
    preds = [pred.strip() for pred in preds]
    labels = [label.strip() for label in labels]

    # ROUGE expects a newline after each sentence
    preds = ["\n".join(nltk.sent_tokenize(pred)) for pred in preds]
    labels = ["\n".join(nltk.sent_tokenize(label)) for label in labels]

    return preds, labels

اگر به یاد داشته باشید که چگونه تابع compute_metrics() مربوط به Seq2SeqTrainer را تعریف کردیم، این باید برای شما آشنا به نظر برسد.

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

from huggingface_hub import get_full_repo_name

model_name = "test-bert-finetuned-squad-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name
'lewtun/mt5-finetuned-amazon-en-es-accelerate'

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

from huggingface_hub import Repository

output_dir = "results-mt5-finetuned-squad-accelerate"
repo = Repository(output_dir, clone_from=repo_name)

این به ما امکان می‌دهد تا با فراخوانی متد repo.push_to_hub() در طول آموزش، مصنوعات را به هاب برگردانیم! حال بیایید تحلیل خود را با نوشتن حلقه آموزش به پایان برسانیم.

حلقه آموزشی[[training-loop]]

حلقه آموزشی برای خلاصه‌سازی کاملاً شبیه به سایر مثال‌های Accelerate 🤗 است که با آنها مواجه شده‌ایم و تقریباً به چهار مرحله اصلی تقسیم می‌شود:

۱. مدل را با تکرار روی تمام مثال‌های موجود در train_dataloader برای هر دوره، آموزش دهید. ۲. در پایان هر دوره خلاصه‌های مدل را تولید کنید؛ ابتدا توکن‌ها و سپس آن‌ها (و خلاصه‌های مرجع) را به متن تبدیل کنید. ۳. امتیازهای ROUGE را با همان روش‌هایی که پیش‌تر دیدیم محاسبه کنید. ۴. چک‌پوینت‌ها را ذخیره کنید و همه چیز را به هاب ارسال کنید. در اینجا ما به آرگومان blocking=False از شیء Repository تکیه می‌کنیم تا بتوانیم چک‌پوینت‌ها را در هر دوره به صورت ناهمگام ارسال کنیم. این به ما امکان می‌دهد بدون نیاز به انتظار برای آپلود نسبتاً کند مربوط به یک مدل با اندازه GB، به آموزش ادامه دهیم!

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

from tqdm.auto import tqdm
import torch
import numpy as np

progress_bar = tqdm(range(num_training_steps))

for epoch in range(num_train_epochs):
    # Training
    model.train()
    for step, batch in enumerate(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 step, batch in enumerate(eval_dataloader):
        with torch.no_grad():
            generated_tokens = accelerator.unwrap_model(model).generate(
                batch["input_ids"],
                attention_mask=batch["attention_mask"],
            )

            generated_tokens = accelerator.pad_across_processes(
                generated_tokens, dim=1, pad_index=tokenizer.pad_token_id
            )
            labels = batch["labels"]

            # If we did not pad to max length, we need to pad the labels too
            labels = accelerator.pad_across_processes(
                batch["labels"], dim=1, pad_index=tokenizer.pad_token_id
            )

            generated_tokens = accelerator.gather(generated_tokens).cpu().numpy()
            labels = accelerator.gather(labels).cpu().numpy()

            # Replace -100 in the labels as we can't decode them
            labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
            if isinstance(generated_tokens, tuple):
                generated_tokens = generated_tokens[0]
            decoded_preds = tokenizer.batch_decode(
                generated_tokens, skip_special_tokens=True
            )
            decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)

            decoded_preds, decoded_labels = postprocess_text(
                decoded_preds, decoded_labels
            )

            rouge_score.add_batch(predictions=decoded_preds, references=decoded_labels)

    # Compute metrics
    result = rouge_score.compute()
    # Extract the median ROUGE scores
    result = {key: value.mid.fmeasure * 100 for key, value in result.items()}
    result = {k: round(v, 4) for k, v in result.items()}
    print(f"Epoch {epoch}:", result)

    # 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: {'rouge1': 5.6351, 'rouge2': 1.1625, 'rougeL': 5.4866, 'rougeLsum': 5.5005}
Epoch 1: {'rouge1': 9.8646, 'rouge2': 3.4106, 'rougeL': 9.9439, 'rougeLsum': 9.9306}
Epoch 2: {'rouge1': 11.0872, 'rouge2': 3.3273, 'rougeL': 11.0508, 'rougeLsum': 10.9468}
Epoch 3: {'rouge1': 11.8587, 'rouge2': 4.8167, 'rougeL': 11.7986, 'rougeLsum': 11.7518}
Epoch 4: {'rouge1': 12.9842, 'rouge2': 5.5887, 'rougeL': 12.7546, 'rougeLsum': 12.7029}
Epoch 5: {'rouge1': 13.4628, 'rouge2': 6.4598, 'rougeL': 13.312, 'rougeLsum': 13.2913}
Epoch 6: {'rouge1': 12.9131, 'rouge2': 5.8914, 'rougeL': 12.6896, 'rougeLsum': 12.5701}
Epoch 7: {'rouge1': 13.3079, 'rouge2': 6.2994, 'rougeL': 13.1536, 'rougeLsum': 13.1194}
Epoch 8: {'rouge1': 13.96, 'rouge2': 6.5998, 'rougeL': 13.9123, 'rougeLsum': 13.7744}
Epoch 9: {'rouge1': 14.1192, 'rouge2': 7.0059, 'rougeL': 14.1172, 'rougeLsum': 13.9509}

و تمام! وقتی این را اجرا کنید، مدل و نتایجی خواهید داشت که بسیار شبیه به نتایجی است که با Trainer به دست آوردیم.

{/if}

با استفاده از مدل تنظیم‌شده‌ی دقیق شما[[using-your-fine-tuned-model]]

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

from transformers import pipeline

hub_model_id = "huggingface-course/mt5-small-finetuned-amazon-en-es"
summarizer = pipeline("summarization", model=hub_model_id)

می‌توانیم چند مثال از مجموعه تست (که مدل ندیده است) را به خط تولید خود وارد کنیم تا کیفیت خلاصه‌ها را ارزیابی کنیم. ابتدا بیایید یک تابع ساده برای نمایش نقد، عنوان و خلاصه تولید شده با هم پیاده‌سازی کنیم:

def print_summary(idx):
    review = books_dataset["test"][idx]["review_body"]
    title = books_dataset["test"][idx]["review_title"]
    summary = summarizer(books_dataset["test"][idx]["review_body"])[0]["summary_text"]
    print(f"'>>> Review: {review}'")
    print(f"\n'>>> Title: {title}'")
    print(f"\n'>>> Summary: {summary}'")

بیایید نگاهی به یکی از مثال‌های انگلیسی که به دست می‌آوریم بیندازیم:

print_summary(100)
'>>> Review: Nothing special at all about this product... the book is too small and stiff and hard to write in. The huge sticker on the back doesn’t come off and looks super tacky. I would not purchase this again. I could have just bought a journal from the dollar store and it would be basically the same thing. It’s also really expensive for what it is.'

'>>> Title: Not impressed at all... buy something else'

'>>> Summary: Nothing special at all about this product'

بد نیست! می‌بینیم مدل ما توانسته با افزودن کلمات تازه به بخش‌هایی از مرور، خلاصه‌سازی انتزاعی انجام دهد. شاید جالب‌ترین ویژگی مدل دوزبانه بودن آن باشد؛ بنابراین می‌توانیم مرورهای اسپانیایی را هم خلاصه کنیم:

print_summary(0)
'>>> Review: Es una trilogia que se hace muy facil de leer. Me ha gustado, no me esperaba el final para nada'

'>>> Title: Buena literatura para adolescentes'

'>>> Summary: Muy facil de leer'

این خلاصه در انگلیسی به «Very easy to read» ترجمه می‌شود و می‌بینیم که در این مورد مستقیماً از مرور استخراج شده است. بااین‌حال، این مثال انعطاف‌پذیری مدل mT5 و تجربه‌ی کار با پیکره‌ای چندزبانه را نشان می‌دهد!

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

Xet Storage Details

Size:
76.5 kB
·
Xet hash:
1b80a909e78132aa821f59be7a2bd458378ab4f1d8edb5084648d441002a35e8

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