Buckets:

|
download
raw
46.2 kB

وقت برش‌زدن و قسمت‌بندی است[[time-to-slice-and-dice]]

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

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

برش‌زدن و قسمت‌بندی داده‌ها[[slicing-and-dicing-our-data]]

🤗 Datasets، مانند Pandas، چندین تابع برای دست‌کاری محتوای اشیای Dataset و DatasetDict ارائه می‌دهد. پیش‌تر در فصل ۳ با متد Dataset.map() آشنا شدیم و در این بخش برخی از توابع دیگر در اختیارمان را بررسی می‌کنیم.

برای این مثال از دیتاست بررسی دارو استفاده می‌کنیم که در مخزن یادگیری ماشین دانشگاه کالیفرنیا، ارواین میزبانی می‌شود. این دیتاست شامل بررسی‌های بیماران درباره‌ی داروهای مختلف، همراه با بیماریِ تحت درمان و امتیاز رضایت بیمار از ۱ تا ۱۰ است.

ابتدا باید داده‌ها را بارگیری و استخراج کنیم؛ این کار با دستورهای wget و unzip انجام می‌شود:

!wget "https://archive.ics.uci.edu/ml/machine-learning-databases/00462/drugsCom_raw.zip"
!unzip drugsCom_raw.zip

از آنجا که TSV فقط گونه‌ای از CSV است که به‌جای ویرگول از tab به‌عنوان جداکننده استفاده می‌کند، می‌توانیم با استفاده از اسکریپت بارگذاری csv و مشخص کردن آرگومان delimiter در تابع load_dataset() این فایل‌ها را بارگذاری کنیم:

from datasets import load_dataset

data_files = {"train": "drugsComTrain_raw.tsv", "test": "drugsComTest_raw.tsv"}
# \t is the tab character in Python
drug_dataset = load_dataset("csv", data_files=data_files, delimiter="\t")

در هر نوع تحلیل داده، گرفتن یک نمونه‌ی تصادفی کوچک برای به‌دست‌آوردن درکی سریع از نوع داده‌ای که با آن کار می‌کنید، روش خوبی است. در 🤗 Datasets می‌توانیم با زنجیره کردن توابع Dataset.shuffle() و Dataset.select() یک نمونه‌ی تصادفی بسازیم:

drug_sample = drug_dataset["train"].shuffle(seed=42).select(range(1000))
# Peek at the first few examples
drug_sample[:3]
{'Unnamed: 0': [87571, 178045, 80482],
 'drugName': ['Naproxen', 'Duloxetine', 'Mobic'],
 'condition': ['Gout, Acute', 'ibromyalgia', 'Inflammatory Conditions'],
 'review': ['"like the previous person mention, I&#039;m a strong believer of aleve, it works faster for my gout than the prescription meds I take. No more going to the doctor for refills.....Aleve works!"',
  '"I have taken Cymbalta for about a year and a half for fibromyalgia pain. It is great\r\nas a pain reducer and an anti-depressant, however, the side effects outweighed \r\nany benefit I got from it. I had trouble with restlessness, being tired constantly,\r\ndizziness, dry mouth, numbness and tingling in my feet, and horrible sweating. I am\r\nbeing weaned off of it now. Went from 60 mg to 30mg and now to 15 mg. I will be\r\noff completely in about a week. The fibro pain is coming back, but I would rather deal with it than the side effects."',
  '"I have been taking Mobic for over a year with no side effects other than an elevated blood pressure.  I had severe knee and ankle pain which completely went away after taking Mobic.  I attempted to stop the medication however pain returned after a few days."'],
 'rating': [9.0, 3.0, 10.0],
 'date': ['September 2, 2015', 'November 7, 2011', 'June 5, 2013'],
 'usefulCount': [36, 13, 128]}

توجه کنید که برای بازتولیدپذیری، seed را در Dataset.shuffle() ثابت کرده‌ایم. Dataset.select() یک iterable از اندیس‌ها می‌خواهد، بنابراین range(1000) را برای گرفتن ۱۰۰۰ نمونه‌ی نخست از دیتاست shuffled به آن داده‌ایم. از این نمونه می‌توانیم چند ویژگی عجیب دیتاست را ببینیم:

  • ستون Unnamed: 0 به‌طور مشکوکی شبیه یک شناسه‌ی ناشناس برای هر بیمار است.
  • ستون condition ترکیبی از برچسب‌های حروف‌بزرگ و حروف‌کوچک دارد.
  • طول بررسی‌ها متفاوت است و علاوه بر جداکننده‌های خط پایتون (\r\n)، ترکیبی از کدهای نویسه‌ی HTML مانند &\#039; را نیز دارند.

