course/pr_1152/te/chapter3/2.md

డేటా సిద్ధం చేయడం[[processing-the-data]]

ముందు అధ్యాయంలో చూపిన ఉదాహరణనే కొనసాగిస్తూ, ఒకే బ్యాచ్‌పై సీక్వెన్స్ క్లాసిఫైయర్‌ను ఎలా శిక్షణ ఇస్తామో ఇక్కడ చూద్దాం:

import torch
from torch.optim import AdamW
from transformers import AutoTokenizer, AutoModelForSequenceClassification

# Same as before
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequences = [
    "I've been waiting for a HuggingFace course my whole life.",
    "This course is amazing!",
]

batch = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")

# This is new
batch["labels"] = torch.tensor([1, 1])

optimizer = AdamW(model.parameters())
loss = model(**batch).loss
loss.backward()
optimizer.step()

సహజంగానే, కేవలం రెండు వాక్యాలతో మోడల్ శిక్షణ ఇస్తే మంచి ఫలితాలు రావు. మంచి ఫలితాలు కావాలంటే పెద్ద డేటాసెట్ సిద్ధం చేయాలి.

ఈ సెక్షన్‌లో ఉదాహరణగా MRPC (Microsoft Research Paraphrase Corpus) డేటాసెట్ తీసుకుంటాం. ఈ డేటాసెట్‌లో 5,801 జతల వాక్యాలు ఉన్నాయి – రెండు వాక్యాలు ఒకే అర్థం కలిగి ఉన్నాయా లేదా అని లేబుల్ ఉంటుంది. ఈ డేటాసెట్ చిన్నది కాబట్టి ప్రయోగాలు చేయడానికి చాలా సులభం.

హబ్ నుంచి డేటాసెట్ తీసుకురావడం[[loading-a-dataset-from-the-hub]]

హబ్‌లో మోడళ్లు మాత్రమే కాదు – వేలాది డేటాసెట్‌లు కూడా ఉన్నాయి (చాలా భాషల్లో!). వాటిని ఇక్కడ చూడొచ్చు. MRPC అనేది GLUE బెంచ్‌మార్క్లో భాగం. GLUE అంటే 10 రకాల టెక్స్ట్ క్లాసిఫికేషన్ టాస్క్‌లపై మోడళ్ల పనితనాన్ని కొలిచే అకడమిక్ బెంచ్‌మార్క్.

🤗 Datasets లైబ్రరీ ద్వారా డేటాసెట్‌ను ఒక్క లైన్‌లో డౌన్‌లోడ్ చేసుకోవచ్చు:

from datasets import load_dataset

raw_datasets = load_dataset("glue", "mrpc")
raw_datasets

DatasetDict({
    train: Dataset({
        features: ['sentence1', 'sentence2', 'label', 'idx'],
        num_rows: 3668
    })
    validation: Dataset({
        features: ['sentence1', 'sentence2', 'label', 'idx'],
        num_rows: 408
    })
    test: Dataset({
        features: ['sentence1', 'sentence2', 'label', 'idx'],
        num_rows: 1725
    })
})

DatasetDictలో శిక్షణ, వాలిడేషన్, టెస్ట్ సెట్లు ఉన్నాయి. ప్రతి ఎలిమెంట్‌లో sentence1, sentence2, label, idx కాలమ్స్ ఉంటాయి.

raw_datasets["train"][0]

{
  'idx': 0,
  'label': 1,
  'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .',
  'sentence2': 'Referring to him as only " the witness " , Amrozi accused his brother of deliberately distorting his evidence .'
}

లేబుల్స్ ఇప్పటికే ఇంటిజర్లుగా ఉన్నాయి (0 = సమానం కాదు, 1 = సమానం).

✏️ ప్రయత్నించండి! శిక్షణ సెట్‌లో 15వ ఎలిమెంట్, వాలిడేషన్ సెట్‌లో 87వ ఎలిమెంట్ చూడండి. వాటి లేబుల్స్ ఏమిటి?

డేటాసెట్ ప్రీ-ప్రాసెసింగ్[[preprocessing-a-dataset]]

టెక్స్ట్‌ను మోడల్ అర్థం చేసుకునే సంఖ్యలుగా మార్చాలి → దీనికి టోకెనైజర్ వాడతాం.

from transformers import AutoTokenizer

checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

inputs = tokenizer("This is the first sentence.", "This is the second one.")
inputs

{ 
  'input_ids': [101, 2023, 2003, 1996, 2034, 6251, 1012, 102, 2023, 2003, 1996, 2117, 2028, 1012, 102],
  'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
  'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
}

