Buckets:

|
download
raw
71.2 kB

پاسخ به سوالات[[question-answering]]

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

{/if}

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

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

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

نکته 💡 مدل‌های فقط‌انکودر مانند BERT معمولاً برای استخراج پاسخ پرسش‌های واقع‌نما، مانند «چه کسی معماری ترنسفورمر را اختراع کرد؟»، عالی هستند، اما در برابر پرسش‌های باز مانند «چرا آسمان آبی است؟» عملکرد ضعیفی دارند. در این موارد دشوارتر، معمولاً از مدل‌های انکودر-دیکودر مانند T5 و BART برای ترکیب اطلاعات به روشی شبیه خلاصه‌سازی متن استفاده می‌شود. اگر به این نوع پاسخ‌گویی مولد به پرسش علاقه دارید، نمونه‌ی ما را که بر پایه‌ی دیتاسِت ELI5 است ببینید.

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

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

دیتاسِت SQuAD[[the-squad-dataset]]

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

from datasets import load_dataset

raw_datasets = load_dataset("squad")

اکنون می‌توانیم این شیء را بررسی کنیم تا درباره‌ی دیتاسِت SQuAD بیشتر بدانیم:

raw_datasets
DatasetDict({
    train: Dataset({
        features: ['id', 'title', 'context', 'question', 'answers'],
        num_rows: 87599
    })
    validation: Dataset({
        features: ['id', 'title', 'context', 'question', 'answers'],
        num_rows: 10570
    })
})

به نظر می‌رسد که ما هر آنچه را که برای فیلدهای context، question و answers نیاز داریم، داریم، بنابراین بیایید آنها را برای اولین عنصر مجموعه آموزشی خود چاپ کنیم:

print("Context: ", raw_datasets["train"][0]["context"])
print("Question: ", raw_datasets["train"][0]["question"])
print("Answer: ", raw_datasets["train"][0]["answers"])
Context: 'Architecturally, the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend "Venite Ad Me Omnes". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858. At the end of the main drive (and in a direct line that connects through 3 statues and the Gold Dome), is a simple, modern stone statue of Mary.'
Question: 'To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France?'
Answer: {'text': ['Saint Bernadette Soubirous'], 'answer_start': [515]}

استفاده از فیلدهای context و question بسیار ساده است. فیلد answers کمی پیچیده‌تر است زیرا شامل یک دیکشنری با دو فیلد است که هر دو لیست هستند. این فرمتی است که معیار squad در طول ارزیابی انتظار دارد. اگر از داده‌های خودتان استفاده می‌کنید، لزوماً نیازی به نگرانی در مورد قرار دادن پاسخ‌ها در همان فرمت ندارید. فیلد text نسبتاً واضح است و فیلد answer_start شامل موارد زیر است: شاخص کاراکتر شروع هر پاسخ در متن.

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

raw_datasets["train"].filter(lambda x: len(x["answers"]["text"]) != 1)
Dataset({
    features: ['id', 'title', 'context', 'question', 'answers'],
    num_rows: 0
})

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

print(raw_datasets["validation"][0]["answers"])
print(raw_datasets["validation"][2]["answers"])
{'text': ['Denver Broncos', 'Denver Broncos', 'Denver Broncos'], 'answer_start': [177, 177, 177]}
{'text': ['Santa Clara, California', "Levi's Stadium", "Levi's Stadium in the San Francisco Bay Area at Santa Clara, California."], 'answer_start': [403, 355, 355]}

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

print(raw_datasets["validation"][2]["context"])
print(raw_datasets["validation"][2]["question"])
'Super Bowl 50 was an American football game to determine the champion of the National Football League (NFL) for the 2015 season. The American Football Conference (AFC) champion Denver Broncos defeated the National Football Conference (NFC) champion Carolina Panthers 24–10 to earn their third Super Bowl title. The game was played on February 7, 2016, at Levi\'s Stadium in the San Francisco Bay Area at Santa Clara, California. As this was the 50th Super Bowl, the league emphasized the "golden anniversary" with various gold-themed initiatives, as well as temporarily suspending the tradition of naming each Super Bowl game with Roman numerals (under which the game would have been known as "Super Bowl L"), so that the logo could prominently feature the Arabic numerals 50.'
'Where did Super Bowl 50 take place?'

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

پردازش داده‌های تعلیم[[processing-the-training-data]]

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

اما جلوتر از خودمان حرکت نکنیم. ابتدا باید متن ورودی را با توکِن‌ساز به شناسه‌هایی تبدیل کنیم که مدل بتواند درک کند:

from transformers import AutoTokenizer

model_checkpoint = "bert-base-cased"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

همانطور که قبلاً ذکر شد، ما یک مدل BERT را به دقت تنظیم خواهیم کرد، اما شما می‌توانید از هر نوع مدل دیگری استفاده کنید، مادامی که یک توکن‌ساز سریع پیاده‌سازی شده باشد. می‌توانید تمام معماری‌هایی را که با یک نسخه سریع ارائه می‌شوند در این جدول بزرگ مشاهده کنید، و برای بررسی اینکه شیء tokenizer که استفاده می‌کنید واقعاً توسط توکن‌سازها پشتیبانی می‌شود، می‌توانید به ویژگی is_fast آن نگاه کنید:

tokenizer.is_fast
True

می‌توانیم سوال و متن را با هم به توکن‌ساز خود ارسال کنیم و توکن‌ساز به درستی توکن‌های ویژه را برای تشکیل جمله‌ای مانند این وارد می‌کند:

[CLS] question [SEP] context [SEP]

بیایید دوباره بررسی کنیم:

context = raw_datasets["train"][0]["context"]
question = raw_datasets["train"][0]["question"]

inputs = tokenizer(question, context)
tokenizer.decode(inputs["input_ids"])
'[CLS] To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France? [SEP] Architecturally, '
'the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin '
'Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms '
'upraised with the legend " Venite Ad Me Omnes ". Next to the Main Building is the Basilica of the Sacred '
'Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a '
'replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette '
'Soubirous in 1858. At the end of the main drive ( and in a direct line that connects through 3 statues '
'and the Gold Dome ), is a simple, modern stone statue of Mary. [SEP]'

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

