course/pr_1152/te/chapter3/2.md

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

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

```python
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]]

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

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

```python
from datasets import load_dataset

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

```python out
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` కాలమ్స్ ఉంటాయి.

```python
raw_datasets["train"][0]
```

```python out
{
  '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` = సమానం).

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

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

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

```python
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
```

```python out
{ 
  '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 దీన్ని ప్రీ-ట్రైనింగ్‌లో నేర్చుకుంది).

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

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

```python
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** అంటారు. హగ్గింగ్ ఫేస్ దీనికోసం రెడీమేడ్ టూల్ ఇచ్చింది:

```python
from transformers import DataCollatorWithPadding

data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
```

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

```python
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 పొడవుకు ప్యాడ్ చేస్తుంది (ఆ బ్యాచ్‌లోనే అతి పెద్దది). మొత్తం డేటాసెట్‌లో అతి పెద్ద వాక్యానికి ప్యాడ్ చేయదు → సమయం, మెమరీ ఆదా అవుతుంది.

```python
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])}
```

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

> [!TIP]
> ✏️ **ప్రయత్నించండి!** 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` కాలమ్‌లు ఎందుకు తొలగిస్తాం?

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

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