Buckets:

|
download
raw
30.4 kB

قابلیت‌های ویژه‌ی توکِنایزرهای سریع[[fast-tokenizers-special-powers]]

{#if fw === 'pt'}

<CourseFloatingBanner chapter={6} 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/chapter6/section3_pt.ipynb"}, {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter6/section3_pt.ipynb"}, ]} />

{:else}

<CourseFloatingBanner chapter={6} 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/chapter6/section3_tf.ipynb"}, {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter6/section3_tf.ipynb"}, ]} />

{/if}

در این بخش نگاه دقیق‌تری به قابلیت‌های توکِنایزرهای 🤗 Transformers می‌اندازیم. تا اینجا فقط از آن‌ها برای توکِن‌سازی ورودی‌ها یا تبدیل دوباره‌ی شناسه‌ها به متن استفاده کرده‌ایم، اما توکِنایزرها — به‌خصوص آن‌هایی که به کتابخانه‌ی 🤗 Tokenizers متکی هستند — کارهای بسیار بیشتری می‌توانند انجام دهند. برای نشان دادن این قابلیت‌های اضافی، بررسی می‌کنیم چگونه می‌توان نتایج خط‌های تولید token-classification (که آن را ner نامیدیم) و question-answering را که نخستین بار در فصل ۱ دیدیم، بازتولید کرد.

در بحث پیش‌رو، اغلب بین توکِنایزرهای «کند» و «سریع» تفاوت می‌گذاریم. توکِنایزرهای کند درون کتابخانه‌ی 🤗 Transformers با پایتون نوشته شده‌اند، درحالی‌که نسخه‌های سریع را 🤗 Tokenizers فراهم می‌کند که با Rust نوشته شده‌اند. اگر جدول فصل ۵ را به یاد داشته باشید که مدت‌زمان توکِن‌سازی دیتاست مرور دارو را با یک توکِنایزر سریع و کند گزارش می‌کرد، باید ایده‌ای از دلیل این نام‌گذاری داشته باشید:

توکِنایزر سریع توکِنایزر کند
batched=True 10.8s 4min41s
batched=False 59.2s 5min3s

⚠️ هنگام توکِن‌سازی یک جمله‌ی واحد، همیشه تفاوت سرعتی بین نسخه‌ی سریع و کند یک توکِنایزر یکسان نمی‌بینید. حتی ممکن است نسخه‌ی سریع واقعاً کندتر باشد! تنها وقتی تعداد زیادی متن را هم‌زمان و به‌صورت موازی توکِن‌سازی کنید، تفاوت را به‌وضوح خواهید دید.

رمزگذاری بتچ[[batch-encoding]]

خروجی یک توکِنایزر، یک دیکشنری ساده‌ی پایتون نیست؛ چیزی که در واقع دریافت می‌کنیم یک شیء ویژه‌ی BatchEncoding است. این شیء زیرکلاسی از یک دیکشنری است (به همین دلیل پیش‌تر توانستیم بدون مشکل در نتیجه اندیس‌گذاری کنیم)، اما متدهای اضافی‌ای دارد که بیشتر برای توکِنایزرهای سریع استفاده می‌شوند.

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

بیایید یک مثال را بررسی کنیم:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
example = "My name is Sylvain and I work at Hugging Face in Brooklyn."
encoding = tokenizer(example)
print(type(encoding))

همان‌طور که پیش‌تر گفتیم، در خروجی توکِنایزر یک شیء BatchEncoding دریافت می‌کنیم:

<class 'transformers.tokenization_utils_base.BatchEncoding'>

از آنجا که کلاس AutoTokenizer به‌صورت پیش‌فرض یک توکِنایزر سریع انتخاب می‌کند، می‌توانیم از متدهای اضافی‌ای که این شیء BatchEncoding ارائه می‌دهد استفاده کنیم. برای بررسی سریع یا کند بودن توکِنایزرمان دو راه داریم. می‌توانیم ویژگی is_fast مربوط به tokenizer را بررسی کنیم:

tokenizer.is_fast
True

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

encoding.is_fast
True

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

encoding.tokens()
['[CLS]', 'My', 'name', 'is', 'S', '##yl', '##va', '##in', 'and', 'I', 'work', 'at', 'Hu', '##gging', 'Face', 'in',
 'Brooklyn', '.', '[SEP]']