بیایید ببینیم چگونه می‌توانیم با استفاده از 🤗 Datasets با هر یک از این مشکلات برخورد کنیم. برای آزمودن فرضیه‌ی شناسه‌ی بیمار درباره‌ی ستون Unnamed: 0، می‌توانیم از تابع Dataset.unique() استفاده کنیم تا ببینیم تعداد شناسه‌ها با تعداد ردیف‌ها در هر split برابر است یا نه:

for split in drug_dataset.keys():
    assert len(drug_dataset[split]) == len(drug_dataset[split].unique("Unnamed: 0"))

این موضوع ظاهراً فرضیه‌ی ما را تأیید می‌کند، پس بیایید با تغییر نام ستون Unnamed: 0 به نامی قابل‌فهم‌تر، دیتاست را کمی پاک‌سازی کنیم. می‌توانیم از تابع DatasetDict.rename_column() استفاده کنیم تا ستون را در هر دو split یک‌جا تغییر نام دهیم:

drug_dataset = drug_dataset.rename_column(
    original_column_name="Unnamed: 0", new_column_name="patient_id"
)
drug_dataset
DatasetDict({
    train: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount'],
        num_rows: 161297
    })
    test: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount'],
        num_rows: 53766
    })
})

✏️ امتحان کنید! با استفاده از تابع Dataset.unique() تعداد داروها و conditionهای یکتای مجموعه‌های تعلیم و آزمون را پیدا کنید.

حالا بیایید همه‌ی برچسب‌های condition را با استفاده از Dataset.map() نرمال کنیم. همان‌طور که در فصل ۳ برای توکِنایز کردن انجام دادیم، می‌توانیم تابع ساده‌ای تعریف کنیم که روی همه‌ی ردیف‌های هر split در drug_dataset اعمال شود:

def lowercase_condition(example):
    return {"condition": example["condition"].lower()}

drug_dataset.map(lowercase_condition)
AttributeError: 'NoneType' object has no attribute 'lower'

ای وای، تابع map ما با مشکل روبه‌رو شد! از خطا می‌توانیم بفهمیم بعضی از ورودی‌های ستون condition مقدار None دارند و چون رشته نیستند، نمی‌توان آن‌ها را به حروف کوچک تبدیل کرد. بیایید با استفاده از Dataset.filter() این ردیف‌ها را حذف کنیم؛ این تابع مانند Dataset.map() کار می‌کند و تابعی می‌خواهد که یک نمونه‌ی منفرد از دیتاست را دریافت کند. به‌جای نوشتن تابعی صریح مانند:

def filter_nones(x):
    return x["condition"] is not None

و سپس اجرای drug_dataset.filter(filter_nones)، می‌توانیم این کار را در یک خط با استفاده از تابع lambda انجام دهیم. توابع lambda توابع کوچکی در پایتون هستند که می‌توانید بدون نام‌گذاری صریح تعریفشان کنید. شکل کلی آن‌ها چنین است:

lambda <arguments> : <expression>

که در آن lambda یکی از کلیدواژه‌های ویژه‌ی پایتون است، <arguments> فهرستی/مجموعه‌ای از مقادیر جداشده با ویرگول است که ورودی‌های تابع را تعریف می‌کند و <expression> عملیاتی را نشان می‌دهد که می‌خواهید انجام دهید. برای مثال، می‌توانیم یک تابع lambda ساده تعریف کنیم که عددی را به توان دو برساند:

lambda x : x * x

برای اعمال این تابع روی یک ورودی، باید خود تابع و ورودی را داخل پرانتز قرار دهیم:

(lambda x: x * x)(3)
9

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

(lambda base, height: 0.5 * base * height)(4, 8)
16.0

توابع lambda زمانی مفیدند که بخواهید توابع کوچک و یک‌بارمصرف تعریف کنید (برای اطلاعات بیشتر درباره‌ی آن‌ها، مطالعه‌ی آموزش عالی Real Python نوشته‌ی Andre Burgaud را پیشنهاد می‌کنیم). در زمینه‌ی 🤗 Datasets، می‌توانیم از توابع lambda برای تعریف عملیات ساده‌ی map و filter استفاده کنیم؛ پس از این ترفند برای حذف ورودی‌های None از دیتاست خود استفاده می‌کنیم:

drug_dataset = drug_dataset.filter(lambda x: x["condition"] is not None)

حالا که ورودی‌های None حذف شده‌اند، می‌توانیم ستون condition را نرمال کنیم:

drug_dataset = drug_dataset.map(lowercase_condition)
# Check that lowercasing worked
drug_dataset["train"]["condition"][:3]
['left ventricular dysfunction', 'adhd', 'birth control']

