Buckets:

|
download
raw
50.7 kB

دسته‌بندی توکِن[[token-classification]]

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

{/if}

اولین کاربردی که بررسی می‌کنیم دسته‌بندی توکِن است. این وظیفه‌ی عمومی هر مسئله‌ای را دربرمی‌گیرد که بتوان آن را به‌شکل «اختصاص دادن یک برچسب به هر توکِن در جمله» صورت‌بندی کرد، مانند:

  • تشخیص موجودیت نام‌دار (NER): موجودیت‌هایی مانند افراد، مکان‌ها یا سازمان‌ها را در جمله پیدا کنید. می‌توان این کار را با اختصاص یک کلاس به هر موجودیت و یک کلاس برای «بدون موجودیت» به هر توکِن صورت‌بندی کرد.
  • برچسب‌گذاری نقش دستوری (POS): هر کلمه‌ی جمله را با نقش دستوری مناسب، مانند اسم، فعل یا صفت، علامت‌گذاری کنید.
  • قطعه‌بندی (Chunking): توکِن‌هایی را پیدا کنید که به یک موجودیت تعلق دارند. می‌توان به توکِن‌های آغاز قطعه برچسب B-، به توکِن‌های داخل قطعه برچسب I- و به توکِن‌های بیرون از هر قطعه برچسب O داد.

البته انواع دیگری از مسئله‌های دسته‌بندی توکِن هم وجود دارد؛ این‌ها فقط چند نمونه‌ی نماینده‌اند. در این بخش، مدلی (BERT) را روی مسئله‌ی NER کوک می‌کنیم تا بتواند پیش‌بینی‌هایی مانند این انجام دهد:

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

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

در قدم اول به دیتاسِتی مناسب برای دسته‌بندی توکِن نیاز داریم. در این بخش از دیتاسِت CoNLL-2003 استفاده می‌کنیم که شامل خبرهای رویترز است.

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

دیتاسِت CoNLL-2003[[the-conll-2003-dataset]]

برای بارگذاری دیتاسِت CoNLL-2003، از متد load_dataset() در کتابخانه‌ی 🤗 Datasets استفاده می‌کنیم:

from datasets import load_dataset

raw_datasets = load_dataset("conll2003")

این کار دیتاسِت را دانلود و در کش ذخیره می‌کند؛ همان‌طور که در فصل ۳ برای دیتاسِت GLUE MRPC دیدیم. بررسی این شیء ستون‌های موجود و تقسیم داده‌ها به مجموعه‌های تعلیم، اعتبارسنجی و آزمون را نشان می‌دهد:

raw_datasets
DatasetDict({
    train: Dataset({
        features: ['chunk_tags', 'id', 'ner_tags', 'pos_tags', 'tokens'],
        num_rows: 14041
    })
    validation: Dataset({
        features: ['chunk_tags', 'id', 'ner_tags', 'pos_tags', 'tokens'],
        num_rows: 3250
    })
    test: Dataset({
        features: ['chunk_tags', 'id', 'ner_tags', 'pos_tags', 'tokens'],
        num_rows: 3453
    })
})

به‌طور مشخص می‌بینیم دیتاسِت برای سه وظیفه‌ی گفته‌شده، یعنی NER، POS و قطعه‌بندی، برچسب دارد. تفاوت مهم با دیتاسِت‌های دیگر این است که متن‌های ورودی به‌صورت جمله یا سند ارائه نشده‌اند، بلکه فهرستی از کلمات‌اند؛ ورودی‌ها از پیش به کلمه‌ها تقسیم شده‌اند و هنوز باید برای توکِن‌سازی زیرکلمه از توکِن‌ساز عبور کنند.

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

raw_datasets["train"][0]["tokens"]
['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb', '.']

چون می‌خواهیم تشخیص موجودیت نام‌دار انجام دهیم، برچسب‌های NER را بررسی می‌کنیم:

raw_datasets["train"][0]["ner_tags"]
[3, 0, 7, 0, 0, 0, 7, 0, 0]