در اینجا توکِنِ اندیس ۵ یعنی ##yl بخشی از کلمه‌ی «Sylvain» در جمله‌ی اصلی است. همچنین می‌توانیم از متد word_ids() استفاده کنیم تا اندیس کلمه‌ای را که هر توکِن از آن آمده به دست آوریم:

encoding.word_ids()
[None, 0, 1, 2, 3, 3, 3, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11, 12, None]

می‌بینیم که توکِن‌های ویژه‌ی توکِنایزر یعنی [CLS] و [SEP] به None نگاشت شده‌اند و سپس هر توکِن به کلمه‌ای که از آن منشأ گرفته نگاشت می‌شود. این قابلیت به‌ویژه برای تشخیص اینکه یک توکِن در ابتدای کلمه قرار دارد یا اینکه دو توکِن متعلق به یک کلمه هستند مفید است. می‌توانستیم برای این کار به پیشوند ## تکیه کنیم، اما این روش فقط برای توکِنایزرهای شبیه BERT کار می‌کند؛ روش حاضر برای هر نوع توکِنایزر، به شرط سریع بودن آن، کار می‌کند. در فصل بعد می‌بینیم چگونه می‌توانیم از این قابلیت برای اعمال درست برچسب‌های هر کلمه روی توکِن‌ها در وظایفی مانند تشخیص موجودیت نامدار (NER) و برچسب‌گذاری نقش دستوری (POS) استفاده کنیم. همچنین می‌توانیم از آن برای ماسک کردن همه‌ی توکِن‌های متعلق به یک کلمه در مدل‌سازی زبان ماسک‌شده (تکنیکی به نام ماسک‌گذاری کل کلمه) استفاده کنیم.

مفهوم «کلمه» پیچیده است. برای مثال، آیا «I'll» (شکل کوتاه‌شده‌ی «I will») یک کلمه محسوب می‌شود یا دو کلمه؟ پاسخ در واقع به توکِنایزر و عملیاتی که برای پیش‌توکِن‌سازی انجام می‌دهد بستگی دارد. برخی توکِنایزرها فقط بر اساس فاصله‌ها جدا می‌کنند، پس این مورد را یک کلمه در نظر می‌گیرند. برخی دیگر علاوه بر فاصله‌ها از علائم نگارشی نیز استفاده می‌کنند و آن را دو کلمه در نظر می‌گیرند.

✏️ امتحان کنید! با استفاده از نقاط تعلیم bert-base-cased و roberta-base یک توکِنایزر بسازید و با آن‌ها «81s» را توکِن‌سازی کنید. چه چیزی مشاهده می‌کنید؟ شناسه‌های کلمه چه هستند؟

به‌طور مشابه، متد sentence_ids() را داریم که می‌توانیم از آن برای نگاشت یک توکِن به جمله‌ای که از آن آمده استفاده کنیم (البته در این مورد، token_type_ids برگشتی از توکِنایزر می‌تواند همین اطلاعات را به ما بدهد).

در نهایت، می‌توانیم هر کلمه یا توکِن را با استفاده از متدهای word_to_chars() یا token_to_chars() و char_to_word() یا char_to_token() به نویسه‌های متن اصلی نگاشت کنیم و برعکس. برای مثال، متد word_ids() به ما گفت که ##yl بخشی از کلمه‌ی اندیس ۳ است، اما این کلمه در جمله کدام است؟ می‌توانیم این‌طور متوجه شویم:

start, end = encoding.word_to_chars(3)
example[start:end]
Sylvain

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

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

درون خط تولید token-classification[[inside-the-token-classification-pipeline]]

در فصل ۱، نخستین تجربه‌ی خود را از به‌کارگیری NER داشتیم — وظیفه‌ای که در آن باید مشخص کنیم کدام بخش‌های متن به موجودیت‌هایی مانند افراد، مکان‌ها یا سازمان‌ها مربوط‌اند — و برای این کار از تابع pipeline() در 🤗 Transformers استفاده کردیم. سپس در فصل ۲ دیدیم که خط تولید چگونه سه مرحله‌ی لازم برای گرفتن پیش‌بینی از یک متن خام را کنار هم قرار می‌دهد: توکِن‌سازی، عبور دادن ورودی‌ها از مدل و پس‌پردازش. دو مرحله‌ی اول خط تولید token-classification مانند هر خط تولید دیگری هستند، اما پس‌پردازش کمی پیچیده‌تر است — بیایید ببینیم چگونه!