در اینجا زمینه طولانی نیست، اما برخی نمونه‌های دیتاسِت زمینه‌های بسیار طولانی دارند که از طول بیشینه‌ی تعیین‌شده (اینجا ۳۸۴) بیشتر می‌شوند. همان‌طور که در فصل ۶ و هنگام بررسی سازوکار خط تولید question-answering دیدیم، با ساختن چند ویژگی تعلیم از یک نمونه‌ی دیتاسِت و استفاده از پنجره‌ی لغزان با زمینه‌های طولانی کنار می‌آییم.

برای اینکه ببینیم این روش با استفاده از مثال فعلی چگونه کار می‌کند، می‌توانیم طول را به ۱۰۰ محدود کنیم و از یک پنجره کشویی ۵۰ توکنی استفاده کنیم. به عنوان یادآوری، از موارد زیر استفاده می‌کنیم:

  • max_length برای تنظیم حداکثر طول (در اینجا ۱۰۰)
  • truncation="only_second" برای کوتاه کردن متن (که در جایگاه دوم قرار دارد) زمانی که سوال به همراه متن آن خیلی طولانی باشد.
  • stride برای تعیین تعداد توکِن‌های هم‌پوشان بین دو تکه‌ی متوالی (اینجا ۵۰)
  • return_overflowing_tokens=True برای اینکه به توکن‌ساز اطلاع دهیم که ما توکن‌های سرریز شده را می‌خواهیم.
inputs = tokenizer(
    question,
    context,
    max_length=100,
    truncation="only_second",
    stride=50,
    return_overflowing_tokens=True,
)

for ids in inputs["input_ids"]:
    print(tokenizer.decode(ids))
'[CLS] To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France? [SEP] Architecturally, the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend " Venite Ad Me Omnes ". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basi [SEP]'
'[CLS] To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France? [SEP] the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend " Venite Ad Me Omnes ". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a replica of the grotto at Lourdes, France where the Virgin [SEP]'
'[CLS] To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France? [SEP] Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858. At the end of the main drive ( and in a direct line that connects through 3 [SEP]'
'[CLS] To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France? [SEP]. It is a replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858. At the end of the main drive ( and in a direct line that connects through 3 statues and the Gold Dome ), is a simple, modern stone statue of Mary. [SEP]'

همانطور که می‌بینیم، مثال ما به چهار ورودی تقسیم شده است که هر کدام شامل سوال و بخشی از متن هستند. توجه داشته باشید که پاسخ سوال ("Bernadette Soubirous") فقط در ورودی‌های سوم و آخر ظاهر می‌شود، بنابراین با برخورد با متن‌های طولانی به این روش، چند مثال آموزشی ایجاد خواهیم کرد که پاسخ در متن گنجانده نشده است. برای این مثال‌ها، برچسب‌ها start_position = end_position = 0 خواهند بود (بنابراین پیش‌بینی می‌کنیم (نشانه [CLS]). ما همچنین آن برچسب‌ها را در مورد نامطلوبی که پاسخ کوتاه شده است، تنظیم خواهیم کرد تا فقط شروع (یا پایان) آن را داشته باشیم. برای مثال‌هایی که پاسخ کاملاً در متن است، برچسب‌ها شاخص نشانه ای خواهند بود که پاسخ از آنجا شروع می‌شود و شاخص نشانه ای خواهد بود که پاسخ در آنجا پایان می‌یابد.

دیتاسِت جایگاه نویسه‌ی آغاز پاسخ را در زمینه می‌دهد و با افزودن طول پاسخ می‌توانیم جایگاه پایان را پیدا کنیم. برای نگاشت آن‌ها به اندیس‌های توکِن باید از نگاشت‌های offset فصل ۶ استفاده کنیم. توکِن‌ساز با افزودن return_offsets_mapping=True این نگاشت‌ها را برمی‌گرداند:

inputs = tokenizer(
    question,
    context,
    max_length=100,
    truncation="only_second",
    stride=50,
    return_overflowing_tokens=True,
    return_offsets_mapping=True,
)
inputs.keys()
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'offset_mapping', 'overflow_to_sample_mapping'])

همان شناسه‌های ورودی، شناسه‌های نوع توکِن و ماسک توجه معمول را می‌گیریم، به‌علاوه‌ی نگاشت offset و کلید overflow_to_sample_mapping. این مقدار هنگام توکِن‌سازی چند متن هم‌زمان به کار می‌آید، چون یک نمونه می‌تواند چند ویژگی بسازد و هر ویژگی را به نمونه‌ی اصلی‌اش نگاشت می‌کند. چون اینجا فقط یک نمونه را توکِن‌سازی کرده‌ایم، فهرستی از 0ها می‌گیریم:

inputs["overflow_to_sample_mapping"]
[0, 0, 0, 0]

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

inputs = tokenizer(
    raw_datasets["train"][2:6]["question"],
    raw_datasets["train"][2:6]["context"],
    max_length=100,
    truncation="only_second",
    stride=50,
    return_overflowing_tokens=True,
    return_offsets_mapping=True,
)

print(f"The 4 examples gave {len(inputs['input_ids'])} features.")
print(f"Here is where each comes from: {inputs['overflow_to_sample_mapping']}.")
'The 4 examples gave 19 features.'
'Here is where each comes from: [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3].'

همانطور که می‌بینیم، سه مثال اول (در اندیس‌های ۲، ۳ و ۴ در مجموعه آموزش) هر کدام چهار ویژگی و مثال آخر (در اندیس ۵ در مجموعه آموزش) ۷ ویژگی ارائه دادند.

این اطلاعات برای نگاشت هر ویژگی به برچسب مربوط به آن مفید خواهد بود. همانطور که قبلاً ذکر شد، این برچسب‌ها عبارتند از:

  • اگر پاسخ در محدوده‌ی مربوط به متن نباشد، (0, 0)
  • اگر پاسخ در محدوده‌ی مربوط به متن باشد، (start_position, end_position) اندیس توکن (در شناسه‌های ورودی) در ابتدای پاسخ و end_position اندیس توکن (در شناسه‌های ورودی) در انتهای پاسخ خواهد بود.