این‌ها برچسب‌هایی عددی و آماده‌ی تعلیم‌اند، اما لزوماً برای بررسی داده مفید نیستند. مانند دسته‌بندی متن، با نگاه کردن به ویژگی features دیتاسِت می‌توانیم تناظر میان این اعداد و نام برچسب‌ها را ببینیم:

ner_feature = raw_datasets["train"].features["ner_tags"]
ner_feature
Sequence(feature=ClassLabel(num_classes=9, names=['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC'], names_file=None, id=None), length=-1, id=None)

پس این ستون عناصری دارد که دنباله‌ای از ClassLabelها هستند. نوع عناصر دنباله در ویژگی feature مربوط به ner_feature قرار دارد و با نگاه کردن به ویژگی names همان feature می‌توانیم فهرست نام‌ها را بگیریم:

label_names = ner_feature.feature.names
label_names
['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC']

این برچسب‌ها را هنگام بررسی خط تولید token-classification در فصل ۶ دیدیم، اما برای یادآوری کوتاه:

  • O یعنی کلمه با هیچ موجودیتی متناظر نیست.
  • B-PER/I-PER یعنی کلمه به‌ترتیب با آغاز یک موجودیت شخص متناظر است یا درون آن قرار دارد.
  • B-ORG/I-ORG یعنی کلمه به‌ترتیب با آغاز یک موجودیت سازمان متناظر است یا درون آن قرار دارد.
  • B-LOC/I-LOC یعنی کلمه به‌ترتیب با آغاز یک موجودیت مکان متناظر است یا درون آن قرار دارد.
  • B-MISC/I-MISC یعنی کلمه به‌ترتیب با آغاز یک موجودیت متفرقه متناظر است یا درون آن قرار دارد.

حالا با رمزگشایی برچسب‌هایی که پیش‌تر دیدیم به این نتیجه می‌رسیم:

words = raw_datasets["train"][0]["tokens"]
labels = raw_datasets["train"][0]["ner_tags"]
line1 = ""
line2 = ""
for word, label in zip(words, labels):
    full_label = label_names[label]
    max_length = max(len(word), len(full_label))
    line1 += word + " " * (max_length - len(word) + 1)
    line2 += full_label + " " * (max_length - len(full_label) + 1)

print(line1)
print(line2)
'EU    rejects German call to boycott British lamb .'
'B-ORG O       B-MISC O    O  O       B-MISC  O    O'

برای نمونه‌ای که برچسب‌های B- و I- را با هم دارد، همین کد برای عنصر شماره‌ی ۴ مجموعه‌ی تعلیم چنین خروجی‌ای می‌دهد:

'Germany \'s representative to the European Union \'s veterinary committee Werner Zwingmann said on Wednesday consumers should buy sheepmeat from countries other than Britain until the scientific advice was clearer .'
'B-LOC   O  O              O  O   B-ORG    I-ORG O  O          O         B-PER  I-PER     O    O  O         O         O      O   O         O    O         O     O    B-LOC   O     O   O          O      O   O       O'

همان‌طور که می‌بینیم، موجودیت‌هایی که دو کلمه را دربرمی‌گیرند، مانند «European Union» و «Werner Zwingmann»، برای کلمه‌ی اول برچسب B- و برای کلمه‌ی دوم برچسب I- می‌گیرند.

✏️ نوبت شماست! همان دو جمله را با برچسب‌های POS یا قطعه‌بندی چاپ کنید.

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

طبق معمول، پیش از آنکه مدل بتواند متن‌ها را درک کند، باید آن‌ها را به شناسه‌های توکِن تبدیل کنیم. همان‌طور که در فصل ۶ دیدیم، تفاوت مهم وظایف دسته‌بندی توکِن این است که ورودی‌ها از قبل توکِن‌سازی شده‌اند. خوشبختانه API توکِن‌ساز به‌راحتی از این وضعیت پشتیبانی می‌کند؛ فقط باید با یک پرچم ویژه به tokenizer هشدار دهیم.

برای شروع، شیء tokenizer را می‌سازیم. همان‌طور که گفتیم، از یک مدل از پیش تعلیم‌دیده‌ی BERT استفاده می‌کنیم، پس ابتدا توکِن‌ساز مربوط را دانلود و در کش ذخیره می‌کنیم:

from transformers import AutoTokenizer

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

می‌توانید model_checkpoint را با هر مدل دیگری از هاب یا با پوشه‌ی محلی حاوی مدل و توکِن‌ساز از پیش تعلیم‌دیده جایگزین کنید. تنها محدودیت این است که توکِن‌ساز باید بر کتابخانه‌ی 🤗 Tokenizers متکی باشد تا نسخه‌ی سریع آن موجود باشد. معماری‌های دارای نسخه‌ی سریع در این جدول بزرگ آمده‌اند؛ برای اطمینان نیز ویژگی is_fast شیء tokenizer را بررسی کنید:

tokenizer.is_fast
True

برای توکِن‌سازی ورودی‌ای که از قبل به کلمه تقسیم شده، می‌توانیم طبق معمول از tokenizer استفاده کنیم و فقط is_split_into_words=True را اضافه کنیم:

inputs = tokenizer(raw_datasets["train"][0]["tokens"], is_split_into_words=True)
inputs.tokens()
['[CLS]', 'EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'la', '##mb', '.', '[SEP]']

توکِن‌ساز توکِن‌های ویژه‌ی مدل را اضافه کرده است ([CLS] در ابتدا و [SEP] در انتها) و بیشتر کلمات را دست‌نخورده گذاشته است. اما lamb به دو زیرکلمه‌ی la و ##mb تبدیل شده است. در نتیجه میان ورودی‌ها و برچسب‌ها ناسازگاری ایجاد می‌شود: فهرست برچسب‌ها فقط ۹ عنصر دارد، در حالی که ورودی اکنون ۱۲ توکِن دارد. حساب کردن توکِن‌های ویژه آسان است، اما باید همه‌ی برچسب‌ها را با کلمه‌های درست هم‌تراز کنیم.

چون از توکِن‌ساز سریع استفاده می‌کنیم، به قابلیت‌های ویژه‌ی 🤗 Tokenizers دسترسی داریم و می‌توانیم هر توکِن را به‌سادگی به کلمه‌ی متناظر آن نگاشت کنیم؛ همان‌طور که در فصل ۶ دیدیم:

inputs.word_ids()
[None, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, None]

با کمی کار می‌توانیم فهرست برچسب‌ها را گسترش دهیم تا با توکِن‌ها هم‌اندازه شود. توکِن‌های ویژه برچسب -100 می‌گیرند؛ چون -100 در تابع هزینه‌ی مورد استفاده (آنتروپی متقابل) نادیده گرفته می‌شود. سپس هر توکِن همان برچسب توکِنی را می‌گیرد که کلمه‌ی دربرگیرنده‌اش را آغاز کرده است. برای توکِن‌های داخل یک کلمه که در آغاز آن نیستند، B- را به I- تبدیل می‌کنیم.

def align_labels_with_tokens(labels, word_ids):
    new_labels = []
    current_word = None
    for word_id in word_ids:
        if word_id != current_word:
            # Start of a new word!
            current_word = word_id
            label = -100 if word_id is None else labels[word_id]
            new_labels.append(label)
        elif word_id is None:
            # Special token
            new_labels.append(-100)
        else:
            # Same word as previous token
            label = labels[word_id]
            # If the label is B-XXX we change it to I-XXX
            if label % 2 == 1:
                label += 1
            new_labels.append(label)

    return new_labels

بیایید آن را روی نخستین جمله امتحان کنیم:

labels = raw_datasets["train"][0]["ner_tags"]
word_ids = inputs.word_ids()
print(labels)
print(align_labels_with_tokens(labels, word_ids))
[3, 0, 7, 0, 0, 0, 7, 0, 0]
[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]

تابع ما برای دو توکِن ویژه در ابتدا و انتها -100 و برای کلمه‌ای که به دو توکِن تقسیم شده، یک 0 جدید اضافه کرده است.

✏️ نوبت شماست! بعضی پژوهشگران ترجیح می‌دهند برای هر کلمه فقط یک برچسب اختصاص دهند و به زیرتوکِن‌های دیگر همان کلمه -100 بدهند. تابع قبلی را طوری تغییر دهید که برچسب‌ها را با شناسه‌های ورودی بر اساس این قاعده هم‌تراز کند.

برای پیش‌پردازش کل دیتاسِت، باید همه‌ی ورودی‌ها را توکِن‌سازی کنیم و align_labels_with_tokens() را روی همه‌ی برچسب‌ها اعمال کنیم. برای بهره بردن از سرعت توکِن‌ساز سریع، متن‌های زیادی را هم‌زمان توکِن‌سازی می‌کنیم؛ پس تابعی می‌نویسیم که فهرستی از نمونه‌ها را پردازش کند و از Dataset.map() با گزینه‌ی batched=True استفاده کنیم. وقتی ورودی‌ها فهرستی از متن‌ها هستند، word_ids() باید اندیس نمونه‌ای را بگیرد که شناسه‌های کلمه‌ی آن را می‌خواهیم؛ این را هم اضافه می‌کنیم:

def tokenize_and_align_labels(examples):
    tokenized_inputs = tokenizer(
        examples["tokens"], truncation=True, is_split_into_words=True
    )
    all_labels = examples["ner_tags"]
    new_labels = []
    for i, labels in enumerate(all_labels):
        word_ids = tokenized_inputs.word_ids(i)
        new_labels.append(align_labels_with_tokens(labels, word_ids))

    tokenized_inputs["labels"] = new_labels
    return tokenized_inputs

توجه کنید که هنوز ورودی‌ها را هم‌طول نکرده‌ایم؛ این کار را بعداً، هنگام ساخت بتچ‌ها با یک جمع‌کننده‌ی داده انجام می‌دهیم.

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

tokenized_datasets = raw_datasets.map(
    tokenize_and_align_labels,
    batched=True,
    remove_columns=raw_datasets["train"].column_names,
)

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

{#if fw === 'pt'}

کوک کردن مدل با API Trainer[[fine-tuning-the-model-with-the-trainer-api]]

کد واقعی استفاده از Trainer مانند قبل است؛ تنها تغییرها روش جمع کردن داده‌ها در یک بتچ و تابع محاسبه‌ی معیار هستند.

{:else}

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

کد واقعی استفاده از کِراس بسیار شبیه قبل است؛ تنها تغییرها روش جمع کردن داده‌ها در یک بتچ و تابع محاسبه‌ی معیار هستند.

{/if}

جمع کردن داده‌ها[[data-collation]]

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

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

{#if fw === 'pt'}

from transformers import DataCollatorForTokenClassification

data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)

{:else}

from transformers import DataCollatorForTokenClassification

data_collator = DataCollatorForTokenClassification(
    tokenizer=tokenizer, return_tensors="tf"
)

{/if}

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

batch = data_collator([tokenized_datasets["train"][i] for i in range(2)])
batch["labels"]
tensor([[-100,    3,    0,    7,    0,    0,    0,    7,    0,    0,    0, -100],
        [-100,    1,    2, -100, -100, -100, -100, -100, -100, -100, -100, -100]])

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

for i in range(2):
    print(tokenized_datasets["train"][i]["labels"])
[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]
[-100, 1, 2, -100]

{#if fw === 'pt'}

مجموعه‌ی دوم برچسب‌ها با استفاده از -100ها تا طول مجموعه‌ی اول هم‌طول شده است.

{:else}

جمع‌کننده‌ی داده آماده است! حالا از آن برای ساختن یک tf.data.Dataset با متد to_tf_dataset() استفاده می‌کنیم. همچنین می‌توانید با model.prepare_tf_dataset() همین کار را با کد کم‌تری انجام دهید؛ در بخش‌های دیگر این فصل آن را خواهید دید.

tf_train_dataset = tokenized_datasets["train"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "labels", "token_type_ids"],
    collate_fn=data_collator,
    shuffle=True,
    batch_size=16,
)

tf_eval_dataset = tokenized_datasets["validation"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "labels", "token_type_ids"],
    collate_fn=data_collator,
    shuffle=False,
    batch_size=16,
)

گام بعدی: خود مدل.

{/if}

{#if fw === 'tf'}

تعریف مدل[[defining-the-model]]

چون با مسئله‌ی دسته‌بندی توکِن کار می‌کنیم، از کلاس TFAutoModelForTokenClassification استفاده می‌کنیم. نکته‌ی اصلی هنگام تعریف مدل این است که اطلاعاتی درباره‌ی تعداد برچسب‌ها به آن بدهیم. ساده‌ترین راه ارسال این تعداد با آرگومان num_labels است؛ اما برای داشتن ویجت استنتاجی مناسب، بهتر است تناظر درست برچسب‌ها را تنظیم کنیم.

این تناظرها باید با دو دیکشنری id2label و label2id تنظیم شوند که نگاشت شناسه به برچسب و برعکس را در خود دارند:

id2label = {i: label for i, label in enumerate(label_names)}
label2id = {v: k for k, v in id2label.items()}

اکنون کافی است آن‌ها را به متد TFAutoModelForTokenClassification.from_pretrained() بدهیم تا در تنظیمات مدل قرار بگیرند و سپس به‌درستی ذخیره و روی هاب بارگذاری شوند:

from transformers import TFAutoModelForTokenClassification

model = TFAutoModelForTokenClassification.from_pretrained(
    model_checkpoint,
    id2label=id2label,
    label2id=label2id,
)

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

model.config.num_labels
9

⚠️ اگر مدل تعداد برچسب نادرستی داشته باشد، هنگام فراخوانی model.fit() با خطایی مبهم روبه‌رو می‌شوید. اشکال‌زدایی این خطا آزاردهنده است، پس این بررسی را انجام دهید تا از تعداد درست برچسب‌ها مطمئن شوید.

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

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

from huggingface_hub import notebook_login

notebook_login()

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

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

huggingface-cli login

پس از ورود، همه‌چیز را برای کامپایل مدل آماده می‌کنیم. 🤗 Transformers تابع create_optimizer() را فراهم می‌کند که یک بهینه‌ساز AdamW با تنظیمات مناسب برای کاهش وزن و کاهش نرخ یادگیری می‌سازد؛ هر دو مورد عملکرد مدل را بهتر می‌کنند:

from transformers import create_optimizer
import tensorflow as tf

# Train in mixed-precision float16
# Comment this line out if you're using a GPU that will not benefit from this
tf.keras.mixed_precision.set_global_policy("mixed_float16")

# The number of training steps is the number of samples in the dataset, divided by the batch size then multiplied
# by the total number of epochs. Note that the tf_train_dataset here is a batched tf.data.Dataset,
# not the original Hugging Face Dataset, so its len() is already num_samples // batch_size.
num_epochs = 3
num_train_steps = len(tf_train_dataset) * num_epochs

optimizer, schedule = create_optimizer(
    init_lr=2e-5,
    num_warmup_steps=0,
    num_train_steps=num_train_steps,
    weight_decay_rate=0.01,
)
model.compile(optimizer=optimizer)

آرگومان loss را به compile() نمی‌دهیم، چون مدل‌ها می‌توانند هزینه را به‌صورت داخلی محاسبه کنند. اگر مدل را بدون هزینه کامپایل کنید و برچسب‌ها را در دیکشنری ورودی قرار دهید، مدل با همان هزینه‌ی داخلی و متناسب با وظیفه و نوع مدل تعلیم می‌بیند.

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

from transformers.keras_callbacks import PushToHubCallback

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

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

با آرگومان hub_model_id می‌توانید نام کامل مخزن مقصد را مشخص کنید؛ برای پوش به یک سازمان به آن نیاز دارید. برای نمونه، هنگام پوش کردن مدل به سازمان huggingface-course، از شناسه‌ی hub_model_id="huggingface-course/bert-finetuned-ner" استفاده می‌کنیم. به‌طور پیش‌فرض مخزن در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود.

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

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

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

{/if}

معیارها[[metrics]]

{#if fw === 'pt'}

برای اینکه Trainer در هر دوره یک معیار را محاسبه کند، باید تابع compute_metrics() را تعریف کنیم؛ این تابع آرایه‌های پیش‌بینی و برچسب را می‌گیرد و دیکشنری‌ای از نام و مقدار معیارها برمی‌گرداند.

چارچوب سنتی ارزیابی پیش‌بینی‌های دسته‌بندی توکِن seqeval است. برای استفاده از این معیار، ابتدا باید کتابخانه‌ی seqeval را نصب کنیم:

!pip install seqeval

سپس مانند فصل ۳ آن را با تابع evaluate.load() بارگذاری می‌کنیم:

{:else}

چارچوب سنتی ارزیابی پیش‌بینی‌های دسته‌بندی توکِن seqeval است. برای استفاده از این معیار، ابتدا باید کتابخانه‌ی seqeval را نصب کنیم:

!pip install seqeval

سپس مانند فصل ۳ آن را با تابع evaluate.load() بارگذاری می‌کنیم:

{/if}

import evaluate

metric = evaluate.load("seqeval")

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

labels = raw_datasets["train"][0]["ner_tags"]
labels = [label_names[i] for i in labels]
labels
['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O', 'O']

سپس با تغییر مقدار اندیس ۲ برای آن‌ها پیش‌بینی‌های ساختگی می‌سازیم:

predictions = labels.copy()
predictions[2] = "O"
metric.compute(predictions=[predictions], references=[labels])

معیار فهرستی از پیش‌بینی‌ها و فهرستی از برچسب‌ها می‌گیرد. خروجی چنین است:

{'MISC': {'precision': 1.0, 'recall': 0.5, 'f1': 0.67, 'number': 2},
 'ORG': {'precision': 1.0, 'recall': 1.0, 'f1': 1.0, 'number': 1},
 'overall_precision': 1.0,
 'overall_recall': 0.67,
 'overall_f1': 0.8,
 'overall_accuracy': 0.89}

{#if fw === 'pt'}

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

تابع compute_metrics() ابتدا آرگومان بیشینه را برای تبدیل لوجیت‌ها به پیش‌بینی می‌گیرد؛ سپس برچسب‌ها و پیش‌بینی‌ها را از عدد صحیح به رشته تبدیل می‌کند، مقادیر دارای برچسب -100 را حذف می‌کند و نتیجه را به metric.compute() می‌دهد:

import numpy as np

def compute_metrics(eval_preds):
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)

    # Remove ignored index (special tokens) and convert to labels
    true_labels = [[label_names[l] for l in label if l != -100] for label in labels]
    true_predictions = [
        [label_names[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    all_metrics = metric.compute(predictions=true_predictions, references=true_labels)
    return {
        "precision": all_metrics["overall_precision"],
        "recall": all_metrics["overall_recall"],
        "f1": all_metrics["overall_f1"],
        "accuracy": all_metrics["overall_accuracy"],
    }

حالا تقریباً آماده‌ی تعریف Trainer هستیم. فقط به مدلی نیاز داریم که آن را کوک کنیم!

{:else}

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

TensorFlow نمی‌تواند پیش‌بینی‌های ما را به هم بچسباند، چون طول توالی‌ها متغیر است. پیش‌بینی‌ها را بتچ‌به‌بتچ می‌گیریم و در فهرستی بزرگ جمع می‌کنیم، توکِن‌های -100 مربوط به ماسک یا هم‌طول‌سازی را کنار می‌گذاریم و در پایان معیارها را محاسبه می‌کنیم:

import numpy as np

all_predictions = []
all_labels = []
for batch in tf_eval_dataset:
    logits = model.predict_on_batch(batch)["logits"]
    labels = batch["labels"]
    predictions = np.argmax(logits, axis=-1)
    for prediction, label in zip(predictions, labels):
        for predicted_idx, label_idx in zip(prediction, label):
            if label_idx == -100:
                continue
            all_predictions.append(label_names[predicted_idx])
            all_labels.append(label_names[label_idx])
metric.compute(predictions=[all_predictions], references=[all_labels])
{'LOC': {'precision': 0.91, 'recall': 0.92, 'f1': 0.91, 'number': 1668},
 'MISC': {'precision': 0.70, 'recall': 0.79, 'f1': 0.74, 'number': 702},
 'ORG': {'precision': 0.85, 'recall': 0.90, 'f1': 0.88, 'number': 1661},
 'PER': {'precision': 0.95, 'recall': 0.95, 'f1': 0.95, 'number': 1617},
 'overall_precision': 0.87,
 'overall_recall': 0.91,
 'overall_f1': 0.89,
 'overall_accuracy': 0.97}

مدل شما در مقایسه با مدل ما چگونه عمل کرد؟ اگر اعداد مشابهی گرفتید، تعلیم شما موفق بوده است!

{/if}

{#if fw === 'pt'}

تعریف مدل[[defining-the-model]]

چون با مسئله‌ی دسته‌بندی توکِن کار می‌کنیم، از کلاس AutoModelForTokenClassification استفاده می‌کنیم. ساده‌ترین راه ارسال تعداد برچسب‌ها با آرگومان num_labels است؛ اما برای داشتن ویجت استنتاج مناسب، بهتر است تناظر صحیح برچسب‌ها را تنظیم کنیم.

این تناظرها باید با دو دیکشنری id2label و label2id تنظیم شوند که نگاشت شناسه به برچسب و برعکس را در خود دارند:

id2label = {i: label for i, label in enumerate(label_names)}
label2id = {v: k for k, v in id2label.items()}

اکنون آن‌ها را به متد AutoModelForTokenClassification.from_pretrained() می‌دهیم تا در تنظیمات مدل قرار بگیرند و سپس ذخیره و روی هاب بارگذاری شوند:

from transformers import AutoModelForTokenClassification

model = AutoModelForTokenClassification.from_pretrained(
    model_checkpoint,
    id2label=id2label,
    label2id=label2id,
)

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

model.config.num_labels
9

⚠️ اگر مدل تعداد برچسب نادرستی داشته باشد، هنگام فراخوانی متد Trainer.train() با خطایی مبهم مانند «CUDA error: device-side assert triggered» روبه‌رو می‌شوید. این رایج‌ترین علت خطاهای گزارش‌شده است؛ پس تعداد درست برچسب‌ها را بررسی کنید.

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

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

from huggingface_hub import notebook_login

notebook_login()

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

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

huggingface-cli login

پس از این کار می‌توانیم TrainingArguments را تعریف کنیم:

from transformers import TrainingArguments

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

ابرپارامترهایی مانند نرخ یادگیری، تعداد دوره‌های تعلیم و کاهش وزن را تنظیم می‌کنیم و با تعیین push_to_hub=True می‌گوییم مدل در پایان هر دوره ذخیره و ارزیابی و نتایج روی هاب مدل بارگذاری شود. با hub_model_id می‌توانید نام مخزن مقصد را مشخص کنید؛ برای نمونه، سازمان huggingface-course را می‌توان به‌عنوان مقصد تعیین کرد و مقدار hub_model_id="huggingface-course/bert-finetuned-ner" را به TrainingArguments داد. در اینجا مخزن پیش‌فرض در فضای نام شما و با نام دایرکتوری خروجی ساخته می‌شود.

💡 اگر دایرکتوری خروجی از قبل وجود داشته باشد، باید کلون محلی مخزن مقصد باشد؛ در غیر این صورت هنگام تعریف Trainer خطا می‌گیرید و باید نام تازه‌ای انتخاب کنید.

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

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    compute_metrics=compute_metrics,
    processing_class=tokenizer,
)
trainer.train()

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

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

trainer.push_to_hub(commit_message="Training complete")

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

'https://huggingface.co/sgugger/bert-finetuned-ner/commit/26ab21e5b1568f9afeccdaed2d8715f571d786ed'

Trainer همچنین یک کارت مدل با همه‌ی نتایج ارزیابی ایجاد و بارگذاری می‌کند. اکنون می‌توانید با ویجت استنتاج در هاب مدل آن را آزمایش و با دوستانتان به اشتراک بگذارید. شما با موفقیت مدلی را برای دسته‌بندی توکِن کوک کرده‌اید — تبریک می‌گوییم!

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

حلقه‌ی تعلیم سفارشی[[a-custom-training-loop]]

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

آماده‌سازی همه‌چیز برای تعلیم[[preparing-everything-for-training]]

ابتدا باید DataLoaderها را از دیتاسِت‌ها بسازیم. از data_collator دوباره به‌عنوان collate_fn استفاده می‌کنیم و مجموعه‌ی تعلیم را درهم می‌ریزیم، اما مجموعه‌ی اعتبارسنجی را نه:

from torch.utils.data import DataLoader

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

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

model = AutoModelForTokenClassification.from_pretrained(
    model_checkpoint,
    id2label=id2label,
    label2id=label2id,
)

از AdamW کلاسیک استفاده می‌کنیم که مانند Adam است، اما شیوه‌ی اعمال کاهش وزن در آن اصلاح شده است:

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 تعلیم می‌دهید، باید همه‌ی کدهای سلول قبل را داخل تابع تعلیم ویژه‌ای قرار دهید. برای جزئیات بیشتر فصل ۳ را ببینید.

حالا که 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-ner-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name
'sgugger/bert-finetuned-ner-accelerate'

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

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

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

حلقه‌ی تعلیم[[training-loop]]

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

def postprocess(predictions, labels):
    predictions = predictions.detach().cpu().clone().numpy()
    labels = labels.detach().cpu().clone().numpy()

    # Remove ignored index (special tokens) and convert to labels
    true_labels = [[label_names[l] for l in label if l != -100] for label in labels]
    true_predictions = [
        [label_names[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    return true_labels, true_predictions

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

  • خود تعلیم: پیمایش روی train_dataloader، اجرای رو به جلوی مدل، سپس اجرای پس‌رو و گام بهینه‌ساز.
  • ارزیابی: چون فرایندها ممکن است ورودی‌ها و برچسب‌ها را به شکل‌های متفاوت هم‌طول کرده باشند، پیش از gather() از accelerator.pad_across_processes() استفاده می‌کنیم تا شکل پیش‌بینی‌ها و برچسب‌ها یکسان شود؛ سپس metric.add_batch() و در پایان metric.compute() را فراخوانی می‌کنیم.
  • ذخیره و بارگذاری: مدل و توکِن‌ساز را ذخیره می‌کنیم و 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 batch in train_dataloader:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

    # Evaluation
    model.eval()
    for batch in eval_dataloader:
        with torch.no_grad():
            outputs = model(**batch)

        predictions = outputs.logits.argmax(dim=-1)
        labels = batch["labels"]

        # Necessary to pad predictions and labels for being gathered
        predictions = accelerator.pad_across_processes(predictions, dim=1, pad_index=-100)
        labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100)

        predictions_gathered = accelerator.gather(predictions)
        labels_gathered = accelerator.gather(labels)

        true_predictions, true_labels = postprocess(predictions_gathered, labels_gathered)
        metric.add_batch(predictions=true_predictions, references=true_labels)

    results = metric.compute()
    print(
        f"epoch {epoch}:",
        {
            key: results[f"overall_{key}"]
            for key in ["precision", "recall", "f1", "accuracy"]
        },
    )

    # 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() مدل را برای تعلیم توزیع‌شده تغییر می‌دهد و accelerator.unwrap_model() این تغییر را برمی‌گرداند. در پایان save_pretrained() را با accelerator.save() به‌جای torch.save() فراخوانی می‌کنیم.

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

{/if}

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

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

from transformers import pipeline

# Replace this with your own checkpoint
model_checkpoint = "huggingface-course/bert-finetuned-ner"
token_classifier = pipeline(
    "token-classification", model=model_checkpoint, aggregation_strategy="simple"
)
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")
[{'entity_group': 'PER', 'score': 0.9988506, 'word': 'Sylvain', 'start': 11, 'end': 18},
 {'entity_group': 'ORG', 'score': 0.9647625, 'word': 'Hugging Face', 'start': 33, 'end': 45},
 {'entity_group': 'LOC', 'score': 0.9986118, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

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

Xet Storage Details

Size:
50.7 kB
·
Xet hash:
3ae12128fc47c0d2b6a763ec38c04664b64112fb2f2eaf0be152ceaf6b842cda

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