کار می‌کند! حالا که برچسب‌ها را پاک‌سازی کرده‌ایم، بیایید به سراغ پاک‌سازی خود بررسی‌ها برویم.

ساختن ستون‌های جدید[[creating-new-columns]]

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

بیایید تابع ساده‌ای تعریف کنیم که تعداد کلمات هر بررسی را بشمارد:

def compute_review_length(example):
    return {"review_length": len(example["review"].split())}

برخلاف تابع lowercase_condition()، تابع compute_review_length() دیکشنری‌ای برمی‌گرداند که کلید آن با یکی از نام‌های ستون‌های دیتاست مطابقت ندارد. در این حالت، وقتی compute_review_length() به Dataset.map() داده شود، روی همه‌ی ردیف‌های دیتاست اعمال می‌شود تا ستون جدید review_length ایجاد شود:

drug_dataset = drug_dataset.map(compute_review_length)
# Inspect the first training example
drug_dataset["train"][0]
{'patient_id': 206461,
 'drugName': 'Valsartan',
 'condition': 'left ventricular dysfunction',
 'review': '"It has no side effect, I take it in combination of Bystolic 5 Mg and Fish Oil"',
 'rating': 9.0,
 'date': 'May 20, 2012',
 'usefulCount': 27,
 'review_length': 17}

همان‌طور که انتظار داشتیم، می‌بینیم ستون review_length به مجموعه‌ی تعلیم ما اضافه شده است. می‌توانیم این ستون جدید را با Dataset.sort() مرتب کنیم تا مقادیر افراطی را ببینیم:

drug_dataset["train"].sort("review_length")[:3]
{'patient_id': [103488, 23627, 20558],
 'drugName': ['Loestrin 21 1 / 20', 'Chlorzoxazone', 'Nucynta'],
 'condition': ['birth control', 'muscle spasm', 'pain'],
 'review': ['"Excellent."', '"useless"', '"ok"'],
 'rating': [10.0, 1.0, 6.0],
 'date': ['November 4, 2008', 'March 24, 2017', 'August 20, 2016'],
 'usefulCount': [5, 2, 10],
 'review_length': [1, 1, 1]}

همان‌طور که حدس می‌زدیم، بعضی بررسی‌ها فقط یک کلمه دارند؛ این مقدار شاید برای تحلیل احساسات مناسب باشد، اما اگر بخواهیم condition را پیش‌بینی کنیم، اطلاعات کافی ارائه نمی‌کند.

🙋 راه دیگری برای افزودن ستون‌های جدید به دیتاست، استفاده از تابع Dataset.add_column() است. این تابع به شما اجازه می‌دهد ستون را به شکل یک فهرست پایتون یا آرایه‌ی NumPy بدهید و در شرایطی که Dataset.map() برای تحلیل شما مناسب نیست، می‌تواند مفید باشد.

بیایید با استفاده از تابع Dataset.filter() بررسی‌هایی را که کمتر از ۳۰ کلمه دارند حذف کنیم. مانند کاری که با ستون condition انجام دادیم، می‌توانیم با الزام طول بیشتر از این آستانه، بررسی‌های بسیار کوتاه را فیلتر کنیم:

drug_dataset = drug_dataset.filter(lambda x: x["review_length"] > 30)
print(drug_dataset.num_rows)
{'train': 138514, 'test': 46108}

همان‌طور که می‌بینید، این کار حدود ۱۵٪ از بررسی‌های مجموعه‌های تعلیم و آزمون اولیه را حذف کرده است.

✏️ امتحان کنید! با استفاده از تابع Dataset.sort() بررسی‌هایی را که بیشترین تعداد کلمه را دارند بررسی کنید. برای دیدن آرگومان لازم جهت مرتب‌سازی بررسی‌ها بر اساس طول به‌صورت نزولی، مستندات را ببینید.

آخرین مسئله‌ای که باید حل کنیم، وجود کدهای نویسه‌ی HTML در بررسی‌هاست. می‌توانیم از ماژول html پایتون برای unescape کردن این نویسه‌ها استفاده کنیم:

import html

text = "I&#039;m a transformer called BERT"
html.unescape(text)
"I'm a transformer called BERT"

از Dataset.map() برای unescape کردن همه‌ی نویسه‌های HTML در مجموعه‌ی خود استفاده می‌کنیم:

drug_dataset = drug_dataset.map(lambda x: {"review": html.unescape(x["review"])})

همان‌طور که می‌بینید، متد Dataset.map() برای پردازش داده بسیار مفید است — و هنوز حتی سطح توانایی‌های آن را لمس نکرده‌ایم!

ابرقدرت‌های متد map()[[the-map-methods-superpowers]]