برای تعیین اینکه کدام یک از این موارد صدق می‌کند و در صورت لزوم، موقعیت توکن‌ها چیست، ابتدا اندیس‌هایی را که زمینه را در شناسه‌های ورودی شروع و پایان می‌دهند، پیدا می‌کنیم. می‌توانیم از شناسه‌های نوع توکن برای انجام این کار استفاده کنیم، اما از آنجایی که این شناسه‌ها لزوماً برای همه مدل‌ها وجود ندارند (برای مثال، DistilBERT به آنها نیاز ندارد)، در عوض از متد sequence_ids() مربوط به BatchEncoding که توکن‌ساز ما برمی‌گرداند، استفاده خواهیم کرد.

وقتی اندیس‌های توکِن را داریم، offsetهای متناظر را بررسی می‌کنیم؛ این‌ها تاپل‌هایی از دو عدد صحیح‌اند که بازه‌ی نویسه‌ها را در زمینه‌ی اصلی نشان می‌دهند. به این ترتیب می‌فهمیم قطعه‌ی زمینه در این ویژگی پس از پاسخ آغاز می‌شود یا پیش از شروع پاسخ پایان می‌یابد؛ در این حالت برچسب (0, 0) است. در غیر این صورت، نخستین و آخرین توکِن پاسخ را پیدا می‌کنیم:

answers = raw_datasets["train"][2:6]["answers"]
start_positions = []
end_positions = []

for i, offset in enumerate(inputs["offset_mapping"]):
    sample_idx = inputs["overflow_to_sample_mapping"][i]
    answer = answers[sample_idx]
    start_char = answer["answer_start"][0]
    end_char = answer["answer_start"][0] + len(answer["text"][0])
    sequence_ids = inputs.sequence_ids(i)

    # Find the start and end of the context
    idx = 0
    while sequence_ids[idx] != 1:
        idx += 1
    context_start = idx
    while sequence_ids[idx] == 1:
        idx += 1
    context_end = idx - 1

    # If the answer is not fully inside the context, label is (0, 0)
    if offset[context_start][0] > start_char or offset[context_end][1] < end_char:
        start_positions.append(0)
        end_positions.append(0)
    else:
        # Otherwise it's the start and end token positions
        idx = context_start
        while idx <= context_end and offset[idx][0] <= start_char:
            idx += 1
        start_positions.append(idx - 1)

        idx = context_end
        while idx >= context_start and offset[idx][1] >= end_char:
            idx -= 1
        end_positions.append(idx + 1)

start_positions, end_positions
([83, 51, 19, 0, 0, 64, 27, 0, 34, 0, 0, 0, 67, 34, 0, 0, 0, 0, 0],
 [85, 53, 21, 0, 0, 70, 33, 0, 40, 0, 0, 0, 68, 35, 0, 0, 0, 0, 0])

بیایید نگاهی به چند نتیجه بیندازیم تا صحت رویکرد خود را تأیید کنیم. برای اولین ویژگی، (83, 85) را به عنوان برچسب پیدا می‌کنیم، بنابراین بیایید پاسخ نظری را با بازه رمزگشایی شده توکن‌ها از ۸۳ تا ۸۵ (شامل) مقایسه کنیم:

idx = 0
sample_idx = inputs["overflow_to_sample_mapping"][idx]
answer = answers[sample_idx]["text"][0]

start = start_positions[idx]
end = end_positions[idx]
labeled_answer = tokenizer.decode(inputs["input_ids"][idx][start : end + 1])

print(f"Theoretical answer: {answer}, labels give: {labeled_answer}")
'Theoretical answer: the Main Building, labels give: the Main Building'

خب، این تطابق دارد! حالا بیایید اندیس ۴ را بررسی کنیم، جایی که برچسب‌ها را روی (0, 0) تنظیم کرده‌ایم، که یعنی پاسخ در بخش زمینه آن ویژگی نیست:

idx = 4
sample_idx = inputs["overflow_to_sample_mapping"][idx]
answer = answers[sample_idx]["text"][0]

decoded_example = tokenizer.decode(inputs["input_ids"][idx])
print(f"Theoretical answer: {answer}, decoded example: {decoded_example}")
'Theoretical answer: a Marian place of prayer and reflection, decoded example: [CLS] What is the Grotto at Notre Dame? [SEP] Architecturally, the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend " Venite Ad Me Omnes ". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grot [SEP]'

در واقع، ما پاسخ را در متن نمی‌بینیم.

نکته ✏️ نوبت شماست! هنگام استفاده از معماری XLNet، هم‌ترازسازی در سمت چپ انجام می‌شود و پرسش و زمینه جابه‌جا می‌شوند. همه‌ی کدی را که دیدیم برای معماری XLNet تطبیق دهید (و padding=True را اضافه کنید). توجه داشته باشید که با اعمال هم‌ترازسازی، ممکن است توکِن [CLS] در جایگاه ۰ نباشد.

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

max_length = 384
stride = 128

def preprocess_training_examples(examples):
    questions = [q.strip() for q in examples["question"]]
    inputs = tokenizer(
        questions,
        examples["context"],
        max_length=max_length,
        truncation="only_second",
        stride=stride,
        return_overflowing_tokens=True,
        return_offsets_mapping=True,
        padding="max_length",
    )

    offset_mapping = inputs.pop("offset_mapping")
    sample_map = inputs.pop("overflow_to_sample_mapping")
    answers = examples["answers"]
    start_positions = []
    end_positions = []

    for i, offset in enumerate(offset_mapping):
        sample_idx = sample_map[i]
        answer = answers[sample_idx]
        start_char = answer["answer_start"][0]
        end_char = answer["answer_start"][0] + len(answer["text"][0])
        sequence_ids = inputs.sequence_ids(i)

        # Find the start and end of the context
        idx = 0
        while sequence_ids[idx] != 1:
            idx += 1
        context_start = idx
        while sequence_ids[idx] == 1:
            idx += 1
        context_end = idx - 1

        # If the answer is not fully inside the context, label is (0, 0)
        if offset[context_start][0] > start_char or offset[context_end][1] < end_char:
            start_positions.append(0)
            end_positions.append(0)
        else:
            # Otherwise it's the start and end token positions
            idx = context_start
            while idx <= context_end and offset[idx][0] <= start_char:
                idx += 1
            start_positions.append(idx - 1)

            idx = context_end
            while idx >= context_start and offset[idx][1] >= end_char:
                idx -= 1
            end_positions.append(idx + 1)

    inputs["start_positions"] = start_positions
    inputs["end_positions"] = end_positions
    return inputs

