course/pr_1149/te/chapter2/3.md

# మోడళ్లు[[the-models]]

ఈ విభాగంలో, మోడల్‌లను సృష్టించడం మరియు ఉపయోగించడం గురించి మరింత లోతుగా పరిశీలిద్దాం. మనం `AutoModel` క్లాస్‌ను ఉపయోగిస్తాము, ఇది ఏ checkpoint నుండి అయినా మోడల్‌ను instantiate చేయాలనుకున్నప్పుడు చాలా ఉపయోగపడుతుంది.

## ఒక Transformer ను సృష్టించడం[[creating-a-transformer]]

`AutoModel` ను instantiate చేసినప్పుడు ఏమి జరుగుతుందో చూద్దాం:

```py
from transformers import AutoModel

model = AutoModel.from_pretrained("bert-base-cased")
```

టోకనైజర్ మాదిరిగానే, `from_pretrained()` పద్ధతి Hugging Face Hub నుండి మోడల్ డేటాను డౌన్‌లోడ్ చేసి cache చేస్తుంది. ముందే చెప్పినట్లుగా, checkpoint పేరు ఒక నిర్దిష్ట మోడల్ architecture మరియు దాని weights ను సూచిస్తుంది. ఈ ఉదాహరణలో, ఇది ఒక BERT ఆధారిత మోడల్ — 12 layers, 768 hidden size, 12 attention heads — మరియు *cased* ఇన్‌పుట్‌లతో (అంటే uppercase/lowercase తేడా ముఖ్యం).  
Hub లో అనేక checkpoints అందుబాటులో ఉన్నాయి — మీరు వాటిని [ఇక్కడ](https://huggingface.co/models) పరిశీలించవచ్చు.

`AutoModel` క్లాస్ మరియు దాని సంబంధిత "Auto" క్లాస్‌లు, ఇవ్వబడిన checkpoint కి సరిపోయే మోడల్ architecture ను ఆటోమేటిక్‌గా ఎంచుకుని సరైన మోడల్ క్లాస్‌ను instantiate చేసే సరళమైన wrappers మాత్రమే.  
మీరు ఉపయోగించాలనుకునే మోడల్ రకం ముందే తెలుసుకుంటే, architecture ని నిర్వచించే క్లాస్‌ను నేరుగా ఉపయోగించవచ్చు:

```py
from transformers import BertModel

model = BertModel.from_pretrained("bert-base-cased")
```

## లోడ్ చేయడం మరియు సేవ్ చేయడం[[loading-and-saving]]

మోడల్‌ను సేవ్ చేయడం, tokenizer ను సేవ్ చేసినంత సులభం. నిజానికి, మోడళ్లలో కూడా అదే `save_pretrained()` పద్ధతి ఉంటుంది, ఇది మోడల్ యొక్క weights మరియు architecture configuration ను సేవ్ చేస్తుంది:

```py
model.save_pretrained("directory_on_my_computer")
```

దీంతో మీ కంప్యూటర్‌లోని ఫోల్డర్‌లో ఈ రెండు ఫైళ్లు సేవ్ అవుతాయి:

```
ls directory_on_my_computer

config.json model.safetensors
```

config.json ఫైల్‌ను ఓపెన్ చేసి చూస్తే, మోడల్ architecture ను నిర్మించడానికి అవసరమైన attributes అన్నీ కనిపిస్తాయి. ఇందులో checkpoint ఎక్కడి నుండి వచ్చింది, అలాగే మీరు చివరిగా ఈ checkpoint ను సేవ్ చేసినప్పుడు ఉపయోగించిన 🤗 Transformers వెర్షన్ వంటి metadata కూడా ఉంటుంది.

pytorch_model.safetensors ఫైల్‌ను state dictionary అంటారు; ఇందులో మోడల్ యొక్క అన్ని weights ఉంటాయి.
ఈ రెండు ఫైళ్లు కలిసే పని చేస్తాయి: configuration ఫైల్ architecture వివరాలను ఇస్తుంది; weights ఫైల్ మోడల్ యొక్క parameters ను కలిగి ఉంటుంది.

సేవ్ చేసిన మోడల్‌ను మళ్లీ ఉపయోగించాలంటే, `from_pretrained()` పద్ధతిని మరోసారి ఉపయోగిస్తాము:

```py
from transformers import AutoModel

model = AutoModel.from_pretrained("directory_on_my_computer")
```

🤗 Transformers లైబ్రరీలోని అద్భుతమైన లక్షణాల్లో ఒకటి — మోడళ్లను మరియు టోకనైజర్‌లను సమాజంతో సులభంగా పంచుకునే సామర్థ్యం. దీని కోసం, ముందుగా మీరు [Hugging Face](https://huggingface.co) లో ఒక ఖాతా కలిగి ఉండాలి.  
మీరు ఒక notebook వాడుతున్నట్లయితే, ఈ విధంగా సులభంగా లాగిన్ కావచ్చు:

```python
from huggingface_hub import notebook_login

notebook_login()
```

లేదా, మీరు టెర్మినల్ ఉపయోగిస్తుంటే, ఇలా నడపండి:

```bash
huggingface-cli login
```

తర్వాత, `push_to_hub()` పద్ధతిని ఉపయోగించి మోడల్‌ను Hub కు పంపవచ్చు:

```py
model.push_to_hub("my-awesome-model")
```

ఇది మీ మోడల్ ఫైళ్లను Hub లోకి, మీ namespace కింద ఉన్న *my-awesome-model* అనే repository లోకి అప్లోడ్ చేస్తుంది.  
అప్పుడు ఎవరైనా మీ మోడల్‌ను `from_pretrained()` తో లోడ్ చేసుకోవచ్చు!

```py
from transformers import AutoModel

model = AutoModel.from_pretrained("your-username/my-awesome-model")
```

Hub API తో మీరు ఇంకా చాలా పనులు చేయవచ్చు:
- స్థానిక repository నుండి నేరుగా మోడల్‌ను push చేయడం
- మొత్తం మోడల్‌ను తిరిగి అప్లోడ్ చేయకుండా, ప్రత్యేకమైన ఫైళ్లను మాత్రమే అప్డేట్ చేయడం
- మోడల్‌కు సంబంధించిన సామర్థ్యాలు, పరిమితులు, bias లు మొదలైన వాటిని వివరించే model cards జోడించడం  

ఇవన్నీ ఎలా చేయాలో తెలుసుకోవడానికి [డాక్యుమెంటేషన్](https://huggingface.co/docs/huggingface_hub/how-to-upstream) ను చూడండి, లేదా మరింత లోతైన వివరణ కోసం advanced [Chapter 4](/course/chapter4) ను పరిశీలించండి.

## టెక్స్ట్‌ను ఎన్కోడ్ చేయడం[[encoding-text]]

Transformer మోడళ్లు టెక్స్ట్‌ను ప్రాసెస్ చేయేటప్పుడు, ఇన్‌పుట్‌ను సంఖ్యలుగా మార్చి పనిచేస్తాయి. ఈ విభాగంలో, tokenizer మీ టెక్స్ట్‌ను ప్రాసెస్ చేసినప్పుడు నిజంగా ఏమి జరుగుతుందో చూద్దాం. [అధ్యాయం 1](/course/chapter1)లో చూసినట్లుగా, tokenizers టెక్స్ట్‌ను tokens గా విడదీసి, ఆ tokens ను సంఖ్యలుగా మార్చుతాయి. ఈ మార్పును ఒక సరళమైన tokenizer ద్వారా పరిశీలించవచ్చు:

```py
from transformers import AutoTokenizer

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

encoded_input = tokenizer("Hello, I'm a single sentence!")
print(encoded_input)
```

```python out
{'input_ids': [101, 8667, 117, 1000, 1045, 1005, 1049, 2235, 17662, 12172, 1012, 102], 
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
```

మనకు వచ్చిన dictionary లో ఈ క్రింది fields ఉంటాయి:
- `input_ids`: మీ tokens యొక్క సంఖ్యాత్మక ప్రతినిధులు
- `token_type_ids`: ఇన్‌పుట్‌లో sentence A ఏది, sentence B ఏదో మోడల్‌కి తెలియజేస్తాయి (దీన్ని తరువాతి విభాగంలో మరింతగా చూడవచ్చు)
- `attention_mask`: మోడల్ ఏ tokens పై దృష్టి పెట్టాలి, ఏవిపై పెట్టకూడదో సూచిస్తుంది (కాసేపటి తర్వాత దీనిని వివరించబడుతుంది)

ఈ input IDs ను మళ్లీ decode చేస్తే అసలు టెక్స్ట్‌ను తిరిగి పొందవచ్చు:

```py
tokenizer.decode(encoded_input["input_ids"])
```

```python out
"[CLS] Hello, I'm a single sentence! [SEP]"
```

మీరు గమనించగలరు: tokenizer `[CLS]`, `[SEP]` వంటి ప్రత్యేక tokens ను జోడించింది — ఇవి ఆ మోడల్‌కు అవసరమైనవి. అన్ని మోడళ్లకు special tokens అవసరం ఉండవు; ఒక మోడల్ training దశలో వీటిని ఉపయోగించి ఉంటే, tokenizer కూడా వాటిని జోడించాల్సి ఉంటుంది.

ఒకేసారి అనేక వాక్యాలను encode చేయవచ్చు — batching ద్వారా (దాని గురించి త్వరలో తెలుసుకుంటాము), లేదా సాదాసీదాగా వాక్యాల జాబితాను పంపడం ద్వారా:

```py
encoded_input = tokenizer("How are you?", "I'm fine, thank you!")
print(encoded_input)
```

```python out
{'input_ids': [[101, 1731, 1132, 1128, 136, 102], [101, 1045, 1005, 1049, 2503, 117, 5763, 1128, 136, 102]], 
 'token_type_ids': [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 
 'attention_mask': [[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}
```

గమనించండి: అనేక వాక్యాలను పంపినప్పుడు, tokenizer ప్రతి dictionary key కి, ప్రతి వాక్యానికి వేర్వేరు లిస్ట్‌లను ఇస్తుంది.  
మనం tokenizer ను నేరుగా PyTorch tensors ను తిరిగి ఇవ్వమని కూడా అడగవచ్చు:

```py
encoded_input = tokenizer("How are you?", "I'm fine, thank you!", return_tensors="pt")
print(encoded_input)
```

```python out
{'input_ids': tensor([[  101,  1731,  1132,  1128,   136,   102],
         [  101,  1045,  1005,  1049,  2503,   117,  5763,  1128,   136,   102]]), 
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1],
         [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}
```

కానీ ఇక్కడ ఒక సమస్య ఉంది: ఈ రెండు లిస్ట్‌లు ఒకే పొడవు (length) కలిగి లేవు! Arrays మరియు tensors rectangular (సమచతురస్రాకార) గా ఉండాలి, కాబట్టి ఈ lists ను నేరుగా PyTorch tensor (లేదా NumPy array) గా మార్చలేం.  
దీనిని పరిష్కరించడానికి tokenizer లో *padding* అనే ఎంపిక ఉంది.

### ఇన్‌పుట్‌లను ప్యాడింగ్ చేయడం[[padding-inputs]]

మనం tokenizer కు padding చేయమని చెబితే, అది అన్ని వాక్యాలను ఒకే పొడవు కలిగేలా చేస్తుంది — అంటే, అతి పొడవైన వాక్యానికి సరిపడేలా చిన్న వాక్యాల చివరకు ప్రత్యేకమైన padding token ను జోడిస్తుంది:

```py
encoded_input = tokenizer(
    ["How are you?", "I'm fine, thank you!"], padding=True, return_tensors="pt"
)
print(encoded_input)
```

```python out
{'input_ids': tensor([[  101,  1731,  1132,  1128,   136,   102,     0,     0,     0,     0],
         [  101,  1045,  1005,  1049,  2503,   117,  5763,  1128,   136,   102]]), 
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
         [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}
```

ఇప్పుడు మనకు rectangular tensors వచ్చాయి!  
గమనించండి: padding tokens కు input IDs లో 0 అనే ID వచ్చింది, మరియు వాటి attention mask విలువ కూడా 0.  
దానికి కారణం — ఈ padding tokens ను మోడల్ విశ్లేషించకూడదు; ఇవి నిజమైన వాక్యంలో భాగం కావు.

### ఇన్‌పుట్‌లను ట్రంకేట్ చేయడం[[truncating-inputs]]

కొన్ని సందర్భాల్లో tensors చాలా పెద్దవుగా మారి, మోడల్ వాటిని ప్రాసెస్ చేయలేకపోవచ్చు. ఉదాహరణకు, BERT ప్రీట్రైనింగ్ చేయబడింది గరిష్టంగా **512 tokens** వరకు మాత్రమే.  
అంటే, ఆకు మించిన పొడవు ఉన్న వాక్యాలను ప్రాసెస్ చేయలేడని అర్థం.

అలా మోడల్ హ్యాండిల్ చేయలేని పొడవైన వాక్యాలు ఉంటే, వాటిని `truncation` పరామీటర్‌ ద్వారా చిన్నదిగా చేయాలి:

```py
encoded_input = tokenizer(
    "This is a very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very long sentence.",
    truncation=True,
)
print(encoded_input["input_ids"])
```

```python out
[101, 1188, 1110, 170, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1179, 5650, 119, 102]
```

Padding మరియు truncation ను కలిపి ఉపయోగిస్తే, మీ tensors మీకు కావాల్సిన ఖచ్చితమైన పరిమాణంలో ఉంటాయి:

```py
encoded_input = tokenizer(
    ["How are you?", "I'm fine, thank you!"],
    padding=True,
    truncation=True,
    max_length=5,
    return_tensors="pt",
)
print(encoded_input)
```

```python out
{'input_ids': tensor([[  101,  1731,  1132,  1128,   102],
         [  101,  1045,  1005,  1049,   102]]), 
 'token_type_ids': tensor([[0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0]]), 
 'attention_mask': tensor([[1, 1, 1, 1, 1],
         [1, 1, 1, 1, 1]])}
```

### ప్రత్యేక tokens ని జోడించడం

Special tokens (లేదా వాటి భావం) BERT మరియు దాని ఆధారిత మోడళ్లకు చాలా ముఖ్యమైనవి.  
ఈ tokens వాక్యాల పరిమితులను సూచించడానికి ఉపయోగపడతాయి — ఉదాహరణకు:

- వాక్య ప్రారంభం: `[CLS]`
- రెండు వాక్యాల మధ్య విభజన: `[SEP]`

ఇదిగో ఒక సాధారణ ఉదాహరణ:

```py
encoded_input = tokenizer("How are you?")
print(encoded_input["input_ids"])
tokenizer.decode(encoded_input["input_ids"])
```

```python out
[101, 1731, 1132, 1128, 136, 102]
'[CLS] How are you? [SEP]'
```

ఈ special tokens ను tokenizer స్వయంచాలకంగా జోడిస్తుంది.  
అన్ని మోడళ్లకు ఇవి అవసరం కాదు;  
మోడల్ ప్రీట్రైనింగ్ దశలో special tokens వాడినప్పుడు మాత్రమే tokenizer వాటిని జోడిస్తుంది — ఎందుకంటే మోడల్ వాటిని ఆశిస్తుంది.

### ఇది అంతా ఎందుకు అవసరం?

ఇదిగో ఒక స్పష్టమైన ఉదాహరణ. ఈ encoded sequences ను పరిశీలించండి:

```py
sequences = [
    "I've been waiting for a HuggingFace course my whole life.",
    "I hate this so much!",
]
```

Tokenize చేసిన తర్వాత మనకు ఇది వస్తుంది:

```python
encoded_sequences = [
    [
        101,
        1045,
        1005,
        2310,
        2042,
        3403,
        2005,
        1037,
        17662,
        12172,
        2607,
        2026,
        2878,
        2166,
        1012,
        102,
    ],
    [101, 1045, 5223, 2023, 2061, 2172, 999, 102],
]
```

ఇది ఒక లిస్ట్ ఆఫ్ లిస్ట్‌లు — అంటే, సంఖ్యలతో కూడిన అనేక లిస్ట్‌లు.  
టెన్సర్లు మాత్రం **సమచతురస్రాకార (rectangular)** ఆకారాన్ని మాత్రమే అంగీకరిస్తాయి — మ్యాట్రిసులకు ఆలోచించండి.

ఈ ఉదాహరణలో "array" ఇప్పటికే rectangularగా ఉంది, కాబట్టి దీనిని tensor గా మార్చడం చాలా సులభం:

```py
import torch

model_inputs = torch.tensor(encoded_sequences)
```

### టెన్సర్లను మోడల్‌కు ఇన్‌పుట్‌లుగా ఉపయోగించడం[[using-the-tensors-as-inputs-to-the-model]]

టెన్సర్లను మోడల్‌తో ఉపయోగించడం చాలా సులభం — మనం inputs తో మోడల్‌ను నేరుగా పిలుస్తాం:

```py
output = model(model_inputs)
```

మోడల్ అనేక రకాల arguments అంగీకరిస్తుంది, కానీ **input IDs తప్పనిసరి**.  
ఇతర arguments ఏమి చేస్తాయి, ఎప్పుడు అవసరం పడతాయో తరువాతి విభాగాల్లో వివరంగా చూస్తాం.  

కానీ ముందుగా, టోకెనైజర్లు Transformer మోడళ్లకు అర్థమయ్యే ఇన్‌పుట్‌లను ఎలా తయారు చేస్తాయో మరింత లోతుగా తెలుసుకోవాలి.