متد Dataset.map() آرگومانی به نام batched دارد که اگر روی True تنظیم شود، باعث می‌شود هم‌زمان یک بتچ از نمونه‌ها را به تابع map ارسال کند (اندازه‌ی بتچ قابل تنظیم است، اما مقدار پیش‌فرض آن ۱۰۰۰ است). برای نمونه، اجرای تابع map قبلی که همه‌ی HTMLها را unescape می‌کرد کمی زمان برد (زمان اجرا را می‌توانید از نوارهای پیشرفت بخوانید). با پردازش هم‌زمان چندین عنصر و استفاده از list comprehension می‌توانیم این کار را سریع‌تر کنیم.

وقتی batched=True را مشخص می‌کنید، تابع یک دیکشنری شامل فیلدهای دیتاست دریافت می‌کند، اما مقدار هر فیلد اکنون فهرستی از مقادیر است، نه فقط یک مقدار. مقدار برگشتی Dataset.map() نیز باید همین شکل را داشته باشد: دیکشنری‌ای با فیلدهایی که می‌خواهیم در دیتاست به‌روزرسانی یا اضافه کنیم، و یک فهرست از مقادیر. برای مثال، راه دیگری برای unescape کردن همه‌ی نویسه‌های HTML با استفاده از batched=True چنین است:

new_drug_dataset = drug_dataset.map(
    lambda x: {"review": [html.unescape(o) for o in x["review"]]}, batched=True
)

اگر این کد را در یک نوت‌بوک اجرا کنید، می‌بینید این دستور بسیار سریع‌تر از دستور قبلی اجرا می‌شود. دلیلش این نیست که بررسی‌های ما از قبل unescape شده‌اند — اگر دستور بخش قبل را دوباره اجرا کنید (بدون batched=True)، همان مقدار زمان قبلی طول می‌کشد. علت این است که list comprehension معمولاً از اجرای همان کد در یک حلقه‌ی for سریع‌تر است و با دسترسی هم‌زمان به عناصر متعدد، به‌جای یکی‌یکی، عملکرد بیشتری نیز به دست می‌آوریم.

استفاده از Dataset.map() با batched=True برای بهره‌گیری از سرعت توکِنایزرهای «سریع» که در فصل ۶ با آن‌ها آشنا می‌شویم ضروری است؛ این توکِنایزرها می‌توانند فهرست‌های بزرگی از متن را به‌سرعت توکِنایز کنند. برای مثال، برای توکِنایز کردن همه‌ی بررسی‌های دارو با یک توکِنایزر سریع، می‌توانیم از تابعی مانند زیر استفاده کنیم:

from transformers import AutoTokenizer

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

def tokenize_function(examples):
    return tokenizer(examples["review"], truncation=True)

همان‌طور که در فصل ۳ دیدید، می‌توانیم یک یا چند نمونه را به توکِنایزر بدهیم؛ بنابراین می‌توانیم از این تابع با یا بدون batched=True استفاده کنیم. از این فرصت استفاده می‌کنیم تا عملکرد گزینه‌های مختلف را با هم مقایسه کنیم. در یک نوت‌بوک، با اضافه کردن %time پیش از خط کدی که می‌خواهید اندازه‌گیری کنید، می‌توانید زمان اجرای یک دستور تک‌خطی را بگیرید:

%time tokenized_dataset = drug_dataset.map(tokenize_function, batched=True)

همچنین می‌توانید با قرار دادن %%time در ابتدای سلول، زمان اجرای یک سلول کامل را اندازه بگیرید. روی سخت‌افزاری که ما این کد را اجرا کردیم، زمان این دستور ۱۰٫۸ ثانیه بود (عددی که بعد از «Wall time» نوشته می‌شود).

✏️ امتحان کنید! همین دستور را با و بدون batched=True اجرا کنید، سپس آن را با یک توکِنایزر کند امتحان کنید (در متد AutoTokenizer.from_pretrained() مقدار use_fast=False را اضافه کنید) تا ببینید روی سخت‌افزار خود چه اعدادی به دست می‌آورید.

نتایجی که با و بدون batching و با توکِنایزر سریع و کند به دست آوردیم:

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

این یعنی استفاده از یک توکِنایزر سریع با گزینه‌ی batched=True، ۳۰ برابر سریع‌تر از توکِنایزر کند آن هم بدون batching است — واقعاً شگفت‌انگیز است! دلیل اصلی پیش‌فرض بودن توکِنایزرهای سریع هنگام استفاده از AutoTokenizer (و دلیل نام‌گذاری آن‌ها با عنوان «سریع») همین است. این توکِنایزرها به این سرعت می‌رسند چون کد توکِنایز کردن در پشت صحنه با Rust اجرا می‌شود؛ زبانی که موازی‌سازی اجرای کد در آن آسان است.