توجه داشته باشید که ما دو ثابت برای تعیین حداکثر طول مورد استفاده و همچنین طول پنجره کشویی تعریف کردیم و قبل از توکن‌سازی، کمی پاکسازی انجام دادیم: برخی از سوالات موجود در دیتاسِت SQuAD دارای فضاهای اضافی در ابتدا و انتها هستند که چیزی اضافه نمی‌کنند (و اگر از مدلی مانند RoBERTa استفاده کنید، هنگام توکن‌سازی فضا اشغال می‌کنند)، بنابراین آن فضاهای اضافی را حذف کردیم.

برای اعمال این تابع روی کل مجموعه‌ی تعلیم، از متد Dataset.map() با پرچم batched=True استفاده می‌کنیم. اینجا لازم است، چون طول دیتاسِت تغییر می‌کند و یک نمونه می‌تواند چند ویژگی تعلیم بسازد:

train_dataset = raw_datasets["train"].map(
    preprocess_training_examples,
    batched=True,
    remove_columns=raw_datasets["train"].column_names,
)
len(raw_datasets["train"]), len(train_dataset)
(87599, 88729)

همان‌طور که می‌بینیم، پیش‌پردازش حدود ۱۰۰۰ ویژگی اضافه کرده است. مجموعه‌ی تعلیم آماده است؛ حالا پیش‌پردازش مجموعه‌ی اعتبارسنجی را بررسی کنیم!

پردازش داده‌های اعتبارسنجی[[processing-the-validation-data]]

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

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

def preprocess_validation_examples(examples):
    questions = [q.strip() for q in examples["question"]]
    inputs = tokenizer(
        questions,
        examples["context"],
        max_length=max_length,
        truncation="only_second",
        stride=stride,
        return_overflowing_tokens=True,
        return_offsets_mapping=True,
        padding="max_length",
    )

    sample_map = inputs.pop("overflow_to_sample_mapping")
    example_ids = []

    for i in range(len(inputs["input_ids"])):
        sample_idx = sample_map[i]
        example_ids.append(examples["id"][sample_idx])

        sequence_ids = inputs.sequence_ids(i)
        offset = inputs["offset_mapping"][i]
        inputs["offset_mapping"][i] = [
            o if sequence_ids[k] == 1 else None for k, o in enumerate(offset)
        ]

    inputs["example_id"] = example_ids
    return inputs

مثل قبل می‌توانیم این تابع را روی کل دیتاسِت اعتبارسنجی اعمال کنیم:

validation_dataset = raw_datasets["validation"].map(
    preprocess_validation_examples,
    batched=True,
    remove_columns=raw_datasets["validation"].column_names,
)
len(raw_datasets["validation"]), len(validation_dataset)
(10570, 10822)

اینجا فقط چندصد نمونه اضافه شده است؛ پس به نظر می‌رسد زمینه‌های دیتاسِت اعتبارسنجی کمی کوتاه‌ترند.

حالا که همه داده‌ها را پیش‌پردازش کرده‌ایم، می‌توانیم به سراغ آموزش برویم.