{#if fw === 'pt'}

{:else}

{/if}

به‌دست‌آوردن نتایج پایه با خط تولید[[getting-the-base-results-with-the-pipeline]]

ابتدا یک خط تولید دسته‌بندی توکِن می‌گیریم تا بتوانیم نتایجی برای مقایسه‌ی دستی به دست آوریم. مدل پیش‌فرض dbmdz/bert-large-cased-finetuned-conll03-english است؛ این مدل روی جمله‌ها NER انجام می‌دهد:

from transformers import pipeline

token_classifier = pipeline("token-classification")
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")
[{'entity': 'I-PER', 'score': 0.9993828, 'index': 4, 'word': 'S', 'start': 11, 'end': 12},
 {'entity': 'I-PER', 'score': 0.99815476, 'index': 5, 'word': '##yl', 'start': 12, 'end': 14},
 {'entity': 'I-PER', 'score': 0.99590725, 'index': 6, 'word': '##va', 'start': 14, 'end': 16},
 {'entity': 'I-PER', 'score': 0.9992327, 'index': 7, 'word': '##in', 'start': 16, 'end': 18},
 {'entity': 'I-ORG', 'score': 0.97389334, 'index': 12, 'word': 'Hu', 'start': 33, 'end': 35},
 {'entity': 'I-ORG', 'score': 0.976115, 'index': 13, 'word': '##gging', 'start': 35, 'end': 40},
 {'entity': 'I-ORG', 'score': 0.98879766, 'index': 14, 'word': 'Face', 'start': 41, 'end': 45},
 {'entity': 'I-LOC', 'score': 0.99321055, 'index': 16, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

مدل هر توکِنی را که از «Sylvain» تولید شده به‌درستی به‌عنوان یک شخص، هر توکِنی را که از «Hugging Face» تولید شده به‌عنوان یک سازمان و توکِن «Brooklyn» را به‌عنوان یک مکان شناسایی کرد. همچنین می‌توانیم از خط تولید بخواهیم توکِن‌های مربوط به یک موجودیت یکسان را در کنار هم گروه‌بندی کند:

from transformers import pipeline

token_classifier = pipeline("token-classification", aggregation_strategy="simple")
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")
[{'entity_group': 'PER', 'score': 0.9981694, 'word': 'Sylvain', 'start': 11, 'end': 18},
 {'entity_group': 'ORG', 'score': 0.97960204, 'word': 'Hugging Face', 'start': 33, 'end': 45},
 {'entity_group': 'LOC', 'score': 0.99321055, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

استراتژی aggregation_strategy انتخاب‌شده، امتیازهای محاسبه‌شده برای هر موجودیت گروه‌بندی‌شده را تغییر می‌دهد. در حالت "simple"، امتیاز فقط میانگین امتیازهای هر توکِن در موجودیت داده‌شده است: برای مثال، امتیاز «Sylvain» میانگین امتیازهایی است که در نمونه‌ی قبلی برای توکِن‌های S، ##yl، ##va و ##in دیدیم. استراتژی‌های دیگری نیز وجود دارند:

  • "first"، که در آن امتیاز هر موجودیت امتیاز نخستین توکِن آن موجودیت است (پس برای «Sylvain» برابر 0.993828، یعنی امتیاز توکِن S، خواهد بود)
  • "max"، که در آن امتیاز هر موجودیت بیشینه‌ی امتیاز توکِن‌های آن موجودیت است (پس برای «Hugging Face» برابر 0.98879766، یعنی امتیاز «Face»، خواهد بود)
  • "average"، که در آن امتیاز هر موجودیت میانگین امتیاز کلمه‌هایی است که آن موجودیت را تشکیل می‌دهند (پس برای «Sylvain» تفاوتی با استراتژی "simple" ندارد، اما امتیاز «Hugging Face» برابر 0.9819، میانگین امتیازهای «Hugging» یعنی 0.975 و «Face» یعنی 0.98879، خواهد بود)

حالا ببینیم چگونه می‌توانیم این نتایج را بدون استفاده از تابع pipeline() به دست آوریم!

از ورودی‌ها تا پیش‌بینی‌ها[[from-inputs-to-predictions]]

{#if fw === 'pt'}

ابتدا باید ورودی خود را توکِن‌سازی کنیم و آن را از مدل عبور دهیم. این کار دقیقاً مانند فصل ۲ انجام می‌شود؛ با استفاده از کلاس‌های AutoXxx، توکِنایزر و مدل را نمونه‌سازی می‌کنیم و سپس آن‌ها را روی مثال خود به کار می‌بریم:

from transformers import AutoTokenizer, AutoModelForTokenClassification

model_checkpoint = "dbmdz/bert-large-cased-finetuned-conll03-english"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
model = AutoModelForTokenClassification.from_pretrained(model_checkpoint)

example = "My name is Sylvain and I work at Hugging Face in Brooklyn."
inputs = tokenizer(example, return_tensors="pt")
outputs = model(**inputs)

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

print(inputs["input_ids"].shape)
print(outputs.logits.shape)
torch.Size([1, 19])
torch.Size([1, 19, 9])

{:else}

ابتدا باید ورودی خود را توکِن‌سازی کنیم و آن را از مدل عبور دهیم. این کار دقیقاً مانند فصل ۲ انجام می‌شود؛ با استفاده از کلاس‌های TFAutoXxx، توکِنایزر و مدل را نمونه‌سازی می‌کنیم و سپس آن‌ها را روی مثال خود به کار می‌بریم:

from transformers import AutoTokenizer, TFAutoModelForTokenClassification

model_checkpoint = "dbmdz/bert-large-cased-finetuned-conll03-english"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
model = TFAutoModelForTokenClassification.from_pretrained(model_checkpoint)

example = "My name is Sylvain and I work at Hugging Face in Brooklyn."
inputs = tokenizer(example, return_tensors="tf")
outputs = model(**inputs)

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

print(inputs["input_ids"].shape)
print(outputs.logits.shape)
(1, 19)
(1, 19, 9)

{/if}

یک بتچ با یک دنباله‌ی ۱۹ توکِنی داریم و مدل ۹ برچسب متفاوت دارد، پس شکل خروجی مدل ۱ × ۱۹ × ۹ است. مانند خط تولید دسته‌بندی متن، از تابع softmax برای تبدیل logitها به احتمال استفاده می‌کنیم و برای گرفتن پیش‌بینی‌ها argmax را می‌گیریم (توجه کنید که می‌توانیم argmax را روی logitها بگیریم، چون softmax ترتیب را تغییر نمی‌دهد):

{#if fw === 'pt'}

import torch

probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)[0].tolist()
predictions = outputs.logits.argmax(dim=-1)[0].tolist()
print(predictions)

{:else}

import tensorflow as tf

probabilities = tf.math.softmax(outputs.logits, axis=-1)[0]
probabilities = probabilities.numpy().tolist()
predictions = tf.math.argmax(outputs.logits, axis=-1)[0]
predictions = predictions.numpy().tolist()
print(predictions)

{/if}

[0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 6, 6, 6, 0, 8, 0, 0]

ویژگی model.config.id2label نگاشتی از اندیس‌ها به برچسب‌ها را در خود دارد که می‌توانیم برای تفسیر پیش‌بینی‌ها از آن استفاده کنیم:

model.config.id2label
{0: 'O',
 1: 'B-MISC',
 2: 'I-MISC',
 3: 'B-PER',
 4: 'I-PER',
 5: 'B-ORG',
 6: 'I-ORG',
 7: 'B-LOC',
 8: 'I-LOC'}

همان‌طور که پیش‌تر دیدیم، ۹ برچسب داریم: O برچسب توکِن‌هایی است که در هیچ موجودیت نام‌داری نیستند (مخفف «outside» به معنای «بیرون» است) و سپس برای هر نوع موجودیت دو برچسب داریم (متفرقه، شخص، سازمان و مکان). برچسب B-XXX نشان می‌دهد توکِن در ابتدای موجودیت XXX قرار دارد و برچسب I-XXX نشان می‌دهد توکِن درون موجودیت XXX است. برای مثال، در نمونه‌ی فعلی انتظار داریم مدل توکِن S را با B-PER (آغاز موجودیت شخص) و توکِن‌های ##yl، ##va و ##in را با I-PER (درون موجودیت شخص) دسته‌بندی کند.

ممکن است فکر کنید مدل در این مورد اشتباه کرده است، چون به هر چهار توکِن برچسب I-PER داده، اما این کاملاً درست نیست. در واقع دو قالب برای برچسب‌های B- و I- وجود دارد: IOB1 و IOB2. قالب IOB2 (که در تصویر زیر به رنگ صورتی نشان داده شده) همان قالبی است که معرفی کردیم، درحالی‌که در قالب IOB1 (به رنگ آبی)، برچسب‌هایی که با B- شروع می‌شوند فقط برای جدا کردن دو موجودیت مجاور از یک نوع استفاده می‌شوند. مدل مورد استفاده‌ی ما روی دیتاستی با همین قالب کوک شده است و به همین دلیل برچسب I-PER را به توکِن S اختصاص می‌دهد.

با این نگاشت، آماده‌ایم نتایج خط تولید اول را (تقریباً به‌طور کامل) بازتولید کنیم — کافی است امتیاز و برچسب هر توکِنی را که با O دسته‌بندی نشده است برداریم:

results = []
tokens = inputs.tokens()

for idx, pred in enumerate(predictions):
    label = model.config.id2label[pred]
    if label != "O":
        results.append(
            {"entity": label, "score": probabilities[idx][pred], "word": tokens[idx]}
        )

print(results)
[{'entity': 'I-PER', 'score': 0.9993828, 'index': 4, 'word': 'S'},
 {'entity': 'I-PER', 'score': 0.99815476, 'index': 5, 'word': '##yl'},
 {'entity': 'I-PER', 'score': 0.99590725, 'index': 6, 'word': '##va'},
 {'entity': 'I-PER', 'score': 0.9992327, 'index': 7, 'word': '##in'},
 {'entity': 'I-ORG', 'score': 0.97389334, 'index': 12, 'word': 'Hu'},
 {'entity': 'I-ORG', 'score': 0.976115, 'index': 13, 'word': '##gging'},
 {'entity': 'I-ORG', 'score': 0.98879766, 'index': 14, 'word': 'Face'},
 {'entity': 'I-LOC', 'score': 0.99321055, 'index': 16, 'word': 'Brooklyn'}]

این خروجی بسیار شبیه نتیجه‌ی قبلی است، با یک تفاوت: خط تولید اطلاعاتی درباره‌ی start و end هر موجودیت در جمله‌ی اصلی نیز به ما داد. اینجاست که نگاشت offset به کار می‌آید. برای به دست آوردن offsetها، کافی است هنگام اعمال توکِنایزر روی ورودی‌ها، return_offsets_mapping=True را تنظیم کنیم:

inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
inputs_with_offsets["offset_mapping"]
[(0, 0), (0, 2), (3, 7), (8, 10), (11, 12), (12, 14), (14, 16), (16, 18), (19, 22), (23, 24), (25, 29), (30, 32),
 (33, 35), (35, 40), (41, 45), (46, 48), (49, 57), (57, 58), (0, 0)]

هر تاپل، بازه‌ی متن مربوط به یک توکِن است و (0, 0) برای توکِن‌های ویژه رزرو شده است. پیش‌تر دیدیم که توکِن اندیس ۵ یعنی ##yl در اینجا offsetهای (12, 14) را دارد. اگر قطعه‌ی متن متناظر را از مثال خود برداریم:

example[12:14]

بازه‌ی درست متن، بدون ##، به دست می‌آید:

yl

با استفاده از این قابلیت، اکنون می‌توانیم نتایج قبلی را کامل کنیم:

results = []
inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
tokens = inputs_with_offsets.tokens()
offsets = inputs_with_offsets["offset_mapping"]

for idx, pred in enumerate(predictions):
    label = model.config.id2label[pred]
    if label != "O":
        start, end = offsets[idx]
        results.append(
            {
                "entity": label,
                "score": probabilities[idx][pred],
                "word": tokens[idx],
                "start": start,
                "end": end,
            }
        )

print(results)
[{'entity': 'I-PER', 'score': 0.9993828, 'index': 4, 'word': 'S', 'start': 11, 'end': 12},
 {'entity': 'I-PER', 'score': 0.99815476, 'index': 5, 'word': '##yl', 'start': 12, 'end': 14},
 {'entity': 'I-PER', 'score': 0.99590725, 'index': 6, 'word': '##va', 'start': 14, 'end': 16},
 {'entity': 'I-PER', 'score': 0.9992327, 'index': 7, 'word': '##in', 'start': 16, 'end': 18},
 {'entity': 'I-ORG', 'score': 0.97389334, 'index': 12, 'word': 'Hu', 'start': 33, 'end': 35},
 {'entity': 'I-ORG', 'score': 0.976115, 'index': 13, 'word': '##gging', 'start': 35, 'end': 40},
 {'entity': 'I-ORG', 'score': 0.98879766, 'index': 14, 'word': 'Face', 'start': 41, 'end': 45},
 {'entity': 'I-LOC', 'score': 0.99321055, 'index': 16, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

این همان نتیجه‌ای است که از خط تولید اول گرفتیم!

گروه‌بندی موجودیت‌ها[[grouping-entities]]

استفاده از offsetها برای تعیین کلیدهای شروع و پایان هر موجودیت مفید است، اما این اطلاعات ضرورتاً لازم نیستند. بااین‌حال، هنگام گروه‌بندی موجودیت‌ها offsetها مقدار زیادی از کدنویسی پیچیده را حذف می‌کنند. برای مثال، اگر بخواهیم توکِن‌های Hu، ##gging و Face را با هم گروه‌بندی کنیم، می‌توانیم قواعد ویژه‌ای بنویسیم که بر اساس آن دو توکِن اول به هم متصل شوند و ## از آن‌ها حذف شود و Face نیز چون با ## شروع نمی‌شود با یک فاصله اضافه شود — اما این قواعد فقط برای همین نوع توکِنایزر کار می‌کنند. برای توکِنایزر SentencePiece یا Byte-Pair-Encoding (که بعداً در این فصل درباره‌شان صحبت می‌کنیم) باید مجموعه‌ی قواعد دیگری بنویسیم.

با offsetها، همه‌ی آن کدهای سفارشی از بین می‌روند: کافی است بازه‌ای از متن اصلی را برداریم که از اولین توکِن شروع می‌شود و به آخرین توکِن ختم می‌شود. بنابراین، در مورد توکِن‌های Hu، ##gging و Face، باید از نویسه‌ی ۳۳ (ابتدای Hu) شروع کنیم و پیش از نویسه‌ی ۴۵ (انتهای Face) پایان دهیم:

example[33:45]
Hugging Face

برای نوشتن کدی که هنگام گروه‌بندی موجودیت‌ها پیش‌بینی‌ها را پس‌پردازش می‌کند، موجودیت‌هایی را که پشت سر هم آمده‌اند و با I-XXX برچسب خورده‌اند در یک گروه قرار می‌دهیم؛ به‌جز نخستین موجودیت که می‌تواند B-XXX یا I-XXX باشد (پس هرگاه به O، نوع جدیدی از موجودیت یا B-XXXای برسیم که آغاز موجودیتی از همان نوع را نشان می‌دهد، گروه‌بندی آن موجودیت را متوقف می‌کنیم):

import numpy as np

results = []
inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
tokens = inputs_with_offsets.tokens()
offsets = inputs_with_offsets["offset_mapping"]

idx = 0
while idx < len(predictions):
    pred = predictions[idx]
    label = model.config.id2label[pred]
    if label != "O":
        # Remove the B- or I-
        label = label[2:]
        start, _ = offsets[idx]

        # Grab all the tokens labeled with I-label
        all_scores = []
        while (
            idx < len(predictions)
            and model.config.id2label[predictions[idx]] == f"I-{label}"
        ):
            all_scores.append(probabilities[idx][pred])
            _, end = offsets[idx]
            idx += 1

        # The score is the mean of all the scores of the tokens in that grouped entity
        score = np.mean(all_scores).item()
        word = example[start:end]
        results.append(
            {
                "entity_group": label,
                "score": score,
                "word": word,
                "start": start,
                "end": end,
            }
        )
    idx += 1

print(results)

و همان نتایج خط تولید دوم را به دست می‌آوریم!

[{'entity_group': 'PER', 'score': 0.9981694, 'word': 'Sylvain', 'start': 11, 'end': 18},
 {'entity_group': 'ORG', 'score': 0.97960204, 'word': 'Hugging Face', 'start': 33, 'end': 45},
 {'entity_group': 'LOC', 'score': 0.99321055, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

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

Xet Storage Details

Size:
30.4 kB
·
Xet hash:
0260afbc6735e77876f33858c91274e11f70594baec20f424dea7860ade2ba14

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