موازی‌سازی همچنین دلیل سرعت تقریباً ۶ برابری توکِنایزر سریع هنگام batching است: نمی‌توان یک عملیات توکِنایز کردن منفرد را موازی کرد، اما وقتی می‌خواهید متن‌های زیادی را هم‌زمان توکِنایز کنید، می‌توانید اجرا را بین چند فرایند تقسیم کنید که هر کدام مسئول متن‌های خود هستند.

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

slow_tokenizer = AutoTokenizer.from_pretrained("bert-base-cased", use_fast=False)

def slow_tokenize_function(examples):
    return slow_tokenizer(examples["review"], truncation=True)

tokenized_dataset = drug_dataset.map(slow_tokenize_function, batched=True, num_proc=8)

می‌توانید با اندازه‌گیری زمان، تعداد بهینه‌ی فرایندها را پیدا کنید؛ در مورد ما، ۸ فرایند بهترین افزایش سرعت را ایجاد کرد. اعدادی که با و بدون چندپردازشی به دست آوردیم:

گزینه‌ها توکِنایزر سریع توکِنایزر کند
batched=True 10.8s 4min41s
batched=False 59.2s 5min3s
batched=True, num_proc=8 6.52s 41.3s
batched=False, num_proc=8 9.49s 45.2s

این نتایج برای توکِنایزر کند بسیار منطقی‌ترند، اما عملکرد توکِنایزر سریع نیز به‌طور چشمگیری بهتر شده است. بااین‌حال توجه کنید که همیشه چنین نخواهد بود — در آزمایش‌های ما، برای مقادیر num_proc غیر از ۸، استفاده از batched=True بدون این گزینه سریع‌تر بود. به‌طور کلی، استفاده از چندپردازشی پایتون را برای توکِنایزرهای سریع با batched=True توصیه نمی‌کنیم.

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

تمام این قابلیت‌ها که در یک متد جمع شده‌اند، به‌تنهایی شگفت‌انگیزند، اما امکانات بیشتری هم وجود دارد! با Dataset.map() و batched=True می‌توانید تعداد عناصر دیتاست را تغییر دهید. این قابلیت در موقعیت‌های زیادی مفید است؛ مثلاً وقتی می‌خواهید از یک نمونه چندین ویژگی تعلیم بسازید. همچنین در پیش‌پردازش چندین وظیفه‌ی NLP که در فصل ۷ انجام خواهیم داد، به آن نیاز داریم.

💡 در یادگیری ماشین، نمونه معمولاً مجموعه‌ای از ویژگی‌ها تعریف می‌شود که به مدل می‌دهیم. در برخی زمینه‌ها، این ویژگی‌ها همان مجموعه‌ی ستون‌های یک Dataset هستند، اما در زمینه‌های دیگر (مانند اینجا و پاسخ‌گویی به پرسش)، می‌توان چند ویژگی را از یک نمونه استخراج کرد که به یک ستون تعلق دارند.

بیایید ببینیم این قابلیت چگونه کار می‌کند! در اینجا نمونه‌های خود را توکِنایز و آن‌ها را به حداکثر طول ۱۲۸ کوتاه می‌کنیم، اما از توکِنایزر می‌خواهیم همه‌ی بخش‌های متن را برگرداند، نه فقط بخش اول را. این کار با return_overflowing_tokens=True انجام می‌شود:

def tokenize_and_split(examples):
    return tokenizer(
        examples["review"],
        truncation=True,
        max_length=128,
        return_overflowing_tokens=True,
    )

پیش از استفاده از Dataset.map() روی کل دیتاست، این را روی یک نمونه آزمایش کنیم:

result = tokenize_and_split(drug_dataset["train"][0])
[len(inp) for inp in result["input_ids"]]
[128, 49]

بنابراین نخستین نمونه‌ی مجموعه‌ی تعلیم ما به دو ویژگی تبدیل شد، چون به بیش از حداکثر تعداد توکِن‌هایی که مشخص کرده بودیم توکِنایز شد: اولی با طول ۱۲۸ و دومی با طول ۴۹. حالا این کار را برای همه‌ی عناصر دیتاست انجام دهیم!

tokenized_dataset = drug_dataset.map(tokenize_and_split, batched=True)
ArrowInvalid: Column 1 named condition expected length 1463 but got length 1000