{#if fw === 'pt'}

تنظیم دقیق مدل با API Trainer[[fine-tuning-the-model-with-the-trainer-api]]

کد آموزشی این مثال بسیار شبیه کد بخش‌های قبلی خواهد بود -- سخت‌ترین کار نوشتن تابع compute_metrics() است. از آنجا که همه‌ی نمونه‌ها را تا حداکثر طول تعیین‌شده هم‌طول کرده‌ایم، نیازی به تعریف جمع‌کننده‌ی داده نیست و محاسبه‌ی معیار تنها چیزی است که باید نگران آن باشیم. بخش دشوار، پس‌پردازش پیش‌بینی‌های مدل به بازه‌هایی از متن در نمونه‌های اصلی است؛ پس از انجام این کار، معیار موجود در کتابخانه‌ی 🤗 Datasets بیشتر کار را برای ما انجام می‌دهد.

{:else}

تنظیم دقیق مدل با Keras[[fine-tuning-the-model-with-keras]]

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

{/if}

پس‌پردازش[[post-processing]]

{#if fw === 'pt'}

{:else}

{/if}

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

  • ما لوجیت‌های شروع و پایان مربوط به توکن‌های خارج از متن را پنهان کردیم.
  • سپس لوجیت‌های شروع و پایان را با استفاده از softmax به احتمال تبدیل کردیم.
  • به هر جفت (start_token, end_token) با ضرب دو احتمال متناظر امتیاز دادیم.
  • جفتی را پیدا کردیم که بیشترین امتیاز را داشت و پاسخی معتبر تولید می‌کرد (برای مثال، start_token آن از end_token کوچک‌تر بود).

در اینجا این فرایند را کمی تغییر می‌دهیم، زیرا نیازی به محاسبه‌ی امتیازهای واقعی نداریم (فقط پاسخ پیش‌بینی‌شده مهم است). بنابراین می‌توانیم از مرحله‌ی softmax صرف‌نظر کنیم. برای سرعت بیشتر، همه‌ی جفت‌های ممکن (start_token, end_token) را امتیازدهی نمی‌کنیم، بلکه فقط جفت‌های متناظر با n_best لوجیتِ بزرگ‌تر (با n_best=20) را بررسی می‌کنیم. از آنجا که از softmax صرف‌نظر می‌کنیم، این امتیازها امتیازهای لوجیت خواهند بود و با جمع‌کردن لوجیت‌های شروع و پایان به دست می‌آیند (به‌جای ضرب، بر اساس قاعده‌ی log⁡(ab)=log⁡(a)+log⁡(b)\log(ab) = \log(a) + \log(b)).

برای نشان دادن همه‌ی این موارد به پیش‌بینی نیاز داریم. چون هنوز مدل را تعلیم نداده‌ایم، از مدل پیش‌فرض خط تولید QA استفاده می‌کنیم تا روی بخشی کوچک از مجموعه‌ی اعتبارسنجی پیش‌بینی بگیریم. همان تابع پردازش قبلی را به کار می‌بریم؛ چون به ثابت سراسری tokenizer وابسته است، موقتاً آن شیء را با توکِن‌ساز مدل مورد نظر جایگزین می‌کنیم:

small_eval_set = raw_datasets["validation"].select(range(100))
trained_checkpoint = "distilbert-base-cased-distilled-squad"

tokenizer = AutoTokenizer.from_pretrained(trained_checkpoint)
eval_set = small_eval_set.map(
    preprocess_validation_examples,
    batched=True,
    remove_columns=raw_datasets["validation"].column_names,
)

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

tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

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

{#if fw === 'pt'}

import torch
from transformers import AutoModelForQuestionAnswering

eval_set_for_model = eval_set.remove_columns(["example_id", "offset_mapping"])
eval_set_for_model.set_format("torch")

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
batch = {k: eval_set_for_model[k].to(device) for k in eval_set_for_model.column_names}
trained_model = AutoModelForQuestionAnswering.from_pretrained(trained_checkpoint).to(
    device
)

with torch.no_grad():
    outputs = trained_model(**batch)

از آنجایی که Trainer پیش‌بینی‌ها را به صورت آرایه‌های NumPy به ما می‌دهد، ما لوجیت‌های شروع و پایان را می‌گیریم و آنها را به آن قالب تبدیل می‌کنیم:

start_logits = outputs.start_logits.cpu().numpy()
end_logits = outputs.end_logits.cpu().numpy()

{:else}

import tensorflow as tf
from transformers import TFAutoModelForQuestionAnswering

eval_set_for_model = eval_set.remove_columns(["example_id", "offset_mapping"])
eval_set_for_model.set_format("numpy")

batch = {k: eval_set_for_model[k] for k in eval_set_for_model.column_names}
trained_model = TFAutoModelForQuestionAnswering.from_pretrained(trained_checkpoint)

outputs = trained_model(**batch)

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

start_logits = outputs.start_logits.numpy()
end_logits = outputs.end_logits.numpy()

{/if}

اکنون باید پاسخ پیش‌بینی‌شده‌ی هر نمونه در small_eval_set را پیدا کنیم. یک نمونه ممکن است در eval_set به چند ویژگی تقسیم شده باشد؛ پس ابتدا هر نمونه‌ی small_eval_set را به ویژگی‌های متناظر در eval_set نگاشت می‌کنیم:

import collections

example_to_features = collections.defaultdict(list)
for idx, feature in enumerate(eval_set):
    example_to_features[feature["example_id"]].append(idx)

با این اطلاعات می‌توانیم کار اصلی را انجام دهیم: برای هر نمونه و سپس هر ویژگی مرتبط، امتیازهای logit مربوط به n_best جایگاه آغاز و پایان را بررسی می‌کنیم و موقعیت‌های نامعتبر را کنار می‌گذاریم:

  • پاسخی که درون زمینه قرار نمی‌گیرد
  • پاسخی با طول منفی
  • پاسخی که بیش از حد طولانی است (امکان‌ها را به max_answer_length=30 محدود می‌کنیم)

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

import numpy as np

n_best = 20
max_answer_length = 30
predicted_answers = []

for example in small_eval_set:
    example_id = example["id"]
    context = example["context"]
    answers = []

    for feature_index in example_to_features[example_id]:
        start_logit = start_logits[feature_index]
        end_logit = end_logits[feature_index]
        offsets = eval_set["offset_mapping"][feature_index]

        start_indexes = np.argsort(start_logit)[-1 : -n_best - 1 : -1].tolist()
        end_indexes = np.argsort(end_logit)[-1 : -n_best - 1 : -1].tolist()
        for start_index in start_indexes:
            for end_index in end_indexes:
                # Skip answers that are not fully in the context
                if offsets[start_index] is None or offsets[end_index] is None:
                    continue
                # Skip answers with a length that is either < 0 or > max_answer_length.
                if (
                    end_index < start_index
                    or end_index - start_index + 1 > max_answer_length
                ):
                    continue

                answers.append(
                    {
                        "text": context[offsets[start_index][0] : offsets[end_index][1]],
                        "logit_score": start_logit[start_index] + end_logit[end_index],
                    }
                )

    best_answer = max(answers, key=lambda x: x["logit_score"])
    predicted_answers.append({"id": example_id, "prediction_text": best_answer["text"]})

قالب نهایی پاسخ‌های پیش‌بینی‌شده، همان قالبی است که توسط معیار مورد استفاده ما انتظار می‌رود. طبق معمول، می‌توانیم آن را با کمک کتابخانه 🤗 Evaluate بارگذاری کنیم:

import evaluate

metric = evaluate.load("squad")

این معیار پاسخ‌های پیش‌بینی‌شده را در قالب بالا می‌خواهد (فهرستی از دیکشنری‌ها با شناسه‌ی نمونه و متن پیش‌بینی‌شده) و پاسخ‌های نظری را در قالب زیر می‌گیرد (فهرستی از دیکشنری‌ها با شناسه‌ی نمونه و پاسخ‌های ممکن):

theoretical_answers = [
    {"id": ex["id"], "answers": ex["answers"]} for ex in small_eval_set
]

اکنون با نگاه کردن به نخستین عنصر هر دو فهرست می‌توانیم منطقی بودن نتایج را بررسی کنیم:

print(predicted_answers[0])
print(theoretical_answers[0])
{'id': '56be4db0acb8001400a502ec', 'prediction_text': 'Denver Broncos'}
{'id': '56be4db0acb8001400a502ec', 'answers': {'text': ['Denver Broncos', 'Denver Broncos', 'Denver Broncos'], 'answer_start': [177, 177, 177]}}

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

metric.compute(predictions=predicted_answers, references=theoretical_answers)
{'exact_match': 83.0, 'f1': 88.25}

باز هم، با توجه به اینکه طبق مقاله‌اش DistilBERT تنظیم‌شده روی SQuAD برای این نمرات در کل دیتاسِت‌ها به ترتیب ۷۹.۱ و ۸۶.۹ به دست می‌آورد، این نسبتاً خوب است.

{#if fw === 'pt'}

حالا همه‌ی کارهای انجام‌شده را در تابع compute_metrics() می‌گذاریم تا در Trainer استفاده شود. این تابع معمولاً فقط eval_preds را با لوجیت‌ها و برچسب‌ها می‌گیرد، اما اینجا باید offset را در دیتاسِت ویژگی‌ها و زمینه‌ی اصلی را در دیتاسِت نمونه‌ها پیدا کنیم؛ پس برای ارزیابی منظم تعلیم مناسب نیست. آن را فقط در پایان تعلیم برای بررسی نتایج به کار می‌بریم.

تابع compute_metrics() همان مراحل قبلی را گروه‌بندی می‌کند؛ ما فقط یک بررسی کوچک اضافه می‌کنیم تا در صورتی که هیچ پاسخ معتبری ارائه ندهیم (که در این صورت یک رشته خالی پیش‌بینی می‌کنیم) مطمئن شویم.

{:else}

اکنون compute_metrics() را برای استفاده پس از تعلیم مدل می‌نویسیم. باید چیزی بیشتر از لوجیت‌های خروجی به آن بدهیم، چون offset را در دیتاسِت ویژگی‌ها و زمینه‌ی اصلی را در دیتاسِت نمونه‌ها بررسی می‌کنیم:

{/if}

from tqdm.auto import tqdm

def compute_metrics(start_logits, end_logits, features, examples):
    example_to_features = collections.defaultdict(list)
    for idx, feature in enumerate(features):
        example_to_features[feature["example_id"]].append(idx)

    predicted_answers = []
    for example in tqdm(examples):
        example_id = example["id"]
        context = example["context"]
        answers = []

        # Loop through all features associated with that example
        for feature_index in example_to_features[example_id]:
            start_logit = start_logits[feature_index]
            end_logit = end_logits[feature_index]
            offsets = features[feature_index]["offset_mapping"]

            start_indexes = np.argsort(start_logit)[-1 : -n_best - 1 : -1].tolist()
            end_indexes = np.argsort(end_logit)[-1 : -n_best - 1 : -1].tolist()
            for start_index in start_indexes:
                for end_index in end_indexes:
                    # Skip answers that are not fully in the context
                    if offsets[start_index] is None or offsets[end_index] is None:
                        continue
                    # Skip answers with a length that is either < 0 or > max_answer_length
                    if (
                        end_index < start_index
                        or end_index - start_index + 1 > max_answer_length
                    ):
                        continue

                    answer = {
                        "text": context[offsets[start_index][0] : offsets[end_index][1]],
                        "logit_score": start_logit[start_index] + end_logit[end_index],
                    }
                    answers.append(answer)

        # Select the answer with the best score
        if len(answers) > 0:
            best_answer = max(answers, key=lambda x: x["logit_score"])
            predicted_answers.append(
                {"id": example_id, "prediction_text": best_answer["text"]}
            )
        else:
            predicted_answers.append({"id": example_id, "prediction_text": ""})

    theoretical_answers = [{"id": ex["id"], "answers": ex["answers"]} for ex in examples]
    return metric.compute(predictions=predicted_answers, references=theoretical_answers)

می‌توانیم بررسی کنیم که آیا پیش‌بینی‌های ما درست کار می‌کند یا خیر:

compute_metrics(start_logits, end_logits, eval_set, small_eval_set)
{'exact_match': 83.0, 'f1': 88.25}

خوب شده! حالا بیایید از این برای کوک کردن مدل خود استفاده کنیم.

کوک مدل[[fine-tuning-the-model]]

{#if fw === 'pt'}

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

model = AutoModelForQuestionAnswering.from_pretrained(model_checkpoint)

{:else}

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

model = TFAutoModelForQuestionAnswering.from_pretrained(model_checkpoint)

{/if}

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

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

from huggingface_hub import notebook_login

notebook_login()

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

huggingface-cli login

{#if fw === 'pt'}

پس از این کار می‌توانیم TrainingArguments را تعریف کنیم. چون امضای compute_metrics() اجازه‌ی حلقه‌ی ارزیابی معمول را نمی‌دهد، می‌توانستیم Trainer را خودمان زیرکلاس‌سازی کنیم (نمونه‌ای از این روش در اسکریپت پاسخ‌گویی به پرسش‌ها آمده است)، اما این کار برای این بخش طولانی است. در عوض اینجا فقط در پایان تعلیم ارزیابی می‌کنیم و پایین‌تر ارزیابی منظم را در یک حلقه‌ی تعلیم سفارشی نشان می‌دهیم.

اینجاست که محدودیت‌های API Trainer مشخص می‌شود و کتابخانه‌ی 🤗 Accelerate می‌درخشد: سفارشی کردن کلاس برای یک کاربرد خاص دشوار است، اما تغییر یک حلقه‌ی تعلیم کاملاً در دسترس آسان است.

بیایید نگاهی به TrainingArguments خودمان بیندازیم:

from transformers import TrainingArguments

args = TrainingArguments(
    "bert-finetuned-squad",
    evaluation_strategy="no",
    save_strategy="epoch",
    learning_rate=2e-5,
    num_train_epochs=3,
    weight_decay=0.01,
    fp16=True,
    push_to_hub=True,
)

بیشتر این موارد را قبلاً دیده‌اید: ابرپارامترهایی مانند نرخ یادگیری، تعداد دوره‌ها و کاهش وزن را تنظیم می‌کنیم، ذخیره‌ی مدل در پایان هر دوره، حذف ارزیابی و بارگذاری نتایج روی هاب مدل را مشخص می‌کنیم. همچنین با fp16=True تعلیم با دقت ترکیبی را فعال می‌کنیم تا روی GPU جدید سریع‌تر باشد.

{:else}

حالا دیتاسِت‌های TF را می‌سازیم. این بار می‌توانیم از جمع‌کننده‌ی داده‌ی پیش‌فرض ساده استفاده کنیم:

from transformers import DefaultDataCollator

data_collator = DefaultDataCollator(return_tensors="tf")

اکنون دیتاسِت‌ها را مثل همیشه می‌سازیم.

tf_train_dataset = model.prepare_tf_dataset(
    train_dataset,
    collate_fn=data_collator,
    shuffle=True,
    batch_size=16,
)
tf_eval_dataset = model.prepare_tf_dataset(
    validation_dataset,
    collate_fn=data_collator,
    shuffle=False,
    batch_size=16,
)

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

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_train_epochs = 3
num_train_steps = len(tf_train_dataset) * num_train_epochs
optimizer, schedule = create_optimizer(
    init_lr=2e-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")

در نهایت، ما آماده آموزش با model.fit() هستیم. ما از PushToHubCallback برای آپلود مدل به هاب پس از هر دوره استفاده می‌کنیم.

{/if}

به‌طور پیش‌فرض مخزن در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود؛ اینجا "sgugger/bert-finetuned-squad" خواهد بود. می‌توانیم با hub_model_id آن را تغییر دهیم؛ برای پوش به سازمان huggingface_course مقدار hub_model_id="huggingface_course/bert-finetuned-squad" را می‌دهیم.

{#if fw === 'pt'}

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

در پایان همه‌چیز را به کلاس Trainer می‌دهیم و تعلیم را آغاز می‌کنیم:

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    eval_dataset=validation_dataset,
    tokenizer=tokenizer,
)
trainer.train()

{:else}

from transformers.keras_callbacks import PushToHubCallback

callback = PushToHubCallback(output_dir="bert-finetuned-squad", tokenizer=tokenizer)

# We're going to do validation afterwards, so no validation mid-training
model.fit(tf_train_dataset, callbacks=[callback], epochs=num_train_epochs)

{/if}

توجه داشته باشید که در حین آموزش، هر بار که مدل ذخیره می‌شود (در اینجا، هر دوره) در پس‌زمینه در هاب آپلود می‌شود. به این ترتیب، در صورت لزوم می‌توانید آموزش خود را روی دستگاه دیگری از سر بگیرید. کل آموزش مدتی طول می‌کشد (کمی بیش از یک ساعت روی Titan RTX)، بنابراین می‌توانید در حین ادامه آموزش، یک قهوه بنوشید یا برخی از بخش‌های دوره را که برایتان چالش‌برانگیزتر بوده است، دوباره بخوانید. همچنین توجه داشته باشید که به‌محض پایان اولین دوره، بخشی از وزن‌ها را می‌بینید که در هاب بارگذاری شده‌اند و می‌توانید کار با مدل خود را در صفحه‌ی آن آغاز کنید.

{#if fw === 'pt'}

پس از پایان تعلیم، مدل را ارزیابی می‌کنیم. متد predict() در Trainer تاپی برمی‌گرداند که عناصر اول آن پیش‌بینی‌های مدل، یعنی جفت لوجیت‌های آغاز و پایان، هستند. این خروجی را به compute_metrics() می‌دهیم:

predictions, _, _ = trainer.predict(validation_dataset)
start_logits, end_logits = predictions
compute_metrics(start_logits, end_logits, validation_dataset, raw_datasets["validation"])

{:else}

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

predictions = model.predict(tf_eval_dataset)
compute_metrics(
    predictions["start_logits"],
    predictions["end_logits"],
    validation_dataset,
    raw_datasets["validation"],
)

{/if}

{'exact_match': 81.18259224219489, 'f1': 88.67381321905516}

عالی! به عنوان مقایسه، امتیازهای پایه گزارش شده در مقاله BERT برای این مدل ۸۰.۸ و ۸۸.۵ است، بنابراین ما درست همان جایی هستیم که باید باشیم.

{#if fw === 'pt'}

در پایان، از متد push_to_hub() استفاده می‌کنیم تا جدیدترین نسخه‌ی مدل را بارگذاری کنیم:

trainer.push_to_hub(commit_message="Training complete")

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

'https://huggingface.co/sgugger/bert-finetuned-squad/commit/9dcee1fbc25946a6ed4bb32efb1bd71d5fa90b68'

Trainer همچنین کارت مدلی با همه‌ی نتایج ارزیابی می‌سازد و بارگذاری می‌کند.

{/if}

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

نکته ✏️ نوبت شماست! معماری مدل دیگری را امتحان کنید تا ببینید آیا در این کار بهتر عمل می‌کند یا خیر!

{#if fw === 'pt'}

اگر می‌خواهید عمیق‌تر وارد حلقه‌ی تعلیم شوید، اکنون همان کار را با 🤗 Accelerate نشان می‌دهیم.

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

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

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

ابتدا DataLoaderها را از دیتاسِت‌ها می‌سازیم. قالب دیتاسِت‌ها را روی "torch" می‌گذاریم و ستون‌های بلااستفاده از مجموعه‌ی اعتبارسنجی را حذف می‌کنیم. سپس از default_data_collator ترنسفورمرها به‌عنوان collate_fn استفاده و مجموعه‌ی تعلیم را درهم می‌ریزیم، اما مجموعه‌ی اعتبارسنجی را نه:

from torch.utils.data import DataLoader
from transformers import default_data_collator

train_dataset.set_format("torch")
validation_set = validation_dataset.remove_columns(["example_id", "offset_mapping"])
validation_set.set_format("torch")

train_dataloader = DataLoader(
    train_dataset,
    shuffle=True,
    collate_fn=default_data_collator,
    batch_size=8,
)
eval_dataloader = DataLoader(
    validation_set, collate_fn=default_data_collator, batch_size=8
)

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

model = AutoModelForQuestionAnswering.from_pretrained(model_checkpoint)

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

from torch.optim import AdamW

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

وقتی همه‌ی اشیا آماده شدند، آن‌ها را به accelerator.prepare() می‌فرستیم. برای تعلیم روی TPU در نوت‌بوک Colab باید این کد را داخل تابع تعلیم ببرید و هیچ سلولی که Accelerator می‌سازد اجرا نکنید. با دادن fp16=True به Accelerator تعلیم با دقت ترکیبی را فعال می‌کنیم؛ در اجرای اسکریپتی نیز config 🤗 Accelerate را درست تنظیم کنید.

from accelerate import Accelerator

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

همان‌طور که از بخش‌های قبل می‌دانید، فقط پس از عبور train_dataloader از accelerator.prepare() می‌توانیم طول آن را برای محاسبه‌ی تعداد گام‌های تعلیم به کار ببریم. از همان زمان‌بندی خطی بخش‌های قبلی استفاده می‌کنیم:

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 را می‌توانید با انتخاب خود جایگزین کنید، فقط باید نام کاربری شما را داشته باشد:

from huggingface_hub import Repository, get_full_repo_name

model_name = "bert-finetuned-squad-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name
'sgugger/bert-finetuned-squad-accelerate'

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

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

اکنون با فراخوانی repo.push_to_hub() هر چیزی را که در output_dir ذخیره کنیم بارگذاری می‌کنیم و مدل‌های میانی را در پایان هر دوره می‌فرستیم.

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

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

  • خودِ فرآیند آموزش، که همان تکرار کلاسیک روی train_dataloader است، شامل عبور رو به جلو از مدل، سپس عبور رو به عقب و مرحله بهینه‌سازی می‌شود.
  • ارزیابی، که در آن تمام مقادیر مربوط به start_logits و end_logits را قبل از تبدیل آنها به آرایه‌های NumPy جمع‌آوری می‌کنیم. پس از پایان حلقه ارزیابی، تمام نتایج را به هم پیوند می‌دهیم. توجه داشته باشید که باید آنها را کوتاه کنیم زیرا Accelerator ممکن است چند نمونه در انتها اضافه کرده باشد تا مطمئن شویم که در هر فرآیند تعداد نمونه‌های یکسانی داریم.
  • ذخیره و آپلود، که در آن ابتدا مدل و توکن‌ساز را ذخیره می‌کنیم، سپس repo.push_to_hub() را فراخوانی می‌کنیم. همانطور که قبلاً انجام دادیم، از آرگومان blocking=False استفاده می‌کنیم تا به کتابخانه 🤗 هاب بگوییم که یک فرآیند ناهمزمان را وارد کند. به این ترتیب، آموزش به طور عادی ادامه می‌یابد و این دستورالعمل (طولانی) در پس‌زمینه اجرا می‌شود.

کد کامل حلقه آموزشی به صورت زیر است:

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 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()
    start_logits = []
    end_logits = []
    accelerator.print("Evaluation!")
    for batch in tqdm(eval_dataloader):
        with torch.no_grad():
            outputs = model(**batch)

        start_logits.append(accelerator.gather(outputs.start_logits).cpu().numpy())
        end_logits.append(accelerator.gather(outputs.end_logits).cpu().numpy())

    start_logits = np.concatenate(start_logits)
    end_logits = np.concatenate(end_logits)
    start_logits = start_logits[: len(validation_dataset)]
    end_logits = end_logits[: len(validation_dataset)]

    metrics = compute_metrics(
        start_logits, end_logits, validation_dataset, raw_datasets["validation"]
    )
    print(f"epoch {epoch}:", metrics)

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

اگر نخستین بار است مدلی را می‌بینید که با 🤗 Accelerate ذخیره شده، سه خط کدی را که با آن همراه‌اند بررسی کنیم:

accelerator.wait_for_everyone()
unwrapped_model = accelerator.unwrap_model(model)
unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)

خط اول نیازی به توضیح ندارد: به همه فرآیندها می‌گوید که قبل از ادامه، منتظر بمانند تا همه به آن مرحله برسند. این کار برای اطمینان از این است که قبل از ذخیره، مدل یکسانی را در هر فرآیند داریم. سپس unwrapped_model را که مدل پایه‌ای است که تعریف کرده‌ایم، برمی‌داریم. روش accelerator.prepare() مدل را طوری تغییر می‌دهد که در آموزش توزیع‌شده کار کند، بنابراین دیگر روش save_pretrained() را نخواهد داشت؛ روش accelerator.unwrap_model() آن مرحله را خنثی می‌کند. در نهایت، save_pretrained() را فراخوانی می‌کنیم، اما به آن می‌گوییم به‌جای torch.save() از accelerator.save() استفاده کند.

پس از این کار باید مدلی داشته باشید که نتایجی شبیه مدل تعلیم‌دیده با Trainer تولید کند. مدل ما در huggingface-course/bert-finetuned-squad-accelerate در دسترس است. برای آزمایش تغییرها، کد حلقه‌ی تعلیم بالا را ویرایش کنید!

{/if}

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

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

from transformers import pipeline

# Replace this with your own checkpoint
model_checkpoint = "huggingface-course/bert-finetuned-squad"
question_answerer = pipeline("question-answering", model=model_checkpoint)

context = """
🤗 Transformers is backed by the three most popular deep learning libraries — Jax, PyTorch and TensorFlow — with a seamless integration
between them. It's straightforward to train your models with one before loading them for inference with the other.
"""
question = "Which deep learning libraries back 🤗 Transformers?"
question_answerer(question=question, context=context)
{'score': 0.9979003071784973,
 'start': 78,
 'end': 105,
 'answer': 'Jax, PyTorch and TensorFlow'}

عالیه! مدل ما به خوبی مدل پیش‌فرض این خط تولید کار می‌کند!

Xet Storage Details

Size:
71.2 kB
·
Xet hash:
34fb0fc110fa7566fa7783b1b601af11a1f2ba493f611098c635aca3a0c9b6cd

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