token_type_ids → ఏ టోకెన్ మొదటి వాక్యానిది, ఏది రెండవ వాక్యానిది అని చెప్పే ఫీల్డ్ (BERT దీన్ని ప్రీ-ట్రైనింగ్‌లో నేర్చుకుంది).

✏️ ప్రయత్నించండి! శిక్షణ సెట్‌లో 15వ ఎలిమెంట్‌ను రెండు వాక్యాలు వేర్వేరుగా మరియు జతగా టోకెనైజ్ చేసి చూడండి. తేడా ఏమిటి?

మొత్తం డేటాసెట్‌ను టోకెనైజ్ చేయడం

def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)

tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)

batched=True వాడితే చాలా వేగంగా జరుగుతుంది (Rustలో రాసిన ఫాస్ట్ టోకెనైజర్ వల్ల).

ప్యాడింగ్ ఇంకా చేయలేదు – ఎందుకంటే ప్రతి బ్యాచ్‌లోని గరిష్ట పొడవుకు మాత్రమే ప్యాడ్ చేయడం (డైనమిక్ ప్యాడింగ్) ఎక్కువ సమర్థవంతం.

డైనమిక్ ప్యాడింగ్[[dynamic-padding]]

బ్యాచ్‌లోని వాక్యాలను ఒకే పొడవుకు తెచ్చే ఫంక్షన్‌ను collate function అంటారు. హగ్గింగ్ ఫేస్ దీనికోసం రెడీమేడ్ టూల్ ఇచ్చింది:

from transformers import DataCollatorWithPadding

data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

ఉదాహరణకు 8 ఎలిమెంట్స్ తీసుకుంటే:

samples = tokenized_datasets["train"][:8]
samples = {k: v for k, v in samples.items() if k not in ["idx", "sentence1", "sentence2"]}
[len(x) for x in samples["input_ids"]]
# → [50, 59, 47, 67, 59, 50, 62, 32]

data_collator వీటిని 67 పొడవుకు ప్యాడ్ చేస్తుంది (ఆ బ్యాచ్‌లోనే అతి పెద్దది). మొత్తం డేటాసెట్‌లో అతి పెద్ద వాక్యానికి ప్యాడ్ చేయదు → సమయం, మెమరీ ఆదా అవుతుంది.

batch = data_collator(samples)
{k: v.shape for k, v in batch.items()}
# → {'input_ids': torch.Size([8, 67]), 'attention_mask': torch.Size([8, 67]), 'token_type_ids': torch.Size([8, 67]), 'labels': torch.Size([8])}

ఇప్పుడు మన డేటా పూర్తిగా మోడల్‌కు సిద్ధంగా ఉంది – ఫైన్-ట్యూనింగ్ చేయడానికి రెడీ!

✏️ ప్రయత్నించండి! GLUEలోని SST-2 డేటాసెట్‌పై ఇదే ప్రాసెస్ రిపీట్ చేయండి (ఒకే వాక్యం ఉంటుంది కాబట్టి కొంచెం డిఫరెంట్). మరింత కష్టమైన ఛాలెంజ్ కావాలంటే ఏదైనా GLUE టాస్క్‌కి పని చేసే ఒకే ప్రీ-ప్రాసెసింగ్ ఫంక్షన్ రాయండి.

సెక్షన్ క్విజ్[[section-quiz]]

1. Dataset.map()లో batched=True వాడితే ప్రధాన లాభం ఏమిటి?

2. ఎందుకు డైనమిక్ ప్యాడింగ్ వాడతాం?

3. BERT టోకెనైజేషన్‌లో token_type_ids ఏమి సూచిస్తుంది?

4. load_dataset('glue', 'mrpc')లో రెండవ ఆర్గ్యుమెంట్ ఏమి చేస్తుంది?

5. శిక్షణకు ముందు sentence1, sentence2 కాలమ్‌లు ఎందుకు తొలగిస్తాం?

ముఖ్య పాయింట్లు:

• batched=True తో map() → చాలా వేగమైన ప్రీ-ప్రాసెసింగ్
• DataCollatorWithPadding తో డైనమిక్ ప్యాడింగ్ → ఎక్కువ సమర్థవంతం
• మోడల్ ఏమి ఆశిస్తుందో దానికి తగ్గట్టు డేటా సిద్ధం చేయాలి
• 🤗 Datasets లైబ్రరీ స్కేల్‌లో ఎఫిషియెంట్ డేటా ప్రాసెసింగ్ చేస్తుంది

ఇప్పుడు డేటా పూర్తిగా సిద్ధం! తర్వాత సెక్షన్‌లో Trainer APIతో మోడల్ ఫైన్-ట్యూన్ చేద్దాం!