ای وای! این کار موفق نشد! چرا؟ پیام خطا سرنخی به ما می‌دهد: طول یکی از ستون‌ها با دیگری متفاوت است؛ یکی طول ۱٬۴۶۳ و دیگری طول ۱٬۰۰۰ دارد. اگر مستندات Dataset.map() را دیده باشید، شاید به یاد داشته باشید که تعداد نمونه‌هایی که به تابع می‌دهیم، همان تعداد نمونه‌هایی است که map می‌شوند؛ در اینجا آن ۱۰۰۰ نمونه، ۱٬۴۶۳ ویژگی جدید ایجاد کرده‌اند و در نتیجه خطای شکل به وجود آمده است.

مشکل این است که داریم دو دیتاست با اندازه‌های متفاوت را با هم ترکیب می‌کنیم: ستون‌های drug_dataset تعداد مشخصی نمونه دارند (۱۰۰۰ نمونه در خطای ما)، اما tokenized_dataset که می‌سازیم تعداد بیشتری دارد (۱٬۴۶۳ نمونه در پیام خطا؛ این تعداد از ۱۰۰۰ بیشتر است چون با استفاده از return_overflowing_tokens=True بررسی‌های طولانی را به چند نمونه توکِنایزشده تبدیل می‌کنیم). این کار برای یک Dataset ممکن نیست، پس باید یا ستون‌های دیتاست قدیمی را حذف کنیم یا اندازه‌ی آن‌ها را با دیتاست جدید برابر کنیم. گزینه‌ی اول را می‌توان با آرگومان remove_columns انجام داد:

tokenized_dataset = drug_dataset.map(
    tokenize_and_split, batched=True, remove_columns=drug_dataset["train"].column_names
)

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

len(tokenized_dataset["train"]), len(drug_dataset["train"])
(206772, 138514)

گفتیم که می‌توانیم مشکل طول‌های متفاوت را با برابر کردن اندازه‌ی ستون‌های قدیمی با ستون‌های جدید نیز حل کنیم. برای این کار به فیلد overflow_to_sample_mapping نیاز داریم که توکِنایزر هنگام تنظیم return_overflowing_tokens=True برمی‌گرداند. این فیلد نگاشتی از اندیس یک ویژگی جدید به اندیس نمونه‌ای که ویژگی از آن ساخته شده است ارائه می‌دهد. با استفاده از آن، می‌توانیم هر کلید موجود در دیتاست اصلی را به فهرستی از مقادیر با اندازه‌ی درست مرتبط کنیم؛ برای این کار مقادیر هر نمونه را به تعداد ویژگی‌های جدیدی که تولید می‌کند تکرار می‌کنیم:

def tokenize_and_split(examples):
    result = tokenizer(
        examples["review"],
        truncation=True,
        max_length=128,
        return_overflowing_tokens=True,
    )
    # Extract mapping between new and old indices
    sample_map = result.pop("overflow_to_sample_mapping")
    for key, values in examples.items():
        result[key] = [values[i] for i in sample_map]
    return result

می‌بینیم که این روش با Dataset.map() کار می‌کند و لازم نیست ستون‌های قدیمی را حذف کنیم:

tokenized_dataset = drug_dataset.map(tokenize_and_split, batched=True)
tokenized_dataset
DatasetDict({
    train: Dataset({
        features: ['attention_mask', 'condition', 'date', 'drugName', 'input_ids', 'patient_id', 'rating', 'review', 'review_length', 'token_type_ids', 'usefulCount'],
        num_rows: 206772
    })
    test: Dataset({
        features: ['attention_mask', 'condition', 'date', 'drugName', 'input_ids', 'patient_id', 'rating', 'review', 'review_length', 'token_type_ids', 'usefulCount'],
        num_rows: 68876
    })
})

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

اکنون دیدید که چگونه می‌توان از 🤗 Datasets برای پیش‌پردازش دیتاست به روش‌های مختلف استفاده کرد. اگرچه توابع پردازش 🤗 Datasets بیشتر نیازهای تعلیم مدل شما را پوشش می‌دهند، گاهی لازم است برای دسترسی به قابلیت‌های قدرتمندتر، مانند DataFrame.groupby() یا APIهای سطح‌بالای مصورسازی، به Pandas روی بیاورید. خوشبختانه 🤗 Datasets برای همکاری با کتابخانه‌هایی مانند Pandas، NumPy، PyTorch، TensorFlow و JAX طراحی شده است. بیایید ببینیم این کار چگونه انجام می‌شود.

از Datasetها به DataFrameها و برعکس[[from-datasets-to-dataframes-and-back]]

برای فعال کردن تبدیل بین کتابخانه‌های مختلف شخص ثالث، 🤗 Datasets تابع Dataset.set_format() را ارائه می‌دهد. این تابع فقط قالب خروجی دیتاست را تغییر می‌دهد، بنابراین می‌توانید به‌سادگی به قالب دیگری جابه‌جا شوید، بدون اینکه قالب داده‌ی زیربنایی، یعنی Apache Arrow، تغییر کند. قالب‌بندی درجا انجام می‌شود. برای نمایش این موضوع، دیتاست خود را به Pandas تبدیل می‌کنیم:

drug_dataset.set_format("pandas")

وقتی اکنون به عناصر دیتاست دسترسی پیدا می‌کنیم، به‌جای دیکشنری یک pandas.DataFrame دریافت می‌کنیم:

drug_dataset["train"][:3]
  patient_id
  drugName
  condition
  review
  rating
  date
  usefulCount
  review_length




  0
  95260
  Guanfacine
  adhd
  "My son is halfway through his fourth week of Intuniv..."
  8.0
  April 27, 2010
  192
  141


  1
  92703
  Lybrel
  birth control
  "I used to take another oral contraceptive, which had 21 pill cycle, and was very happy- very light periods, max 5 days, no other side effects..."
  5.0
  December 14, 2009
  17
  134


  2
  138000
  Ortho Evra
  birth control
  "This is my first time using any form of birth control..."
  8.0
  November 3, 2015
  10
  89

بیایید با انتخاب همه‌ی عناصر drug_dataset["train"] یک pandas.DataFrame برای کل مجموعه‌ی تعلیم بسازیم:

train_df = drug_dataset["train"][:]

🚨 در پشت صحنه، Dataset.set_format() قالب خروجی متد ویژه‌ی __getitem__() دیتاست را تغییر می‌دهد. یعنی وقتی می‌خواهیم شیء جدیدی مانند train_df را از یک Dataset با قالب "pandas" بسازیم، باید کل دیتاست را برش بزنیم تا یک pandas.DataFrame به دست آوریم. برای اطمینان می‌توانید بررسی کنید که نوع drug_dataset["train"] بدون توجه به قالب خروجی، Dataset است.

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

frequencies = (
    train_df["condition"]
    .value_counts()
    .to_frame()
    .reset_index()
    .rename(columns={"index": "condition", "count": "frequency"})
)
frequencies.head()
  condition
  frequency




  0
  birth control
  27655


  1
  depression
  8023


  2
  acne
  5209


  3
  anxiety
  4991


  4
  pain
  4744

پس از پایان تحلیل Pandas، همیشه می‌توانیم با استفاده از تابع Dataset.from_pandas() یک شیء Dataset جدید بسازیم:

from datasets import Dataset

freq_dataset = Dataset.from_pandas(frequencies)
freq_dataset
Dataset({
    features: ['condition', 'frequency'],
    num_rows: 819
})

✏️ امتحان کنید! میانگین امتیاز هر دارو را محاسبه و نتیجه را در یک Dataset جدید ذخیره کنید.

این پایان گشت‌وگذار ما در تکنیک‌های مختلف پیش‌پردازش موجود در 🤗 Datasets است. برای تکمیل این بخش، بیایید یک مجموعه‌ی اعتبارسنجی بسازیم تا دیتاست را برای تعلیم یک دسته‌بند آماده کنیم. پیش از این کار، قالب خروجی drug_dataset را از "pandas" به "arrow" بازنشانی می‌کنیم:

drug_dataset.reset_format()

ساختن یک مجموعه‌ی اعتبارسنجی[[creating-a-validation-set]]

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

🤗 Datasets تابع Dataset.train_test_split() را ارائه می‌دهد که بر پایه‌ی قابلیت معروف scikit-learn ساخته شده است. بیایید مجموعه‌ی تعلیم خود را به بخش‌های train و validation تقسیم کنیم (برای بازتولیدپذیری آرگومان seed را تنظیم می‌کنیم):

drug_dataset_clean = drug_dataset["train"].train_test_split(train_size=0.8, seed=42)
# Rename the default "test" split to "validation"
drug_dataset_clean["validation"] = drug_dataset_clean.pop("test")
# Add the "test" set to our `DatasetDict`
drug_dataset_clean["test"] = drug_dataset["test"]
drug_dataset_clean
DatasetDict({
    train: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length', 'review_clean'],
        num_rows: 110811
    })
    validation: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length', 'review_clean'],
        num_rows: 27703
    })
    test: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length', 'review_clean'],
        num_rows: 46108
    })
})

عالی است، اکنون دیتاستی آماده برای تعلیم چند مدل داریم! در بخش ۵ نشان می‌دهیم چگونه دیتاست‌ها را در هاب هاگینگ‌فِیس بارگذاری کنید، اما فعلاً تحلیل خود را با بررسی چند روش ذخیره‌سازی دیتاست‌ها روی ماشین محلی به پایان می‌رسانیم.

ذخیره‌سازی یک دیتاست[[saving-a-dataset]]

