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` را که نخستین بار در [فصل ۱](/course/chapter1) دیدیم، بازتولید کرد.
در بحث پیش‌رو، اغلب بین توکِنایزرهای «کند» و «سریع» تفاوت می‌گذاریم. توکِنایزرهای کند درون کتابخانه‌ی 🤗 Transformers با پایتون نوشته شده‌اند، درحالی‌که نسخه‌های سریع را 🤗 Tokenizers فراهم می‌کند که با Rust نوشته شده‌اند. اگر جدول [فصل ۵](/course/chapter5/3) را به یاد داشته باشید که مدت‌زمان توکِن‌سازی دیتاست مرور دارو را با یک توکِنایزر سریع و کند گزارش می‌کرد، باید ایده‌ای از دلیل این نام‌گذاری داشته باشید:
| | توکِنایزر سریع | توکِنایزر کند
:--------------:|:--------------:|:-------------:
`batched=True` | 10.8s | 4min41s
`batched=False` | 59.2s | 5min3s
> [!WARNING]
> ⚠️ هنگام توکِن‌سازی یک جمله‌ی واحد، همیشه تفاوت سرعتی بین نسخه‌ی سریع و کند یک توکِنایزر یکسان نمی‌بینید. حتی ممکن است نسخه‌ی سریع واقعاً کندتر باشد! تنها وقتی تعداد زیادی متن را هم‌زمان و به‌صورت موازی توکِن‌سازی کنید، تفاوت را به‌وضوح خواهید دید.
## رمزگذاری بتچ[[batch-encoding]]
خروجی یک توکِنایزر، یک دیکشنری ساده‌ی پایتون نیست؛ چیزی که در واقع دریافت می‌کنیم یک شیء ویژه‌ی `BatchEncoding` است. این شیء زیرکلاسی از یک دیکشنری است (به همین دلیل پیش‌تر توانستیم بدون مشکل در نتیجه اندیس‌گذاری کنیم)، اما متدهای اضافی‌ای دارد که بیشتر برای توکِنایزرهای سریع استفاده می‌شوند.
جدا از قابلیت‌های موازی‌سازی، عملکرد اصلی توکِنایزرهای سریع این است که همیشه بازه‌ی اصلی متنی را که توکِن‌های نهایی از آن آمده‌اند دنبال می‌کنند — قابلیتی که آن را *نگاشت offset* می‌نامیم. این قابلیت به نوبه‌ی خود امکاناتی مانند نگاشت هر کلمه به توکِن‌هایی که تولید کرده یا نگاشت هر نویسه از متن اصلی به توکِنی که آن را دربر دارد و برعکس را ممکن می‌کند.
بیایید یک مثال را بررسی کنیم:
```py
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` دریافت می‌کنیم:
```python out
<class 'transformers.tokenization_utils_base.BatchEncoding'>
```
از آنجا که کلاس `AutoTokenizer` به‌صورت پیش‌فرض یک توکِنایزر سریع انتخاب می‌کند، می‌توانیم از متدهای اضافی‌ای که این شیء `BatchEncoding` ارائه می‌دهد استفاده کنیم. برای بررسی سریع یا کند بودن توکِنایزرمان دو راه داریم. می‌توانیم ویژگی `is_fast` مربوط به `tokenizer` را بررسی کنیم:
```python
tokenizer.is_fast
```
```python out
True
```
یا همین ویژگی را در `encoding` بررسی کنیم:
```python
encoding.is_fast
```
```python out
True
```
بیایید ببینیم توکِنایزر سریع چه امکاناتی در اختیار ما می‌گذارد. نخست، می‌توانیم بدون تبدیل شناسه‌ها به توکِن، مستقیماً به توکِن‌ها دسترسی پیدا کنیم:
```py
encoding.tokens()
```
```python out
['[CLS]', 'My', 'name', 'is', 'S', '##yl', '##va', '##in', 'and', 'I', 'work', 'at', 'Hu', '##gging', 'Face', 'in',
'Brooklyn', '.', '[SEP]']
```
در اینجا توکِنِ اندیس ۵ یعنی `##yl` بخشی از کلمه‌ی «Sylvain» در جمله‌ی اصلی است. همچنین می‌توانیم از متد `word_ids()` استفاده کنیم تا اندیس کلمه‌ای را که هر توکِن از آن آمده به دست آوریم:
```py
encoding.word_ids()
```
```python out
[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) استفاده کنیم. همچنین می‌توانیم از آن برای ماسک کردن همه‌ی توکِن‌های متعلق به یک کلمه در مدل‌سازی زبان ماسک‌شده (تکنیکی به نام _ماسک‌گذاری کل کلمه_) استفاده کنیم.
> [!TIP]
> مفهوم «کلمه» پیچیده است. برای مثال، آیا «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` بخشی از کلمه‌ی اندیس ۳ است، اما این کلمه در جمله کدام است؟ می‌توانیم این‌طور متوجه شویم:
```py
start, end = encoding.word_to_chars(3)
example[start:end]
```
```python out
Sylvain
```
همان‌طور که پیش‌تر گفتیم، همه‌ی این قابلیت‌ها به این دلیل ممکن‌اند که توکِنایزر سریع بازه‌ی متنی مربوط به هر توکِن را در فهرستی از *offsetها* دنبال می‌کند. برای نشان دادن کاربرد آن‌ها، در ادامه نحوه‌ی بازتولید دستی نتایج خط تولید `token-classification` را نشان می‌دهیم.
> [!TIP]
> ✏️ **امتحان کنید!** یک متن نمونه‌ی خودتان بسازید و ببینید آیا می‌توانید بفهمید کدام توکِن‌ها به یک شناسه‌ی کلمه مربوط‌اند و چگونه بازه‌های نویسه‌ای یک کلمه‌ی واحد را استخراج کنید. برای امتیاز بیشتر، دو جمله را به‌عنوان ورودی استفاده کنید و ببینید شناسه‌های جمله برایتان منطقی هستند یا نه.
## درون خط تولید `token-classification`[[inside-the-token-classification-pipeline]]
در [فصل ۱](/course/chapter1)، نخستین تجربه‌ی خود را از به‌کارگیری NER داشتیم — وظیفه‌ای که در آن باید مشخص کنیم کدام بخش‌های متن به موجودیت‌هایی مانند افراد، مکان‌ها یا سازمان‌ها مربوط‌اند — و برای این کار از تابع `pipeline()` در 🤗 Transformers استفاده کردیم. سپس در [فصل ۲](/course/chapter2) دیدیم که خط تولید چگونه سه مرحله‌ی لازم برای گرفتن پیش‌بینی از یک متن خام را کنار هم قرار می‌دهد: توکِن‌سازی، عبور دادن ورودی‌ها از مدل و پس‌پردازش. دو مرحله‌ی اول خط تولید `token-classification` مانند هر خط تولید دیگری هستند، اما پس‌پردازش کمی پیچیده‌تر است — بیایید ببینیم چگونه!
{#if fw === 'pt'}
{:else}
{/if}
### به‌دست‌آوردن نتایج پایه با خط تولید[[getting-the-base-results-with-the-pipeline]]
ابتدا یک خط تولید دسته‌بندی توکِن می‌گیریم تا بتوانیم نتایجی برای مقایسه‌ی دستی به دست آوریم. مدل پیش‌فرض [`dbmdz/bert-large-cased-finetuned-conll03-english`](https://huggingface.co/dbmdz/bert-large-cased-finetuned-conll03-english) است؛ این مدل روی جمله‌ها NER انجام می‌دهد:
```py
from transformers import pipeline
token_classifier = pipeline("token-classification")
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")
```
```python out
[{'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» را به‌عنوان یک مکان شناسایی کرد. همچنین می‌توانیم از خط تولید بخواهیم توکِن‌های مربوط به یک موجودیت یکسان را در کنار هم گروه‌بندی کند:
```py
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.")
```
```python out
[{'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'}
ابتدا باید ورودی خود را توکِن‌سازی کنیم و آن را از مدل عبور دهیم. این کار دقیقاً مانند [فصل ۲](/course/chapter2) انجام می‌شود؛ با استفاده از کلاس‌های `AutoXxx`، توکِنایزر و مدل را نمونه‌سازی می‌کنیم و سپس آن‌ها را روی مثال خود به کار می‌بریم:
```py
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 دریافت می‌کنیم:
```py
print(inputs["input_ids"].shape)
print(outputs.logits.shape)
```
```python out
torch.Size([1, 19])
torch.Size([1, 19, 9])
```
{:else}
ابتدا باید ورودی خود را توکِن‌سازی کنیم و آن را از مدل عبور دهیم. این کار دقیقاً مانند [فصل ۲](/course/chapter2) انجام می‌شود؛ با استفاده از کلاس‌های `TFAutoXxx`، توکِنایزر و مدل را نمونه‌سازی می‌کنیم و سپس آن‌ها را روی مثال خود به کار می‌بریم:
```py
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 دریافت می‌کنیم:
```py
print(inputs["input_ids"].shape)
print(outputs.logits.shape)
```
```python out
(1, 19)
(1, 19, 9)
```
{/if}
یک بتچ با یک دنباله‌ی ۱۹ توکِنی داریم و مدل ۹ برچسب متفاوت دارد، پس شکل خروجی مدل ۱ × ۱۹ × ۹ است. مانند خط تولید دسته‌بندی متن، از تابع softmax برای تبدیل logitها به احتمال استفاده می‌کنیم و برای گرفتن پیش‌بینی‌ها argmax را می‌گیریم (توجه کنید که می‌توانیم argmax را روی logitها بگیریم، چون softmax ترتیب را تغییر نمی‌دهد):
{#if fw === 'pt'}
```py
import torch
probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)[0].tolist()
predictions = outputs.logits.argmax(dim=-1)[0].tolist()
print(predictions)
```
{:else}
```py
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}
```python out
[0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 6, 6, 6, 0, 8, 0, 0]
```
ویژگی `model.config.id2label` نگاشتی از اندیس‌ها به برچسب‌ها را در خود دارد که می‌توانیم برای تفسیر پیش‌بینی‌ها از آن استفاده کنیم:
```py
model.config.id2label
```
```python out
{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` دسته‌بندی نشده است برداریم:
```py
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)
```
```python out
[{'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` را تنظیم کنیم:
```py
inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
inputs_with_offsets["offset_mapping"]
```
```python out
[(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)` را دارد. اگر قطعه‌ی متن متناظر را از مثال خود برداریم:
```py
example[12:14]
```
بازه‌ی درست متن، بدون `##`، به دست می‌آید:
```python out
yl
```
با استفاده از این قابلیت، اکنون می‌توانیم نتایج قبلی را کامل کنیم:
```py
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)
```
```python out
[{'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`) پایان دهیم:
```py
example[33:45]
```
```python out
Hugging Face
```
برای نوشتن کدی که هنگام گروه‌بندی موجودیت‌ها پیش‌بینی‌ها را پس‌پردازش می‌کند، موجودیت‌هایی را که پشت سر هم آمده‌اند و با `I-XXX` برچسب خورده‌اند در یک گروه قرار می‌دهیم؛ به‌جز نخستین موجودیت که می‌تواند `B-XXX` یا `I-XXX` باشد (پس هرگاه به `O`، نوع جدیدی از موجودیت یا `B-XXX`ای برسیم که آغاز موجودیتی از همان نوع را نشان می‌دهد، گروه‌بندی آن موجودیت را متوقف می‌کنیم):
```py
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)
```
و همان نتایج خط تولید دوم را به دست می‌آوریم!
```python out
[{'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.