اگرچه 🤗 Datasets هر دیتاست بارگیری‌شده و عملیات انجام‌شده روی آن را cache می‌کند، گاهی لازم است دیتاستی را روی دیسک ذخیره کنید (مثلاً اگر cache حذف شود). همان‌طور که در جدول زیر می‌بینید، 🤗 Datasets سه تابع اصلی برای ذخیره‌سازی دیتاست در قالب‌های مختلف ارائه می‌دهد:

قالب داده تابع
Arrow Dataset.save_to_disk()
CSV Dataset.to_csv()
JSON Dataset.to_json()

برای مثال، بیایید دیتاست پاک‌سازی‌شده‌ی خود را در قالب Arrow ذخیره کنیم:

drug_dataset_clean.save_to_disk("drug-reviews")

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

drug-reviews/
├── dataset_dict.json
├── test
│   ├── dataset.arrow
│   ├── dataset_info.json
│   └── state.json
├── train
│   ├── dataset.arrow
│   ├── dataset_info.json
│   ├── indices.arrow
│   └── state.json
└── validation
    ├── dataset.arrow
    ├── dataset_info.json
    ├── indices.arrow
    └── state.json

در این ساختار می‌بینیم که هر split جدول dataset.arrow مخصوص خود را دارد و بخشی از فراداده نیز در dataset_info.json و state.json ذخیره شده است. می‌توانید قالب Arrow را جدولی پیشرفته از ستون‌ها و ردیف‌ها در نظر بگیرید که برای ساخت برنامه‌های پربازده جهت پردازش و انتقال دیتاست‌های بزرگ بهینه شده است.

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

from datasets import load_from_disk

drug_dataset_reloaded = load_from_disk("drug-reviews")
drug_dataset_reloaded
DatasetDict({
    train: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length'],
        num_rows: 110811
    })
    validation: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length'],
        num_rows: 27703
    })
    test: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length'],
        num_rows: 46108
    })
})

برای قالب‌های CSV و JSON، باید هر split را در یک فایل جداگانه ذخیره کنیم. یکی از راه‌ها، پیمایش کلیدها و مقادیر شیء DatasetDict است:

for split, dataset in drug_dataset_clean.items():
    dataset.to_json(f"drug-reviews-{split}.jsonl")

این کار هر split را در قالب JSON Lines ذخیره می‌کند؛ در این قالب هر ردیف دیتاست به‌صورت یک خط JSON ذخیره می‌شود. نمونه‌ی نخست به شکل زیر است:

!head -n 1 drug-reviews-train.jsonl
{"patient_id":141780,"drugName":"Escitalopram","condition":"depression","review":"\"I seemed to experience the regular side effects of LEXAPRO, insomnia, low sex drive, sleepiness during the day. I am taking it at night because my doctor said if it made me tired to take it at night. I assumed it would and started out taking it at night. Strange dreams, some pleasant. I was diagnosed with fibromyalgia. Seems to be helping with the pain. Have had anxiety and depression in my family, and have tried quite a few other medications that haven't worked. Only have been on it for two weeks but feel more positive in my mind, want to accomplish more in my life. Hopefully the side effects will dwindle away, worth it to stick with it from hearing others responses. Great medication.\"","rating":9.0,"date":"May 29, 2011","usefulCount":10,"review_length":125}

سپس می‌توانیم از تکنیک‌های بخش ۲ برای بارگذاری فایل‌های JSON استفاده کنیم:

data_files = {
    "train": "drug-reviews-train.jsonl",
    "validation": "drug-reviews-validation.jsonl",
    "test": "drug-reviews-test.jsonl",
}
drug_dataset_reloaded = load_dataset("json", data_files=data_files)

و این پایان گشت‌وگذار ما در سامان‌دهی داده با 🤗 Datasets است! حالا که دیتاست پاک‌سازی‌شده‌ای برای تعلیم مدل داریم، چند ایده وجود دارد که می‌توانید امتحان کنید:

  1. از تکنیک‌های فصل ۳ برای تعلیم یک دسته‌بند استفاده کنید که بتواند بیماری بیمار را بر اساس بررسی دارو پیش‌بینی کند.
  2. از خط تولید summarization در فصل ۱ برای تولید خلاصه‌ی بررسی‌ها استفاده کنید.

در ادامه، بررسی می‌کنیم که چگونه 🤗 Datasets به شما اجازه می‌دهد با دیتاست‌های بسیار بزرگ کار کنید، بدون اینکه RAM لپ‌تاپتان را پر کنید!

Xet Storage Details

Size:
46.2 kB
·
Xet hash:
49ac43d639e1d8b1d64f796f09fd314bae6eb71f99ee050efbc93c9f28277e14

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