From d3b1b1ddd5e12eb5c51d2c5ecc848b26d53ca5a3 Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Mon, 1 Dec 2025 03:00:42 -0500 Subject: [PATCH 1/8] Transultaion_telugu_version_1 --- chapters/te/chapter3/1.mdx | 40 +++++++ chapters/te/chapter3/2.mdx | 229 +++++++++++++++++++++++++++++++++++ chapters/te/chapter3/3.mdx | 203 +++++++++++++++++++++++++++++++ chapters/te/chapter3/4.mdx | 236 +++++++++++++++++++++++++++++++++++++ chapters/te/chapter3/5.mdx | 210 +++++++++++++++++++++++++++++++++ chapters/te/chapter3/6.mdx | 38 ++++++ chapters/te/chapter3/7.mdx | 22 ++++ 7 files changed, 978 insertions(+) create mode 100644 chapters/te/chapter3/1.mdx create mode 100644 chapters/te/chapter3/2.mdx create mode 100644 chapters/te/chapter3/3.mdx create mode 100644 chapters/te/chapter3/4.mdx create mode 100644 chapters/te/chapter3/5.mdx create mode 100644 chapters/te/chapter3/6.mdx create mode 100644 chapters/te/chapter3/7.mdx diff --git a/chapters/te/chapter3/1.mdx b/chapters/te/chapter3/1.mdx new file mode 100644 index 000000000..fafcab275 --- /dev/null +++ b/chapters/te/chapter3/1.mdx @@ -0,0 +1,40 @@ + +# పరిచయం[[introduction]] + + +అధ్యాయం 2లో మనం టోకెనైజర్లు మరియు ముందే శిక్షణ పొందిన మోడళ్లను ఉపయోగించి ప్రిడిక్షన్లు ఎలా పొందాలో తెలుసుకున్నాం.అయితే మీకు ఒక ప్రత్యేకమైన పని చేసే మోడల్ కావాలంటే ఏం చేయాలి? అందుకే ముందే శిక్షణ పొందిన మోడల్‌ను మీ స్వంత డేటాతో మరింత శిక్షణ ఇవ్వాల్సి ఉంటుంది. ఈ ప్రక్రియను **fine-tuning** అంటారు. ఈ పాఠం మొత్తం ఇదే అంశాన్ని కవర్ చేస్తుంది. + +ఈ పాఠం పూర్తయిన తర్వాత మీరు కింది విషయాలు నేర్చుకుంటారు: +- Hugging Face Hub నుంచి పెద్ద డేటాసెట్‌లను తాజా 🤗 Datasets లైబ్రరీ ద్వారా ఎలా తీసుకురావాలి +- అత్యంత సులభమైన `Trainer` API ఉపయోగించి మోడల్‌ను ఆధునిక ఉత్తమ పద్ధతులతో ఫైన్-ట్యూన్ ఎలా చేయాలి +- స్వంతంగా పూర్తి ట్రైనింగ్ లూప్ రాసి, ఆప్టిమైజేషన్ టెక్నిక్స్ ఎలా వినియోగించాలి +- 🤗 Accelerate లైబ్రరీ ద్వారా ఏ రకమైన హార్డ్‌వేర్ సెటప్‌లోనైనా సులభంగా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ ఎలా నడపాలి +- ప్రస్తుతం అత్యుత్తమ ఫలితాలు ఇచ్చే ఫైన్-ట్యూనింగ్ పద్ధతులు ఏమిటి + +> [!TIP] +> 📚 ప్రారంభించే ముందు 🤗 Datasets డాక్యుమెంటేషన్‌ను ఒకసారి సందర్శించడం ఉపయోగకరం → https://huggingface.co/docs/datasets/ + +ఈ పాఠం 🤗 Transformers లైబ్రరీతో పాటు Hugging Face యొక్క ఇతర ముఖ్యమైన లైబ్రరీలకు కూడా పరిచయం అవుతుంది: 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate, 🤗 Evaluate. ఈ లైబ్రరీలు కలిసి మోడల్ శిక్షణను మరింత వేగవంతంగా, సమర్థవంతంగా చేస్తాయి. + +ఈ పాఠం యొక్క ముఖ్య భాగాలు: +- **సెక్షన్ 2**: ఆధునిక డేటా ప్రీ-ప్రాసెసింగ్ పద్ధతులు మరియు సమర్థవంతమైన డేటాసెట్ నిర్వహణ +- **సెక్షన్ 3**: Trainer API యొక్క తాజా ఫీచర్లతో సహా పూర్తి ఉపయోగం +- **సెక్షన్ 4**: స్వంతంగా ట్రైనింగ్ లూప్ రాయడం మరియు Accelerate ద్వారా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ + +పాఠం ముగిసే సమయానికి మీరు కింది రెండు విధానాల్లో ఏదైనా ఉపయోగించి, మీ స్వంత డేటాసెట్‌లపై మోడళ్లను ఫైన్-ట్యూన్ చేయగలుగుతారు: +- అత్యంత సులభమైన Trainer API ద్వారా +- పూర్తి నియంత్రణతో స్వంత ట్రైనింగ్ లూప్ రాసి + +అంతేకాకుండా, ప్రస్తుతం అత్యుత్తమ ఫలితాలు ఇచ్చే పద్ధతులను కూడా అనుసరించగలుగుతారు. + +> [!TIP] +> 🎯 ఈ పాఠం ముగిసే సమయానికి మీరు BERT మోడల్‌ను టెక్స్ట్ క్లాసిఫికేషన్ కార్యానికి ఫైన్-ట్యూన్ చేసి ఉంటారు మరియు ఈ పద్ధతులను మీ స్వంత డేటాసెట్, మీ స్వంత కార్యానికి ఎలా అనుకూలీకరించాలో స్పష్టంగా అర్థమవుతుంది. + +ఈ పాఠం పూర్తిగా **PyTorch** ఆధారంగా ఉంటుంది – ఇది ప్రస్తుత డీప్ లెర్నింగ్ పరిశోధన మరియు ఉత్పత్తి వినియోగంలో ప్రామాణిక ఫ్రేమ్‌వర్క్‌గా మారింది. + +మీరు శిక్షణ పూర్తి చేసిన మోడల్‌ను Hugging Face Hubలో అప్‌లోడ్ చేయాలంటే ఒక ఉచిత ఖాతా అవసరం: [ఖాతా సృష్టించండి](https://huggingface.co/join) + +ఇక ఆలస్యం ఏమీ లేకుండా… ప్రారంభిద్దాం! \ No newline at end of file diff --git a/chapters/te/chapter3/2.mdx b/chapters/te/chapter3/2.mdx new file mode 100644 index 000000000..932c2b116 --- /dev/null +++ b/chapters/te/chapter3/2.mdx @@ -0,0 +1,229 @@ +# డేటా సిద్ధం చేయడం[[processing-the-data]] + + +ముందు అధ్యాయంలో చూపిన ఉదాహరణనే కొనసాగిస్తూ, ఒకే బ్యాచ్‌పై సీక్వెన్స్ క్లాసిఫైయర్‌ను ఎలా శిక్షణ ఇస్తామో ఇక్కడ చూద్దాం: + +```python +import torch +from torch.optim import AdamW +from transformers import AutoTokenizer, AutoModelForSequenceClassification + +# ఇది ముందు లాగానే +checkpoint = "bert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) + +sequences = [ + "నేను జీవితమంతా హగ్గింగ్ ఫేస్ కోర్సు కోసం ఎదురుచూస్తున్నాను.", + "ఈ కోర్సు అద్భుతం!", +] + +batch = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt") + +# ఇది కొత్త +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 లైబ్రరీ ద్వారా డేటాసెట్‌ను ఒక్క లైన్‌లో డౌన్‌లోడ్ చేసుకోవచ్చు: + +```py +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` కాలమ్స్ ఉంటాయి. + +```py +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]] + + +టెక్స్ట్‌ను మోడల్ అర్థం చేసుకునే సంఖ్యలుగా మార్చాలి → దీనికి టోకెనైజర్ వాడతాం. + +```py +from transformers import AutoTokenizer + +checkpoint = "bert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) + +inputs = tokenizer("మొదటి వాక్యం ఇది.", "రెండవ వాక్యం ఇది.") +inputs +``` + +```python out +{ + 'input_ids': [101, ... , 102], + 'token_type_ids': [0, 0, ..., 1, 1, ...], + 'attention_mask': [1, 1, ...] +} +``` + +`token_type_ids` → ఏ టోకెన్ మొదటి వాక్యానిది, ఏది రెండవ వాక్యానిది అని చెప్పే ఫీల్డ్ (BERT దీన్ని ప్రీ-ట్రైనింగ్‌లో నేర్చుకుంది). + +> [!TIP] +> ✏️ **ప్రయత్నించండి!** శిక్షణ సెట్‌లో 15వ ఎలిమెంట్‌ను రెండు వాక్యాలు వేర్వేరుగా మరియు జతగా టోకెనైజ్ చేసి చూడండి. తేడా ఏమిటి? + +### మొత్తం డేటాసెట్‌ను టోకెనైజ్ చేయడం + +```py +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** అంటారు. హగ్గింగ్ ఫేస్ దీనికోసం రెడీమేడ్ టూల్ ఇచ్చింది: + +```py +from transformers import DataCollatorWithPadding + +data_collator = DataCollatorWithPadding(tokenizer=tokenizer) +``` + +ఉదాహరణకు 8 ఎలిమెంట్స్ తీసుకుంటే: + +```py +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 పొడవుకు ప్యాడ్ చేస్తుంది (ఆ బ్యాచ్‌లోనే అతి పెద్దది). మొత్తం డేటాసెట్‌లో అతి పెద్ద వాక్యానికి ప్యాడ్ చేయదు → చాలా సమయం, మెమరీ ఆదా అవుతుంది. + +```py +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]), ...} +``` + +ఇప్పుడు మన డేటా పూర్తిగా మోడల్‌కు సిద్ధంగా ఉంది – ఫైన్-ట్యూనింగ్ చేయడానికి రెడీ! + +> [!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తో మోడల్ ఫైన్-ట్యూన్ చేద్దాం! \ No newline at end of file diff --git a/chapters/te/chapter3/3.mdx b/chapters/te/chapter3/3.mdx new file mode 100644 index 000000000..0aa5d9b7f --- /dev/null +++ b/chapters/te/chapter3/3.mdx @@ -0,0 +1,203 @@ + +# Trainer APIతో మోడల్ ఫైన్-ట్యూనింగ్[[fine-tuning-a-model-with-the-trainer-api]] + + + +🤗 Transformers లైబ్రరీలోని **`Trainer`** క్లాస్ మీ డేటాసెట్‌పై ఏదైనా ప్రీ-ట్రైన్డ్ మోడల్‌ను సులభంగా ఫైన్-ట్యూన్ చేయడానికి సహాయపడుతుంది. ముందు సెక్షన్‌లో డేటా ప్రీ-ప్రాసెసింగ్ పూర్తయిన తర్వాత, Trainerను నిర్వచించడానికి కేవలం కొన్ని స్టెప్స్ మాత్రమే మిగులుతాయి. + +CPUలో Trainer.train() చాలా నెమ్మదిగా రన్ అవుతుంది. GPU లేకపోతే [Google Colab](https://colab.research.google.com/)లో ఉచిత GPU/TPU ఉపయోగించండి. + +> [!TIP] +> **శిక్షణ రిసోర్సెస్**: ప్రారంభించే ముందు [🤗 Transformers శిక్షణ గైడ్](https://huggingface.co/docs/transformers/main/en/training) మరియు [ఫైన్-ట్యూనింగ్ కుక్‌బుక్](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu) చూడండి. + +ముందు సెక్షన్‌లో రన్ చేసిన కోడ్ రీక్యాప్: + +```py +from datasets import load_dataset +from transformers import AutoTokenizer, DataCollatorWithPadding + +raw_datasets = load_dataset("glue", "mrpc") +checkpoint = "bert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) + +def tokenize_function(example): + return tokenizer(example["sentence1"], example["sentence2"], truncation=True) + +tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) +data_collator = DataCollatorWithPadding(tokenizer=tokenizer) +``` + +### శిక్షణ[[training]] + +Trainer నిర్వచించే ముందు ముందుగా `TrainingArguments` క్లాస్‌ను సృష్టించాలి. ఇందులో శిక్షణ & ఎవాల్యుయేషన్ కోసం అన్ని హైపర్‌పారామీటర్స్ ఉంటాయి. + +```py +from transformers import TrainingArguments + +training_args = TrainingArguments("test-trainer") +``` + +`push_to_hub=True` ఇస్తే శిక్షణ సమయంలోనే మోడల్ హబ్‌కి ఆటోమేటిక్‌గా అప్‌లోడ్ అవుతుంది. + +> [!TIP] +> **అడ్వాన్స్డ్ కాన్ఫిగరేషన్**: అన్ని ఆప్షన్స్ కోసం [TrainingArguments డాక్యుమెంటేషన్](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments) చూడండి. + +మోడల్: + +```py +from transformers import AutoModelForSequenceClassification + +model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) +``` + +> వార్నింగ్ వస్తుంది – ఎందుకంటే BERT ముందుగా సెంటెన్స్ పేర్ క్లాసిఫికేషన్‌పై శిక్షణ పొందలేదు. పాత హెడ్ తీసేసి కొత్త హెడ్ జోడించారు. ఇప్పుడు శిక్షణ ఇవ్వాల్సిందే! + +Trainer నిర్వచించడం: + +```py +from transformers import Trainer + +trainer = Trainer( + model, + training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation"], + data_collator=data_collator, + processing_class=tokenizer, # ఇది కొత్త ఫీచర్ – ఏ టోకెనైజర్ వాడాలో చెబుతుంది +) +``` + +`processing_class` ఇస్తే `data_collator` ఆటోమేటిక్‌గా `DataCollatorWithPadding` అవుతుంది. + +శిక్షణ ప్రారంభించడం: + +```py +trainer.train() +``` + +ఇది శిక్షణ మొదలుపెడుతుంది – కానీ ఎవాల్యుయేషన్ మెట్రిక్స్ రావు ఎందుకంటే: +1. `eval_strategy` సెట్ చేయలేదు +2. `compute_metrics` ఫంక్షన్ ఇవ్వలేదు + +### ఎవాల్యుయేషన్[[evaluation]] + +మంచి `compute_metrics()` ఫంక్షన్ రాయడం: + +```py +predictions = trainer.predict(tokenized_datasets["validation"]) +print(predictions.predictions.shape, predictions.label_ids.shape) +# → (408, 2) (408,) +``` + +```py +import numpy as np +preds = np.argmax(predictions.predictions, axis=-1) +``` + +మెట్రిక్ లోడ్ చేయడం: + +```py +import evaluate +metric = evaluate.load("glue", "mrpc") +metric.compute(predictions=preds, references=predictions.label_ids) +# → {'accuracy': 0.8578, 'f1': 0.8996} +``` + +పూర్తి `compute_metrics` ఫంక్షన్: + +```py +def compute_metrics(eval_preds): + metric = evaluate.load("glue", "mrpc") + logits, labels = eval_preds + predictions = np.argmax(logits, axis=-1) + return metric.compute(predictions=predictions, references=labels) +``` + +ఇప్పుడు కొత్త Trainerతో మళ్లీ శిక్షణ: + +```py +training_args = TrainingArguments("test-trainer", eval_strategy="epoch") +model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) + +trainer = Trainer( + model, + training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation"], + data_collator=data_collator, + processing_class=tokenizer, + compute_metrics=compute_metrics, +) + +trainer.train() +``` + +ఇప్పుడు ప్రతి ఎపాక్ చివర ఎవాల్యుయేషన్ లాస్ + మెట్రిక్స్ కనిపిస్తాయి! + +### అడ్వాన్స్డ్ శిక్షణ ఫీచర్స్[[advanced-training-features]] + +**మిక్స్డ్ ప్రెసిషన్ (వేగం + మెమరీ ఆదా)** + +```py +training_args = TrainingArguments("test-trainer", eval_strategy="epoch", fp16=True) +``` + +**గ్రేడియంట్ అక్యుములేషన్ (ఎక్కువ బ్యాచ్ సైజ్ సిమ్యులేషన్)** + +```py +training_args = TrainingArguments( + "test-trainer", + per_device_train_batch_size=4, + gradient_accumulation_steps=4, # ఎఫెక్టివ్ బ్యాచ్ సైజ్ = 16 +) +``` + +**లెర్నింగ్ రేట్ షెడ్యూలర్** + +```py +training_args = TrainingArguments( + "test-trainer", + learning_rate=2e-5, + lr_scheduler_type="cosine", +) +``` + +> [!TIP] +> **పర్ఫార్మెన్స్ ఆప్టిమైజేషన్**: డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్, మెమరీ ఆప్టిమైజేషన్ కోసం [🤗 Transformers పర్ఫార్మెన్స్ గైడ్](https://huggingface.co/docs/transformers/main/en/performance) చూడండి. + +Trainer మల్టీ-GPU/TPUలో ఔట్-ఆఫ్-ది-బాక్స్ పని చేస్తుంది – చాప్టర్ 10లో వివరంగా చూద్దాం. + +## సెక్షన్ క్విజ్[[section-quiz]] + +### 1. Trainerలో `processing_class` పరామీటర్ దేనికి? + + +### 2. ఎవాల్యుయేషన్ ఎప్పుడు జరగాలో ఏ పారామీటర్ నిర్ణయిస్తుంది? + + +### 3. `fp16=True` ఏమి చేస్తుంది? + + +### 4. `compute_metrics` ఫంక్షన్ పాత్ర ఏమిటి? + + +### 5. `eval_dataset` ఇవ్వకపోతే ఏమవుతుంది? + + +### 6. గ్రేడియంట్ అక్యుములేషన్ అంటే ఏమిటి? + + +> [!TIP] +> **ముఖ్య పాయింట్లు**: +> - `Trainer` API అతి సులభమైన, శక్తివంతమైన ఇంటర్‌ఫేస్ +> - `processing_class` ద్వారా టోకెనైజర్ స్పష్టంగా చెప్పండి +> - `TrainingArguments`లో లెర్నింగ్ రేట్, బ్యాచ్ సైజ్, fp16, గ్రేడియంట్ అక్యుములేషన్ వంటివి సెట్ చేయండి +> - `compute_metrics` ద్వారా మీకు కావలసిన మెట్రిక్స్ చూడండి +> - ఆధునిక ఆప్టిమైజేషన్స్ (fp16, gradient accumulation) ఒక్క లైన్‌లో ఆన్ చేయవచ్చు \ No newline at end of file diff --git a/chapters/te/chapter3/4.mdx b/chapters/te/chapter3/4.mdx new file mode 100644 index 000000000..1f3954ece --- /dev/null +++ b/chapters/te/chapter3/4.mdx @@ -0,0 +1,236 @@ + +# పూర్తి శిక్షణ లూప్[[a-full-training]] + + + +ఇప్పుడు `Trainer` క్లాస్ ఉపయోగించకుండా, మునుపటి సెక్షన్‌లో చూపిన అదే ఫలితాలను సాధించే విధంగా పూర్తి శిక్షణ లూప్‌ను PyTorchలో అమలు చేద్దాం. మళ్లీ చెప్తున్నాం – మీరు సెక్షన్ 2లో డేటా ప్రాసెసింగ్ పూర్తి చేసి ఉన్నారని అనుకుంటున్నాం. + +```py +from datasets import load_dataset +from transformers import AutoTokenizer, DataCollatorWithPadding + +raw_datasets = load_dataset("glue", "mrpc") +checkpoint = "bert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) + +def tokenize_function(example): + return tokenizer(example["sentence1"], example["sentence2"], truncation=True) + +tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) +data_collator = DataCollatorWithPadding(tokenizer=tokenizer) +``` + +### శిక్షణకు సిద్ధం చేయడం[[prepare-for-training]] + +`Trainer` ఆటోమేటిక్‌గా చేసే కొన్ని దశలను మనం మాన్యువల్‌గా చేయాలి: + +```py +tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"]) +tokenized_datasets = tokenized_datasets.rename_column("label", "labels") +tokenized_datasets.set_format("torch") + +tokenized_datasets["train"].column_names +``` + +```python out +["attention_mask", "input_ids", "labels", "token_type_ids"] +``` + +ఇప్పుడు DataLoaderలు తయారు చేయవచ్చు: + +```py +from torch.utils.data import DataLoader + +train_dataloader = DataLoader( + tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator +) +eval_dataloader = DataLoader( + tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator +) +``` + +ఒక బ్యాచ్ చూద్దాం: + +```py +for batch in train_dataloader: + break +{k: v.shape for k, v in batch.items()} +``` + +```python out +{'attention_mask': torch.Size([8, 65]), + 'input_ids': torch.Size([8, 65]), + 'labels': torch.Size([8]), + 'token_type_ids': torch.Size([8, 65])} +``` + +మోడల్: + +```py +from transformers import AutoModelForSequenceClassification + +model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) +``` + +టెస్ట్: + +```py +outputs = model(**batch) +print(outputs.loss, outputs.logits.shape) +``` + +```python out +tensor(0.5441, grad_fn=) torch.Size([8, 2]) +``` + +ఆప్టిమైజర్: + +```py +from torch.optim import AdamW + +optimizer = AdamW(model.parameters(), lr=5e-5) +``` + +లెర్నింగ్ రేట్ షెడ్యూలర్: + +```py +from transformers import get_scheduler + +num_epochs = 3 +num_training_steps = num_epochs * len(train_dataloader) +lr_scheduler = get_scheduler( + "linear", + optimizer=optimizer, + num_warmup_steps=0, + num_training_steps=num_training_steps, +) +print(num_training_steps) +``` + +```python out +1377 +``` + +GPUకి తరలించడం: + +```py +import torch + +device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") +model.to(device) +print(device) +``` + +```python out +device(type='cuda') +``` + +### శిక్షణ లూప్[[the-training-loop]] + +```py +from tqdm.auto import tqdm + +progress_bar = tqdm(range(num_training_steps)) + +model.train() +for epoch in range(num_epochs): + for batch in train_dataloader: + batch = {k: v.to(device) for k, v in batch.items()} + + outputs = model(**batch) + loss = outputs.loss + loss.backward() + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + progress_bar.update(1) +``` + +### ఎవాల్యుయేషన్ లూప్[[the-evaluation-loop]] + +```py +import evaluate + +metric = evaluate.load("glue", "mrpc") +model.eval() + +for batch in eval_dataloader: + batch = {k: v.to(device) for k, v in batch.items()} + with torch.no_grad(): + outputs = model(**batch) + + logits = outputs.logits + predictions = torch.argmax(logits, dim=-1) + metric.add_batch(predictions=predictions, references=batch["labels"]) + +metric.compute() +``` + +```python out +{'accuracy': 0.8431372549019608, 'f1': 0.8907849829351535} +``` + +### 🤗 Accelerateతో శిక్షణ లూప్[[supercharge-your-training-loop-with-accelerate]] + + +```py +from accelerate import Accelerator +from transformers import get_scheduler +from torch.optim import AdamW +from tqdm.auto import tqdm + +accelerator = Accelerator() + +model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) +optimizer = AdamW(model.parameters(), lr=3e-5) + +train_dl, eval_dl, model, optimizer = accelerator.prepare( + train_dataloader, eval_dataloader, model, optimizer +) + +num_epochs = 3 +num_training_steps = num_epochs * len(train_dl) +lr_scheduler = get_scheduler( + "linear", + optimizer=optimizer, + num_warmup_steps=0, + num_training_steps=num_training_steps, +) + +progress_bar = tqdm(range(num_training_steps), disable=not accelerator.is_local_main_process) + +model.train() +for epoch in range(num_epochs): + for batch in train_dl: + outputs = model(**batch) + loss = outputs.loss + + accelerator.backward(loss) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + progress_bar.update(1) +``` + +ఈ కోడ్‌ను `train.py`లో సేవ్ చేసి కింది కమాండ్‌లతో రన్ చేయవచ్చు: + +```bash +accelerate config +accelerate launch train.py +``` + +Colabలో టెస్ట్ చేయాలంటే: + +```py +from accelerate import notebook_launcher +notebook_launcher(training_function) +``` \ No newline at end of file diff --git a/chapters/te/chapter3/5.mdx b/chapters/te/chapter3/5.mdx new file mode 100644 index 000000000..65160e8d1 --- /dev/null +++ b/chapters/te/chapter3/5.mdx @@ -0,0 +1,210 @@ + +# లెర్నింగ్ కర్వ్స్ అర్థం చేసుకోవడం[[understanding-learning-curves]] + + +`Trainer` API మరియు కస్టమ్ ట్రైనింగ్ లూప్స్ రెండిటితో ఫైన్-ట్యూనింగ్ ఎలా చేయాలో నేర్చుకున్న తర్వాత, ఫలితాలను ఎలా అర్థం చేసుకోవాలో తెలుసుకోవడం చాలా ముఖ్యం. లెర్నింగ్ కర్వ్స్ మోడల్ పనితీరును అంచనా వేయడానికి, సమస్యలను ముందుగానే గుర్తించడానికి అమూల్యమైన టూల్స్. + +ఈ సెక్షన్‌లో ఆక్యురసీ మరియు లాస్ కర్వ్స్‌ను ఎలా చదవాలో, వివిధ కర్వ్ ఆకారాలు మోడల్ ప్రవర్తన గురించి ఏమి చెబుతాయో, సాధారణ శిక్షణ సమస్యలను ఎలా పరిష్కరించాలో తెలుసుకుంటాం. + +## లెర్నింగ్ కర్వ్స్ అంటే ఏమిటి?[[what-are-learning-curves]] + +లెర్నింగ్ కర్వ్స్ అంటే శిక్షణ సమయంలో మోడల్ పనితీరు మెట్రిక్స్ ఎలా మారుతాయో చూపే దృశ్య రూపాలు. పర్యవేక్షించాల్సిన ముఖ్యమైన రెండు కర్వ్స్: + +- **లాస్ కర్వ్స్**: మోడల్ ఎర్రర్ (లాస్) శిక్షణ స్టెప్స్ లేదా ఎపాక్స్‌లో ఎలా మారుతుంది +- **ఆక్యురసీ కర్వ్స్**: సరైన ప్రిడిక్షన్స్ శాతం ఎలా మారుతుంది + +### లాస్ కర్వ్స్[[loss-curves]] + +లాస్ కర్వ్ మోడల్ ఎర్రర్ కాలక్రమంలో ఎలా తగ్గుతుందో చూపిస్తుంది. సాధారణ విజయవంతమైన శిక్షణలో కింది విధంగా కనిపిస్తుంది: + +![Loss Curve](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/1.png) + +- **మొదట ఎక్కువ లాస్**: మోడల్ ఆప్టిమైజ్ కాని స్థితిలో ఉంటుంది, ప్రిడిక్షన్స్ పేలవంగా ఉంటాయి +- **తగ్గుతున్న లాస్**: శిక్షణ పురోగమిస్తుండగా లాస్ సాధారణంగా తగ్గుతుంది +- **కన్వర్జెన్స్**: చివరికి లాస్ తక్కువ వాల్యూకి స్థిరపడుతుంది + +```python +from transformers import Trainer, TrainingArguments +import wandb +wandb.init(project="transformer-fine-tuning", name="bert-mrpc-analysis") + +training_args = TrainingArguments( + output_dir="./results", + eval_strategy="steps", + eval_steps=50, + save_steps=100, + logging_steps=10, + num_train_epochs=3, + per_device_train_batch_size=16, + per_device_eval_batch_size=16, + report_to="wandb", +) + +trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation"], + data_collator=data_collator, + processing_class=tokenizer, + compute_metrics=compute_metrics, +) +trainer.train() +``` + +### ఆక్యురసీ కర్వ్స్[[accuracy-curves]] + +![Accuracy Curve](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/2.png) + +- **మొదట తక్కువ**: మోడల్ ఇంకా ప్యాటర్న్స్ నేర్చుకోలేదు +- **పెరుగుతుంది**: మోడల్ నేర్చుకుంటుంది కాబట్టి ఆక్యురసీ పెరుగుతుంది +- **ప్లాటోలు కనిపిస్తాయి**: ఆక్యురసీ సాధారణంగా డిస్క్రీట్ జంప్స్‌లో పెరుగుతుంది + +> [!TIP] +> ఆక్యురసీ కర్వ్స్ "స్టెప్పీ"గా ఉండటానికి కారణం: లాస్ కంటిన్యూస్ అయితే, ఆక్యురసీ డిస్క్రీట్ ప్రిడిక్షన్స్‌పై ఆధారపడి ఉంటుంది. కాన్ఫిడెన్స్‌లో చిన్న మెరుగుదలలు ఫైనల్ ప్రిడిక్షన్ మార్చకపోవచ్చు, థ్రెషోల్డ్ దాటినప్పుడు మాత్రమే ఆక్యురసీ పెరుగుతుంది. + +### కన్వర్జెన్స్[[convergence]] + +![Convergence](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/4.png) + +మోడల్ పనితీరు స్థిరపడినప్పుడు కన్వర్జెన్స్ జరుగుతుంది. + +## లెర్నింగ్ కర్వ్ ప్యాటర్న్స్ అర్థం చేసుకోవడం[[interpreting-learning-curve-patterns]] + +### ఆరోగ్యకరమైన లెర్నింగ్ కర్వ్స్[[healthy-learning-curves]] + +![Healthy Loss Curve](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/5.png) + +> [!TIP] +> ఆరోగ్యకరమైన కర్వ్స్ లక్షణాలు: +> - ట్రైన్ & వాలిడేషన్ లాస్ రెండూ స్థిరంగా తగ్గుతాయి +> - ట్రైన్/వాలిడేషన్ మధ్య చిన్న గ్యాప్ మాత్రమే ఉంటుంది +> - కర్వ్స్ స్థిరపడతాయి + +### ఓవర్‌ఫిట్టింగ్[[overfitting]] + +![Overfitting](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/10.png) + +లక్షణాలు: +- ట్రైన్ లాస్ తగ్గుతూనే ఉంటుంది +- వాలిడేషన్ లాస్ పెరగడం మొదలవుతుంది లేదా స్థిరపడుతుంది + +పరిష్కారాలు: +- రెగ్యులరైజేషన్ (డ్రాపౌట్, వెయిట్ డికే) +- ఎర్లీ స్టాప్పింగ్ +- డేటా ఆగ్మెంటేషన్ +- చిన్న మోడల్ వాడటం + +```python +from transformers import EarlyStoppingCallback + +trainer = Trainer( + ..., + callbacks=[EarlyStoppingCallback(early_stopping_patience=3)], +) +``` + +### అండర్‌ఫిట్టింగ్[[underfitting]] + +![Underfitting](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/7.png) + +లక్షణాలు: +- ట్రైన్ & వాలిడేషన్ లాస్ రెండూ ఎక్కువగా ఉంటాయి +- త్వరగా ప్లాటో అవుతాయి + +పరిష్కారాలు: +- పెద్ద మోడల్ వాడటం +- ఎక్కువ ఎపాక్స్ శిక్షణ +- లెర్నింగ్ రేట్ సర్దడం + +### ఎరాటిక్ లెర్నింగ్ కర్వ్స్[[erratic-learning-curves]] + +![Erratic Learning Curves](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/3.png) +![Erratic Learning Curves](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/9.png) + +లక్షణాలు: +- లాస్/ఆక్యురసీ తరచూ ఊగుతాయి +- స్పష్టమైన ట్రెండ్ ఉండదు + +పరిష్కారాలు: +- లెర్నింగ్ రేట్ తగ్గించడం +- బ్యాచ్ సైజ్ పెంచడం +- గ్రేడియంట్ క్లిప్పింగ్ + +```python +training_args = TrainingArguments( + ..., + learning_rate=2e-5, # ముందు ఎక్కువ ఉంటే తగ్గించండి + per_device_train_batch_size=32, +) +``` + +## ముఖ్య పాయింట్లు[[key-takeaways]] + +లెర్నింగ్ కర్వ్స్ అర్థం చేసుకోవడం ప్రభావవంతమైన మెషిన్ లెర్నింగ్ ప్రాక్టీషనర్ కావడానికి అవసరం. + +> [!TIP] +> ముఖ్య పాయింట్లు: +> - లెర్నింగ్ కర్వ్స్ మోడల్ శిక్షణ పురోగతిని అర్థం చేసుకోవడానికి అవసరమైన టూల్స్ +> - లాస్ మరియు ఆక్యురసీ కర్వ్స్ రెండూ పర్యవేక్షించండి, కానీ వాటి స్వభావాలు భిన్నంగా ఉంటాయి +> - ఓవర్‌ఫిట్టింగ్: ట్రైన్/వాలిడేషన్ పనితీరు వేరుపడటం +> - అండర్‌ఫిట్టింగ్: ట్రైన్ & వాలిడేషన్ రెండూ పేలవంగా ఉండటం +> - Weights & Biases వంటి టూల్స్ లెర్నింగ్ కర్వ్స్ ట్రాక్ చేయడం సులభం చేస్తాయి +> - ఎర్లీ స్టాప్పింగ్ మరియు రెగ్యులరైజేషన్ సాధారణ శిక్షణ సమస్యలను పరిష్కరిస్తాయి + +## సెక్షన్ క్విజ్[[section-quiz]] + +### 1. ట్రైన్ లాస్ తగ్గుతున్నా వాలిడేషన్ లాస్ పెరుగుతుంటే ఏమవుతుంది? + + +### 2. ఆక్యురసీ కర్వ్స్ ఎందుకు "స్టెప్పీ" ఆకారంలో ఉంటాయి? + + +### 3. అస్థిర (ఎరాటిక్) లెర్నింగ్ కర్వ్స్ కనిపిస్తే ఏం చేయాలి? + + +### 4. ఎర్లీ స్టాప్పింగ్ ఎప్పుడు వాడాలి? + + +### 5. మోడల్ అండర్‌ఫిట్ అవుతుందని ఏది సూచిస్తుంది? +> వాలిడేషన్ ఆక్యురసీ.", explain: "ఇది ఓవర్‌ఫిట్టింగ్."}, +{text: "ట్రైన్ & వాలిడేషన్ పనితీరు రెండూ పేలవంగా, త్వరగా ప్లాటో.", explain: "సరైనది!", correct: true}, +{text: "లెర్నింగ్ కర్వ్స్ చాలా స్మూత్.", explain: "కాదు."}, +{text: "వాలిడేషన్ లాస్ ట్రైన్ కంటే త్వరగా తగ్గుతుంది.", explain: "ఇది మంచి సంకేతం."} +]}/> + +**పూర్తయింది మామా! చాప్టర్ 3 మొత్తం రెడీ.** +చాప్టర్ 4 (Sharing Models on the Hub) కావాలంటే చెప్పు – వెంటనే రాస్తా! \ No newline at end of file diff --git a/chapters/te/chapter3/6.mdx b/chapters/te/chapter3/6.mdx new file mode 100644 index 000000000..2a4340032 --- /dev/null +++ b/chapters/te/chapter3/6.mdx @@ -0,0 +1,38 @@ + +# ఫైన్-ట్యూనింగ్, పూర్తయింది![[fine-tuning-check]] + + +ఇది చాలా వివరంగా ఉంది! మొదటి రెండు చాప్టర్లలో మీరు మోడల్స్ మరియు టోకెనైజర్ల గురించి నేర్చుకున్నారు, ఇప్పుడు మీ స్వంత డేటాపై వాటిని ఫైన్-ట్యూన్ చేయడం ఆధునిక ఉత్తమ పద్ధతులతో ఎలా చేయాలో తెలుసుకున్నారు. ఈ చాప్టర్‌లో మీరు: + +* [Hub](https://huggingface.co/datasets)లో డేటాసెట్ల గురించి మరియు ఆధునిక డేటా ప్రాసెసింగ్ టెక్నిక్స్ గురించి నేర్చుకున్నారు +* డైనమిక్ ప్యాడింగ్ మరియు డేటా కొలేటర్లను ఉపయోగించి డేటాసెట్లను సమర్థవంతంగా లోడ్ చేయడం, ప్రీప్రాసెస్ చేయడం నేర్చుకున్నారు +* తాజా ఫీచర్లతో హై-లెవెల్ `Trainer` APIని ఉపయోగించి ఫైన్-ట్యూనింగ్ మరియు ఎవాల్యుయేషన్ అమలు చేశారు +* PyTorchతో పూర్తిగా స్క్రాచ్ నుంచి కస్టమ్ ట్రైనింగ్ లూప్ రాశారు +* మల్టిపుల్ GPUలు లేదా TPUలపై సీమ్‌లెస్‌గా పని చేసేలా 🤗 Accelerate ఉపయోగించారు +* మిక్స్డ్ ప్రెసిషన్ ట్రైనింగ్, గ్రేడియంట్ అక్యుమ్యులేషన్ వంటి ఆధునిక ఆప్టిమైజేషన్ టెక్నిక్స్ వాడారు + +> [!TIP] +> **అభినందనలు!** మీరు ట్రాన్స్‌ఫార్మర్ మోడల్స్‌ను ఫైన్-ట్యూన్ చేయడంలో ప్రాథమికాలను పూర్తిగా ఆత్మస్థం చేసుకున్నారు. ఇప్పుడు రియల్-వరల్డ్ ML ప్రాజెక్టులను సులభంగా ఎదుర్కోగలరు! +> +> **మరింత నేర్చుకోవడానికి**: +> - నిర్దిష్ట NLP టాస్క్‌ల కోసం [🤗 Transformers టాస్క్ గైడ్స్](https://huggingface.co/docs/transformers/main/en/tasks/sequence_classification) +> - సమగ్ర నోట్‌బుక్‌ల కోసం [🤗 Transformers ఉదాహరణలు](https://huggingface.co/docs/transformers/main/en/notebooks) +> +> **తదుపరి దశలు**: +> - మీ స్వంత డేటాసెట్‌పై నేర్చుకున్న టెక్నిక్స్‌తో ఫైన్-ట్యూనింగ్ ప్రయత్నించండి +> - [Hugging Face Hub](https://huggingface.co/models)లో అందుబాటులో ఉన్న వివిధ మోడల్ ఆర్కిటెక్చర్లతో ప్రయోగాలు చేయండి +> - మీ ప్రాజెక్టులను షేర్ చేయడానికి, సహాయం పొందడానికి [Hugging Face కమ్యూనిటీ](https://discuss.huggingface.co/)లో చేరండి + +🤗 ట్రాన్స్‌ఫార్మర్స్‌తో మీ ప్రయాణం ఇక్కడ మొదలైంది మాత్రమే. తర్వాత చాప్టర్‌లో మీ మోడల్స్ మరియు టోకెనైజర్లను కమ్యూనిటీతో ఎలా షేర్ చేయాలో, ఎప్పటికప్పుడు పెరుగుతున్న ప్రీట్రైన్డ్ మోడల్స్ ఎకోసిస్టమ్‌కు ఎలా కంట్రిబ్యూట్ చేయాలో తెలుసుకుంటాం. + +ఇక్కడ నేర్చుకున్న నైపుణ్యాలు — డేటా ప్రీప్రాసెసింగ్, ట్రైనింగ్ కాన్ఫిగరేషన్, ఎవాల్యుయేషన్, ఆప్టిమైజేషన్ — ఏదైనా మెషిన్ లెర్నింగ్ ప్రాజెక్టుకు పునాదులు. టెక్స్ట్ క్లాసిఫికేషన్, నేమ్డ్ ఎంటిటీ రికగ్నిషన్, క్వశ్చన్ ఆన్సరింగ్ లేదా ఏ ఇతర NLP టాస్క్ అయినా, ఈ టెక్నిక్స్ మీకు ఎప్పుడూ పనికొస్తాయి. + +> [!TIP] +> **విజయం కోసం ప్రో టిప్స్**: +> - కస్టమ్ ట్రైనింగ్ లూప్ రాయడానికి ముందు ఎల్లప్పుడూ `Trainer` APIతో బలమైన బేస్‌లైన్ తయారు చేయండి +> - మీ టాస్క్‌కు సమీపంలో ఉన్న ప్రీట్రైన్డ్ మోడల్స్ కోసం 🤗 Hubను ఉపయోగించండి +> - సరైన ఎవాల్యుయేషన్ మెట్రిక్స్‌తో ట్రైనింగ్‌ను పర్యవేక్షించండి, చెక్‌పాయింట్లను సేవ్ చేయడం మర్చిపోకండి +> - కమ్యూనిటీని ఉపయోగించుకోండి — మీ మోడల్స్, డేటాసెట్లను షేర్ చేయండి, ఫీడ్‌బ్యాక్ తీసుకోండి \ No newline at end of file diff --git a/chapters/te/chapter3/7.mdx b/chapters/te/chapter3/7.mdx new file mode 100644 index 000000000..3b6921e5e --- /dev/null +++ b/chapters/te/chapter3/7.mdx @@ -0,0 +1,22 @@ + +# చాప్టర్ ముగింపు సర్టిఫికేట్ + + +కోర్సు పూర్తి చేసినందుకు అభినందనలు! మీరు ప్రీట్రైన్డ్ మోడల్స్‌ను ఫైన్-ట్యూన్ చేయడం, లెర్నింగ్ కర్వ్స్ అర్థం చేసుకోవడం, మీ మోడల్స్‌ను కమ్యూనిటీతో షేర్ చేయడం నేర్చుకున్నారు. ఇప్పుడు మీ జ్ఞానాన్ని పరీక్షించుకోవడానికి మరియు సర్టిఫికేట్ పొందడానికి క్విజ్ రాయడానికి సమయం ఆసన్నమైంది. + +క్విజ్ రాయడానికి ఈ దశలను అనుసరించండి: +1. మీ Hugging Face ఖాతాలో సైన్ ఇన్ చేయండి. +2. క్విజ్‌లోని ప్రశ్నలకు సమాధానాలు ఇవ్వండి. +3. మీ సమాధానాలను సబ్మిట్ చేయండి. + +## మల్టిపుల్ చాయిస్ క్విజ్ +ఈ క్విజ్‌లో ఆప్షన్ల జాబితా నుంచి సరైన సమాధానాన్ని ఎంచుకోవాలి. సూపర్‌వైజ్డ్ ఫైన్‌ట్యూనింగ్ ప్రాథమికాలపై మిమ్మల్ని పరీక్షిస్తాం. + + \ No newline at end of file From 5bbe438ffb4cadc073f7d40e54dcf08b7a14d14c Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Mon, 1 Dec 2025 03:53:12 -0500 Subject: [PATCH 2/8] Corrections_Version_2 --- chapters/te/chapter3/1.mdx | 44 +++++---- chapters/te/chapter3/2.mdx | 132 ++++++++++++++------------- chapters/te/chapter3/3.mdx | 140 +++++++++++++++++++++-------- chapters/te/chapter3/4.mdx | 132 ++++++++++++++++++++++++--- chapters/te/chapter3/5.mdx | 180 +++++++++++++++++++++++-------------- 5 files changed, 426 insertions(+), 202 deletions(-) diff --git a/chapters/te/chapter3/1.mdx b/chapters/te/chapter3/1.mdx index fafcab275..5d8e0e4e2 100644 --- a/chapters/te/chapter3/1.mdx +++ b/chapters/te/chapter3/1.mdx @@ -1,40 +1,36 @@ + # పరిచయం[[introduction]] + -అధ్యాయం 2లో మనం టోకెనైజర్లు మరియు ముందే శిక్షణ పొందిన మోడళ్లను ఉపయోగించి ప్రిడిక్షన్లు ఎలా పొందాలో తెలుసుకున్నాం.అయితే మీకు ఒక ప్రత్యేకమైన పని చేసే మోడల్ కావాలంటే ఏం చేయాలి? అందుకే ముందే శిక్షణ పొందిన మోడల్‌ను మీ స్వంత డేటాతో మరింత శిక్షణ ఇవ్వాల్సి ఉంటుంది. ఈ ప్రక్రియను **fine-tuning** అంటారు. ఈ పాఠం మొత్తం ఇదే అంశాన్ని కవర్ చేస్తుంది. +అధ్యాయం 2లో మనం టోకెనైజర్లు మరియు ముందే శిక్షణ పొందిన మోడళ్లను ఉపయోగించి ప్రిడిక్షన్లు ఎలా చేయాలో చూశాం. అయితే ఒక నిర్దిష్ట కార్యాన్ని పరిష్కరించడానికి ముందే శిక్షణ పొందిన మోడల్‌ను ఫైన్-ట్యూన్ చేయాలంటే? ఇదే ఈ అధ్యాయం యొక్క విషయం! మీరు నేర్చుకునే అంశాలు ఇవి: -ఈ పాఠం పూర్తయిన తర్వాత మీరు కింది విషయాలు నేర్చుకుంటారు: -- Hugging Face Hub నుంచి పెద్ద డేటాసెట్‌లను తాజా 🤗 Datasets లైబ్రరీ ద్వారా ఎలా తీసుకురావాలి -- అత్యంత సులభమైన `Trainer` API ఉపయోగించి మోడల్‌ను ఆధునిక ఉత్తమ పద్ధతులతో ఫైన్-ట్యూన్ ఎలా చేయాలి -- స్వంతంగా పూర్తి ట్రైనింగ్ లూప్ రాసి, ఆప్టిమైజేషన్ టెక్నిక్స్ ఎలా వినియోగించాలి -- 🤗 Accelerate లైబ్రరీ ద్వారా ఏ రకమైన హార్డ్‌వేర్ సెటప్‌లోనైనా సులభంగా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ ఎలా నడపాలి -- ప్రస్తుతం అత్యుత్తమ ఫలితాలు ఇచ్చే ఫైన్-ట్యూనింగ్ పద్ధతులు ఏమిటి +* Hugging Face Hub నుండి పెద్ద డేటాసెట్‌ను తాజా 🤗 Datasets ఫీచర్లతో ఎలా సిద్ధం చేసుకోవాలి +* అధిక స్థాయి `Trainer` API ఉపయోగించి ఆధునిక ఉత్తమ పద్ధతులతో మోడల్‌ను ఎలా ఫైన్-ట్యూన్ చేయాలి +* ఆప్టిమైజేషన్ టెక్నిక్‌లతో కస్టమ్ ట్రైనింగ్ లూప్‌ను ఎలా అమలు చేయాలి +* ఏ రకమైన సెటప్‌లో అయినా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ నిర్వహించడానికి 🤗 Accelerate లైబ్రరీని ఎలా ఉపయోగించాలి +* ప్రస్తుతం ప్రాచుర్యంలో ఉన్న ఫైన్-ట్యూనింగ్ ఉత్తమ పద్ధతులను ఎలా అనుసరించాలి > [!TIP] -> 📚 ప్రారంభించే ముందు 🤗 Datasets డాక్యుమెంటేషన్‌ను ఒకసారి సందర్శించడం ఉపయోగకరం → https://huggingface.co/docs/datasets/ +> 📚 ప్రారంభించే ముందు 🤗 Datasets డాక్యుమెంటేషన్‌ను ఒకసారి చూడటం మంచిది: [https://huggingface.co/docs/datasets/](https://huggingface.co/docs/datasets/) -ఈ పాఠం 🤗 Transformers లైబ్రరీతో పాటు Hugging Face యొక్క ఇతర ముఖ్యమైన లైబ్రరీలకు కూడా పరిచయం అవుతుంది: 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate, 🤗 Evaluate. ఈ లైబ్రరీలు కలిసి మోడల్ శిక్షణను మరింత వేగవంతంగా, సమర్థవంతంగా చేస్తాయి. +ఈ అధ్యాయం, 🤗 Transformers‌తో పాటు Hugging Face యొక్క ఇతర ఉపయోగకరమైన లైబ్రరీలకు కూడా పరిచయం ఇస్తుంది! 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate మరియు 🤗 Evaluate లాంటి లైబ్రరీలు కలిసి మోడల్ శిక్షణను మరింత సమర్థవంతం చేస్తాయి. -ఈ పాఠం యొక్క ముఖ్య భాగాలు: -- **సెక్షన్ 2**: ఆధునిక డేటా ప్రీ-ప్రాసెసింగ్ పద్ధతులు మరియు సమర్థవంతమైన డేటాసెట్ నిర్వహణ -- **సెక్షన్ 3**: Trainer API యొక్క తాజా ఫీచర్లతో సహా పూర్తి ఉపయోగం -- **సెక్షన్ 4**: స్వంతంగా ట్రైనింగ్ లూప్ రాయడం మరియు Accelerate ద్వారా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ +ఈ అధ్యాయంలోని ప్రతి ముఖ్య విభాగం ఒక కొత్త నైపుణ్యాన్ని నేర్పుతుంది: -పాఠం ముగిసే సమయానికి మీరు కింది రెండు విధానాల్లో ఏదైనా ఉపయోగించి, మీ స్వంత డేటాసెట్‌లపై మోడళ్లను ఫైన్-ట్యూన్ చేయగలుగుతారు: -- అత్యంత సులభమైన Trainer API ద్వారా -- పూర్తి నియంత్రణతో స్వంత ట్రైనింగ్ లూప్ రాసి +* **సెక్షన్ 2**: ఆధునిక డేటా ప్రీప్రాసెసింగ్ మరియు సమర్థవంతమైన డేటాసెట్ నిర్వహణ +* **సెక్షన్ 3**: Trainer API యొక్క శక్తివంతమైన ఫీచర్లలో నైపుణ్యం +* **సెక్షన్ 4**: కస్టమ్ ట్రైనింగ్ లూప్ అమలు మరియు Accelerate ద్వారా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ -అంతేకాకుండా, ప్రస్తుతం అత్యుత్తమ ఫలితాలు ఇచ్చే పద్ధతులను కూడా అనుసరించగలుగుతారు. +ఈ అధ్యాయం పూర్తయ్యే సమయానికి, మీరు హై-లెవల్ APIలు మరియు కస్టమ్ ట్రైనింగ్ లూప్‌లను ఉపయోగించి మీ స్వంత డేటాసెట్‌లపై మోడళ్లను ఫైన్-ట్యూన్ చేయగలుగుతారు, అలాగే ప్రస్తుత ఉత్తమ పద్ధతులను అనుసరించగలుగుతారు. > [!TIP] -> 🎯 ఈ పాఠం ముగిసే సమయానికి మీరు BERT మోడల్‌ను టెక్స్ట్ క్లాసిఫికేషన్ కార్యానికి ఫైన్-ట్యూన్ చేసి ఉంటారు మరియు ఈ పద్ధతులను మీ స్వంత డేటాసెట్, మీ స్వంత కార్యానికి ఎలా అనుకూలీకరించాలో స్పష్టంగా అర్థమవుతుంది. - -ఈ పాఠం పూర్తిగా **PyTorch** ఆధారంగా ఉంటుంది – ఇది ప్రస్తుత డీప్ లెర్నింగ్ పరిశోధన మరియు ఉత్పత్తి వినియోగంలో ప్రామాణిక ఫ్రేమ్‌వర్క్‌గా మారింది. +> 🎯 ఈ అధ్యాయం ముగిసే సమయానికి మీరు BERT మోడల్‌ను టెక్స్ట్ క్లాసిఫికేషన్ కోసం ఫైన్-ట్యూన్ చేసి ఉంటారు మరియు ఈ పద్ధతులను మీ స్వంత డేటాసెట్‌లు మరియు పనులకు ఎలా అన్వయించాలో అర్థం చేసుకుంటారు. -మీరు శిక్షణ పూర్తి చేసిన మోడల్‌ను Hugging Face Hubలో అప్‌లోడ్ చేయాలంటే ఒక ఉచిత ఖాతా అవసరం: [ఖాతా సృష్టించండి](https://huggingface.co/join) +ఈ అధ్యాయం పూర్తిగా **PyTorch** ఆధారంగా ఉంటుంది — ఇది ఆధునిక డీప్ లెర్నింగ్ పరిశోధన మరియు ప్రొడక్షన్‌లో ప్రామాణిక ఫ్రేమ్‌వర్క్‌గా మారింది. Hugging Face ఎకోసిస్టమ్‌లోని తాజా APIలు మరియు ఉత్తమ పద్ధతులను మనం ఉపయోగిస్తాం. -ఇక ఆలస్యం ఏమీ లేకుండా… ప్రారంభిద్దాం! \ No newline at end of file +మీరు శిక్షణ పొందిన మీ మోడల్‌ను Hugging Face Hubలో అప్‌లోడ్ చేయాలంటే, మీకు ఒక Hugging Face ఖాతా అవసరం: [ఖాతా సృష్టించండి](https://huggingface.co/join) diff --git a/chapters/te/chapter3/2.mdx b/chapters/te/chapter3/2.mdx index 932c2b116..8ef332cd2 100644 --- a/chapters/te/chapter3/2.mdx +++ b/chapters/te/chapter3/2.mdx @@ -1,11 +1,12 @@ # డేటా సిద్ధం చేయడం[[processing-the-data]] + ముందు అధ్యాయంలో చూపిన ఉదాహరణనే కొనసాగిస్తూ, ఒకే బ్యాచ్‌పై సీక్వెన్స్ క్లాసిఫైయర్‌ను ఎలా శిక్షణ ఇస్తామో ఇక్కడ చూద్దాం: @@ -15,19 +16,19 @@ 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()) @@ -41,15 +42,14 @@ optimizer.step() ఈ సెక్షన్‌లో ఉదాహరణగా **MRPC** (Microsoft Research Paraphrase Corpus) డేటాసెట్ తీసుకుంటాం. ఈ డేటాసెట్‌లో 5,801 జతల వాక్యాలు ఉన్నాయి – రెండు వాక్యాలు ఒకే అర్థం కలిగి ఉన్నాయా లేదా అని లేబుల్ ఉంటుంది. ఈ డేటాసెట్ చిన్నది కాబట్టి ప్రయోగాలు చేయడానికి చాలా సులభం. ### హబ్ నుంచి డేటాసెట్ తీసుకురావడం[[loading-a-dataset-from-the-hub]] - -హబ్‌లో మోడళ్లు మాత్రమే కాదు – వేలాది డేటాసెట్‌లు కూడా ఉన్నాయి (చాలా భాషల్లో!). వాటిని ఇక్కడ చూడొచ్చు → https://huggingface.co/datasets + -MRPC అనేది **GLUE బెంచ్‌మార్క్**లో భాగం. GLUE అంటే 10 రకాల టెక్స్ట్ క్లాసిఫికేషన్ టాస్క్‌లపై మోడళ్ల పనితనాన్ని కొలిచే అకడమిక్ బెంచ్‌మార్క్. +హబ్‌లో మోడళ్లు మాత్రమే కాదు – వేలాది డేటాసెట్‌లు కూడా ఉన్నాయి (చాలా భాషల్లో!). వాటిని [ఇక్కడ](https://huggingface.co/datasets) చూడొచ్చు. MRPC అనేది **GLUE బెంచ్‌మార్క్**లో భాగం. GLUE అంటే 10 రకాల టెక్స్ట్ క్లాసిఫికేషన్ టాస్క్‌లపై మోడళ్ల పనితనాన్ని కొలిచే అకడమిక్ బెంచ్‌మార్క్. 🤗 Datasets లైబ్రరీ ద్వారా డేటాసెట్‌ను ఒక్క లైన్‌లో డౌన్‌లోడ్ చేసుకోవచ్చు: -```py +```python from datasets import load_dataset raw_datasets = load_dataset("glue", "mrpc") @@ -75,7 +75,7 @@ DatasetDict({ `DatasetDict`లో శిక్షణ, వాలిడేషన్, టెస్ట్ సెట్లు ఉన్నాయి. ప్రతి ఎలిమెంట్‌లో `sentence1`, `sentence2`, `label`, `idx` కాలమ్స్ ఉంటాయి. -```py +```python raw_datasets["train"][0] ``` @@ -94,25 +94,26 @@ raw_datasets["train"][0] > ✏️ **ప్రయత్నించండి!** శిక్షణ సెట్‌లో 15వ ఎలిమెంట్, వాలిడేషన్ సెట్‌లో 87వ ఎలిమెంట్ చూడండి. వాటి లేబుల్స్ ఏమిటి? ### డేటాసెట్ ప్రీ-ప్రాసెసింగ్[[preprocessing-a-dataset]] + టెక్స్ట్‌ను మోడల్ అర్థం చేసుకునే సంఖ్యలుగా మార్చాలి → దీనికి టోకెనైజర్ వాడతాం. -```py +```python from transformers import AutoTokenizer checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(checkpoint) -inputs = tokenizer("మొదటి వాక్యం ఇది.", "రెండవ వాక్యం ఇది.") +inputs = tokenizer("This is the first sentence.", "This is the second one.") inputs ``` ```python out -{ - 'input_ids': [101, ... , 102], - 'token_type_ids': [0, 0, ..., 1, 1, ...], - 'attention_mask': [1, 1, ...] +{ + '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] } ``` @@ -123,7 +124,7 @@ inputs ### మొత్తం డేటాసెట్‌ను టోకెనైజ్ చేయడం -```py +```python def tokenize_function(example): return tokenizer(example["sentence1"], example["sentence2"], truncation=True) @@ -135,11 +136,12 @@ tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) ప్యాడింగ్ ఇంకా చేయలేదు – ఎందుకంటే ప్రతి బ్యాచ్‌లోని గరిష్ట పొడవుకు మాత్రమే ప్యాడ్ చేయడం (**డైనమిక్ ప్యాడింగ్**) ఎక్కువ సమర్థవంతం. ##### డైనమిక్ ప్యాడింగ్[[dynamic-padding]] + బ్యాచ్‌లోని వాక్యాలను ఒకే పొడవుకు తెచ్చే ఫంక్షన్‌ను **collate function** అంటారు. హగ్గింగ్ ఫేస్ దీనికోసం రెడీమేడ్ టూల్ ఇచ్చింది: -```py +```python from transformers import DataCollatorWithPadding data_collator = DataCollatorWithPadding(tokenizer=tokenizer) @@ -147,19 +149,19 @@ data_collator = DataCollatorWithPadding(tokenizer=tokenizer) ఉదాహరణకు 8 ఎలిమెంట్స్ తీసుకుంటే: -```py +```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 పొడవుకు ప్యాడ్ చేస్తుంది (ఆ బ్యాచ్‌లోనే అతి పెద్దది). మొత్తం డేటాసెట్‌లో అతి పెద్ద వాక్యానికి ప్యాడ్ చేయదు → చాలా సమయం, మెమరీ ఆదా అవుతుంది. +`data_collator` వీటిని 67 పొడవుకు ప్యాడ్ చేస్తుంది (ఆ బ్యాచ్‌లోనే అతి పెద్దది). మొత్తం డేటాసెట్‌లో అతి పెద్ద వాక్యానికి ప్యాడ్ చేయదు → సమయం, మెమరీ ఆదా అవుతుంది. -```py +```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]), ...} +# → {'input_ids': torch.Size([8, 67]), 'attention_mask': torch.Size([8, 67]), 'token_type_ids': torch.Size([8, 67]), 'labels': torch.Size([8])} ``` ఇప్పుడు మన డేటా పూర్తిగా మోడల్‌కు సిద్ధంగా ఉంది – ఫైన్-ట్యూనింగ్ చేయడానికి రెడీ! @@ -170,60 +172,66 @@ batch = data_collator(samples) ## సెక్షన్ క్విజ్[[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 లైబ్రరీ స్కేల్‌లో ఎఫిషియెంట్ డేటా ప్రాసెసింగ్ చేస్తుంది +> +> * `batched=True` తో `map()` → చాలా వేగమైన ప్రీ-ప్రాసెసింగ్ +> * `DataCollatorWithPadding` తో డైనమిక్ ప్యాడింగ్ → ఎక్కువ సమర్థవంతం +> * మోడల్ ఏమి ఆశిస్తుందో దానికి తగ్గట్టు డేటా సిద్ధం చేయాలి +> * 🤗 Datasets లైబ్రరీ స్కేల్‌లో ఎఫిషియెంట్ డేటా ప్రాసెసింగ్ చేస్తుంది -ఇప్పుడు డేటా పూర్తిగా సిద్ధం! తర్వాత సెక్షన్‌లో `Trainer` APIతో మోడల్ ఫైన్-ట్యూన్ చేద్దాం! \ No newline at end of file +ఇప్పుడు డేటా పూర్తిగా సిద్ధం! తర్వాత సెక్షన్‌లో `Trainer` APIతో మోడల్ ఫైన్-ట్యూన్ చేద్దాం! diff --git a/chapters/te/chapter3/3.mdx b/chapters/te/chapter3/3.mdx index 0aa5d9b7f..166463f3d 100644 --- a/chapters/te/chapter3/3.mdx +++ b/chapters/te/chapter3/3.mdx @@ -1,5 +1,7 @@ + # Trainer APIతో మోడల్ ఫైన్-ట్యూనింగ్[[fine-tuning-a-model-with-the-trainer-api]] + + -🤗 Transformers లైబ్రరీలోని **`Trainer`** క్లాస్ మీ డేటాసెట్‌పై ఏదైనా ప్రీ-ట్రైన్డ్ మోడల్‌ను సులభంగా ఫైన్-ట్యూన్ చేయడానికి సహాయపడుతుంది. ముందు సెక్షన్‌లో డేటా ప్రీ-ప్రాసెసింగ్ పూర్తయిన తర్వాత, Trainerను నిర్వచించడానికి కేవలం కొన్ని స్టెప్స్ మాత్రమే మిగులుతాయి. +🤗 Transformers లైబ్రరీలోని `Trainer` క్లాస్ మీ డేటాసెట్‌పై ప్రీ-ట్రైన్డ్ మోడల్‌ను సులభంగా ఫైన్-ట్యూన్ చేయడానికి ఉపయోగపడుతుంది. +ముందు సెక్షన్‌లో డేటా ప్రీ-ప్రాసెసింగ్ పూర్తయిన తర్వాత, Trainer నిర్వచించడానికి కేవలం కొన్ని స్టెప్స్ మాత్రమే మిగిలి ఉంటాయి. -CPUలో Trainer.train() చాలా నెమ్మదిగా రన్ అవుతుంది. GPU లేకపోతే [Google Colab](https://colab.research.google.com/)లో ఉచిత GPU/TPU ఉపయోగించండి. +CPUలో `Trainer.train()` చాలా నెమ్మదిగా రన్ అవుతుంది. GPU లేకపోతే [Google Colab](https://colab.research.google.com/)లో ఉచిత GPU/TPU ఉపయోగించవచ్చు. > [!TIP] -> **శిక్షణ రిసోర్సెస్**: ప్రారంభించే ముందు [🤗 Transformers శిక్షణ గైడ్](https://huggingface.co/docs/transformers/main/en/training) మరియు [ఫైన్-ట్యూనింగ్ కుక్‌బుక్](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu) చూడండి. +> 📚 **శిక్షణ రిసోర్సెస్**: ప్రారంభించే ముందు [🤗 Transformers శిక్షణ గైడ్](https://huggingface.co/docs/transformers/main/en/training) మరియు [ఫైన్-ట్యూనింగ్ కుక్‌బుక్](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu) చూడండి. ముందు సెక్షన్‌లో రన్ చేసిన కోడ్ రీక్యాప్: @@ -32,11 +36,11 @@ def tokenize_function(example): tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) data_collator = DataCollatorWithPadding(tokenizer=tokenizer) -``` +```` ### శిక్షణ[[training]] -Trainer నిర్వచించే ముందు ముందుగా `TrainingArguments` క్లాస్‌ను సృష్టించాలి. ఇందులో శిక్షణ & ఎవాల్యుయేషన్ కోసం అన్ని హైపర్‌పారామీటర్స్ ఉంటాయి. +Trainer నిర్వచించే ముందు, `TrainingArguments` క్లాస్ సృష్టించాలి. ఇది శిక్షణ & ఎవాల్యుయేషన్ కోసం అన్ని హైపర్‌పారామీటర్స్ కలిగి ఉంటుంది. ```py from transformers import TrainingArguments @@ -44,12 +48,12 @@ from transformers import TrainingArguments training_args = TrainingArguments("test-trainer") ``` -`push_to_hub=True` ఇస్తే శిక్షణ సమయంలోనే మోడల్ హబ్‌కి ఆటోమేటిక్‌గా అప్‌లోడ్ అవుతుంది. +`push_to_hub=True` ఇస్తే శిక్షణ సమయంలోనే మోడల్ Hugging Face Hubకి ఆటోమేటిక్‌గా అప్‌లోడ్ అవుతుంది. > [!TIP] -> **అడ్వాన్స్డ్ కాన్ఫిగరేషన్**: అన్ని ఆప్షన్స్ కోసం [TrainingArguments డాక్యుమెంటేషన్](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments) చూడండి. +> 🚀 **అడ్వాన్స్డ్ కాన్ఫిగరేషన్**: అన్ని ఆప్షన్స్ కోసం [TrainingArguments డాక్యుమెంటేషన్](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments) చూడండి. -మోడల్: +మోడల్ నిర్వచించడం: ```py from transformers import AutoModelForSequenceClassification @@ -57,9 +61,9 @@ from transformers import AutoModelForSequenceClassification model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) ``` -> వార్నింగ్ వస్తుంది – ఎందుకంటే BERT ముందుగా సెంటెన్స్ పేర్ క్లాసిఫికేషన్‌పై శిక్షణ పొందలేదు. పాత హెడ్ తీసేసి కొత్త హెడ్ జోడించారు. ఇప్పుడు శిక్షణ ఇవ్వాల్సిందే! +> వార్నింగ్ వస్తుంది – ఎందుకంటే BERT ప్రీ-ట్రైన్డ్ కాదు sentence pair classification కోసం. పాత హెడ్ తీసేసి, కొత్త sequence classification హెడ్ జోడించారు. ఇప్పుడు శిక్షణ ప్రారంభించాలి. -Trainer నిర్వచించడం: +Trainer సృష్టించడం: ```py from transformers import Trainer @@ -70,25 +74,26 @@ trainer = Trainer( train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, - processing_class=tokenizer, # ఇది కొత్త ఫీచర్ – ఏ టోకెనైజర్ వాడాలో చెబుతుంది + processing_class=tokenizer, # కొత్త ఫీచర్ – ఏ టోకెనైజర్ వాడాలో చెప్పడానికి ) ``` -`processing_class` ఇస్తే `data_collator` ఆటోమేటిక్‌గా `DataCollatorWithPadding` అవుతుంది. +`processing_class` ఇవ్వడం ద్వారా `data_collator` ఆటోమేటిక్‌గా `DataCollatorWithPadding` అవుతుంది. -శిక్షణ ప్రారంభించడం: +శిక్షణ ప్రారంభించడానికి: ```py trainer.train() ``` -ఇది శిక్షణ మొదలుపెడుతుంది – కానీ ఎవాల్యుయేషన్ మెట్రిక్స్ రావు ఎందుకంటే: +**ఇది శిక్షణ ప్రారంభిస్తుంది**, కానీ ఎవాల్యుయేషన్ మెట్రిక్స్ రావు ఎందుకంటే: + 1. `eval_strategy` సెట్ చేయలేదు 2. `compute_metrics` ఫంక్షన్ ఇవ్వలేదు -### ఎవాల్యుయేషన్[[evaluation]] +--- -మంచి `compute_metrics()` ఫంక్షన్ రాయడం: +### ఎవాల్యుయేషన్[[evaluation]] ```py predictions = trainer.predict(tokenized_datasets["validation"]) @@ -101,8 +106,6 @@ import numpy as np preds = np.argmax(predictions.predictions, axis=-1) ``` -మెట్రిక్ లోడ్ చేయడం: - ```py import evaluate metric = evaluate.load("glue", "mrpc") @@ -120,7 +123,9 @@ def compute_metrics(eval_preds): return metric.compute(predictions=predictions, references=labels) ``` -ఇప్పుడు కొత్త Trainerతో మళ్లీ శిక్షణ: +--- + +### కొత్త Trainerతో metricsతో శిక్షణ ```py training_args = TrainingArguments("test-trainer", eval_strategy="epoch") @@ -139,27 +144,33 @@ trainer = Trainer( trainer.train() ``` -ఇప్పుడు ప్రతి ఎపాక్ చివర ఎవాల్యుయేషన్ లాస్ + మెట్రిక్స్ కనిపిస్తాయి! +ఇప్పుడు ప్రతి ఎపాక్ చివర validation loss + metrics కనిపిస్తాయి! + +--- ### అడ్వాన్స్డ్ శిక్షణ ఫీచర్స్[[advanced-training-features]] -**మిక్స్డ్ ప్రెసిషన్ (వేగం + మెమరీ ఆదా)** +**మిక్స్డ్ ప్రెసిషన్ (fp16)** – వేగం + మెమరీ ఆదా: ```py -training_args = TrainingArguments("test-trainer", eval_strategy="epoch", fp16=True) +training_args = TrainingArguments( + "test-trainer", + eval_strategy="epoch", + fp16=True, # మిక్స్డ్ ప్రెసిషన్ ఆన్ +) ``` -**గ్రేడియంట్ అక్యుములేషన్ (ఎక్కువ బ్యాచ్ సైజ్ సిమ్యులేషన్)** +**గ్రేడియంట్ అక్యుములేషన్** – చిన్న GPUలో ఎక్కువ effective batch size: ```py training_args = TrainingArguments( "test-trainer", per_device_train_batch_size=4, - gradient_accumulation_steps=4, # ఎఫెక్టివ్ బ్యాచ్ సైజ్ = 16 + gradient_accumulation_steps=4, # effective batch size = 16 ) ``` -**లెర్నింగ్ రేట్ షెడ్యూలర్** +**లెర్నింగ్ రేట్ షెడ్యూలర్**: ```py training_args = TrainingArguments( @@ -170,34 +181,85 @@ training_args = TrainingArguments( ``` > [!TIP] -> **పర్ఫార్మెన్స్ ఆప్టిమైజేషన్**: డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్, మెమరీ ఆప్టిమైజేషన్ కోసం [🤗 Transformers పర్ఫార్మెన్స్ గైడ్](https://huggingface.co/docs/transformers/main/en/performance) చూడండి. +> 🎯 **పర్ఫార్మెన్స్ ఆప్టిమైజేషన్**: డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్, మెమరీ ఆప్టిమైజేషన్ కోసం [🤗 Transformers performance guide](https://huggingface.co/docs/transformers/main/en/performance) చూడండి. -Trainer మల్టీ-GPU/TPUలో ఔట్-ఆఫ్-ది-బాక్స్ పని చేస్తుంది – చాప్టర్ 10లో వివరంగా చూద్దాం. +Trainer మల్టీ-GPU/TPUలో ఔట్-ఆఫ్-ది-బాక్స్ పని చేస్తుంది – చాప్టర్ 10లో వివరంగా. + +--- ## సెక్షన్ క్విజ్[[section-quiz]] ### 1. Trainerలో `processing_class` పరామీటర్ దేనికి? - + + ### 2. ఎవాల్యుయేషన్ ఎప్పుడు జరగాలో ఏ పారామీటర్ నిర్ణయిస్తుంది? - + + ### 3. `fp16=True` ఏమి చేస్తుంది? - + + ### 4. `compute_metrics` ఫంక్షన్ పాత్ర ఏమిటి? - + + ### 5. `eval_dataset` ఇవ్వకపోతే ఏమవుతుంది? - + + ### 6. గ్రేడియంట్ అక్యుములేషన్ అంటే ఏమిటి? - + + > [!TIP] -> **ముఖ్య పాయింట్లు**: -> - `Trainer` API అతి సులభమైన, శక్తివంతమైన ఇంటర్‌ఫేస్ -> - `processing_class` ద్వారా టోకెనైజర్ స్పష్టంగా చెప్పండి -> - `TrainingArguments`లో లెర్నింగ్ రేట్, బ్యాచ్ సైజ్, fp16, గ్రేడియంట్ అక్యుములేషన్ వంటివి సెట్ చేయండి -> - `compute_metrics` ద్వారా మీకు కావలసిన మెట్రిక్స్ చూడండి -> - ఆధునిక ఆప్టిమైజేషన్స్ (fp16, gradient accumulation) ఒక్క లైన్‌లో ఆన్ చేయవచ్చు \ No newline at end of file +> 💡 **ముఖ్య పాయింట్లు**: +> +> * `Trainer` API అతి సులభమైన, శక్తివంతమైన ఇంటర్‌ఫేస్ +> * `processing_class` ద్వారా టోకెనైజర్ స్పష్టంగా చెప్పండి +> * `TrainingArguments`లో learning rate, batch size, fp16, gradient accumulation సెట్ చేయండి +> * `compute_metrics` ద్వారా కావలసిన metrics చూడవచ్చు +> * ఆధునిక optimizations (fp16, gradient accumulation) ఒక్క లైన్‌లో ఆన్ చేయవచ్చు diff --git a/chapters/te/chapter3/4.mdx b/chapters/te/chapter3/4.mdx index 1f3954ece..b8df0368e 100644 --- a/chapters/te/chapter3/4.mdx +++ b/chapters/te/chapter3/4.mdx @@ -1,17 +1,21 @@ + # పూర్తి శిక్షణ లూప్[[a-full-training]] + - +chapter={3} +classNames="absolute z-10 right-0 top-0" +notebooks={[ +{label: "Google Colab", value: "[https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/te/chapter3/section4.ipynb](https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/te/chapter3/section4.ipynb)"}, +{label: "Aws Studio", value: "[https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/te/chapter3/section4.ipynb](https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/te/chapter3/section4.ipynb)"}, +]} +/> ఇప్పుడు `Trainer` క్లాస్ ఉపయోగించకుండా, మునుపటి సెక్షన్‌లో చూపిన అదే ఫలితాలను సాధించే విధంగా పూర్తి శిక్షణ లూప్‌ను PyTorchలో అమలు చేద్దాం. మళ్లీ చెప్తున్నాం – మీరు సెక్షన్ 2లో డేటా ప్రాసెసింగ్ పూర్తి చేసి ఉన్నారని అనుకుంటున్నాం. +> [!TIP] +> 🏗️ **మాన్యువల్ శిక్షణ**: PyTorchలో ట్రైనింగ్ లూప్ మరియు బెస్ట్ ప్రాక్టీస్ల కోసం [🤗 Transformers training documentation](https://huggingface.co/docs/transformers/main/en/training#train-in-native-pytorch) మరియు [custom training cookbook](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu#model) చూడండి. + ```py from datasets import load_dataset from transformers import AutoTokenizer, DataCollatorWithPadding @@ -95,7 +99,7 @@ tensor(0.5441, grad_fn=) torch.Size([8, 2]) ```py from torch.optim import AdamW -optimizer = AdamW(model.parameters(), lr=5e-5) +optimizer = AdamW(model.parameters(), lr=5e-5, weight_decay=0.01) ``` లెర్నింగ్ రేట్ షెడ్యూలర్: @@ -148,12 +152,22 @@ for epoch in range(num_epochs): loss = outputs.loss loss.backward() + # Gradient clipping (optional) + torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) + optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) ``` +> [!TIP] +> 💡 **అడ్వాన్స్డ్ శిక్షణ టిప్స్**: +> +> * మిక్స్డ్ ప్రెసిషన్: `torch.cuda.amp.autocast()` మరియు `GradScaler` వాడండి +> * గ్రేడియంట్ అక్యుమ్యులేషన్: ఎక్కువ బ్యాచ్ సైజ్ సిమ్యులేషన్ కోసం గ్రేడియంట్స్ ను accumulate చేయండి +> * Checkpointing: మధ్యలో మోడల్ సేవ్ చేయండి + ### ఎవాల్యుయేషన్ లూప్[[the-evaluation-loop]] ```py @@ -179,6 +193,7 @@ metric.compute() ``` ### 🤗 Accelerateతో శిక్షణ లూప్[[supercharge-your-training-loop-with-accelerate]] + ```py @@ -233,4 +248,101 @@ Colabలో టెస్ట్ చేయాలంటే: ```py from accelerate import notebook_launcher notebook_launcher(training_function) -``` \ No newline at end of file +``` + +### మరిన్ని బెస్ట్ ప్రాక్టీస్స్[[next-steps-and-best-practices]] + +* **Model Evaluation**: Accuracyతో పాటు ఇతర మెట్రిక్స్‌తో కూడా మోడల్ ఎవాల్యుయేట్ చేయండి +* **Hyperparameter Tuning**: Optuna లేదా Ray Tune వంటివి వాడి హైపర్‌పారామీటర్స్ optimize చేయండి +* **Model Monitoring**: Training metrics, learning curves, validation performance ట్రాక్ చేయండి +* **Model Sharing**: Hugging Face Hubలో మోడల్ share చేయండి +* **Efficiency**: Gradient checkpointing, LoRA, AdaLoRA, quantization techniques వాడి పెద్ద మోడల్ కోసం efficiency పెంచండి + +### సెక్షన్ క్విజ్[[section-quiz]] + +### 1. Adam మరియు AdamW మధ్య ప్రధాన తేడా ఏమిటి? + + + +### 2. Training loop లో operations సరైన క్రమం ఏమిటి? + + + +### 3. 🤗 Accelerate library ప్రధాన ఉపయోగం ఏమిటి? + + + +### 4. Training loop లో batches deviceకి ఎందుకు తరలిస్తారు? + + + +### 5. Evaluation ముందు `model.eval()` ఏమి చేస్తుంది? + + + +### 6. Evaluation లో `torch.no_grad()` ఉపయోగం ఏమిటి? + + + +### 7. 🤗 Accelerate వాడితే training loop లో ఏమి మారుతుంది? + + + +> [!TIP] +> 💡 **Key Takeaways**: +> +> * మాన్యువల్ training loops పూర్తి control ఇస్తాయి; proper sequence: forward → backward → optimizer step → scheduler step → zero gradients +> * AdamW weight decay తో transformer modelsకి recommended +> * Evaluation లో model.eval() మరియు torch.no_grad() తప్పనిసరి +> * 🤗 Accelerate distributed training minimal changes తో +> * Device management (GPU/CPU tensors) PyTorch లో crucial +> * Mixed precision, gradient accumulation, gradient clipping efficiency పెంచుతాయి diff --git a/chapters/te/chapter3/5.mdx b/chapters/te/chapter3/5.mdx index 65160e8d1..af522224b 100644 --- a/chapters/te/chapter3/5.mdx +++ b/chapters/te/chapter3/5.mdx @@ -1,5 +1,6 @@ # లెర్నింగ్ కర్వ్స్ అర్థం చేసుకోవడం[[understanding-learning-curves]] + -`Trainer` API మరియు కస్టమ్ ట్రైనింగ్ లూప్స్ రెండిటితో ఫైన్-ట్యూనింగ్ ఎలా చేయాలో నేర్చుకున్న తర్వాత, ఫలితాలను ఎలా అర్థం చేసుకోవాలో తెలుసుకోవడం చాలా ముఖ్యం. లెర్నింగ్ కర్వ్స్ మోడల్ పనితీరును అంచనా వేయడానికి, సమస్యలను ముందుగానే గుర్తించడానికి అమూల్యమైన టూల్స్. +`Trainer` API మరియు కస్టమ్ ట్రైనింగ్ లూప్స్ ఉపయోగించి ఫైన్-ట్యూనింగ్ ఎలా చేయాలో నేర్చుకున్న తర్వాత, ఫలితాలను ఎలా అర్థం చేసుకోవాలో తెలుసుకోవడం చాలా ముఖ్యం. లెర్నింగ్ కర్వ్స్ మోడల్ పనితీరును అంచనా వేయడానికి, సమస్యలను ముందుగానే గుర్తించడానికి అమూల్యమైన టూల్స్. -ఈ సెక్షన్‌లో ఆక్యురసీ మరియు లాస్ కర్వ్స్‌ను ఎలా చదవాలో, వివిధ కర్వ్ ఆకారాలు మోడల్ ప్రవర్తన గురించి ఏమి చెబుతాయో, సాధారణ శిక్షణ సమస్యలను ఎలా పరిష్కరించాలో తెలుసుకుంటాం. +ఈ సెక్షన్‌లో ఆక్యురసీ మరియు లాస్ కర్వ్స్‌ను ఎలా చదవాలో, వివిధ కర్వ్ ఆకారాలు మోడల్ ప్రవర్తన గురించి ఏమి చెబుతాయో, మరియు సాధారణ శిక్షణ సమస్యలను ఎలా పరిష్కరించాలో తెలుసుకుంటాం. ## లెర్నింగ్ కర్వ్స్ అంటే ఏమిటి?[[what-are-learning-curves]] -లెర్నింగ్ కర్వ్స్ అంటే శిక్షణ సమయంలో మోడల్ పనితీరు మెట్రిక్స్ ఎలా మారుతాయో చూపే దృశ్య రూపాలు. పర్యవేక్షించాల్సిన ముఖ్యమైన రెండు కర్వ్స్: +లెర్నింగ్ కర్వ్స్ అనేవి శిక్షణ సమయంలో మోడల్ పనితీరు మెట్రిక్స్ మార్పును చూపించే దృశ్య రూపాలు. ముఖ్యంగా పర్యవేక్షించాల్సిన రెండు కర్వ్స్: -- **లాస్ కర్వ్స్**: మోడల్ ఎర్రర్ (లాస్) శిక్షణ స్టెప్స్ లేదా ఎపాక్స్‌లో ఎలా మారుతుంది -- **ఆక్యురసీ కర్వ్స్**: సరైన ప్రిడిక్షన్స్ శాతం ఎలా మారుతుంది +- **లాస్ కర్వ్స్**: మోడల్ ఎర్రర్ (లాస్) శిక్షణ స్టెప్స్ లేదా ఎపాక్స్‌లో ఎలా మారుతుందో చూపిస్తుంది +- **ఆక్యురసీ కర్వ్స్**: సరైన ప్రిడిక్షన్స్ శాతం ఎలా మారుతుందో చూపిస్తుంది ### లాస్ కర్వ్స్[[loss-curves]] -లాస్ కర్వ్ మోడల్ ఎర్రర్ కాలక్రమంలో ఎలా తగ్గుతుందో చూపిస్తుంది. సాధారణ విజయవంతమైన శిక్షణలో కింది విధంగా కనిపిస్తుంది: +లాస్ కర్వ్ మోడల్ పొరపాటు (ఎర్రర్) కాలక్రమంలో ఎలా తగ్గుతుందో చూపిస్తుంది. సాధారణ విజయవంతమైన శిక్షణలో కింద చూపినట్టే ఉంటుంది: ![Loss Curve](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/1.png) -- **మొదట ఎక్కువ లాస్**: మోడల్ ఆప్టిమైజ్ కాని స్థితిలో ఉంటుంది, ప్రిడిక్షన్స్ పేలవంగా ఉంటాయి -- **తగ్గుతున్న లాస్**: శిక్షణ పురోగమిస్తుండగా లాస్ సాధారణంగా తగ్గుతుంది -- **కన్వర్జెన్స్**: చివరికి లాస్ తక్కువ వాల్యూకి స్థిరపడుతుంది +- **మొదటి ఎక్కువ లాస్**: మోడల్ ప్రారంభంలో ఆప్టిమైజ్ కాని స్థితిలో ఉంటుంది +- **తగ్గుతున్న లాస్**: శిక్షణ కొనసాగినప్పుడు లాస్ సాధారణంగా తగ్గుతుంది +- **కన్వర్జెన్స్**: చివరగా లాస్ తక్కువ విలువ వద్ద స్థిరపడుతుంది ```python +# Example of tracking loss during training with the Trainer from transformers import Trainer, TrainingArguments import wandb + +# Initialize Weights & Biases for experiment tracking wandb.init(project="transformer-fine-tuning", name="bert-mrpc-analysis") training_args = TrainingArguments( @@ -40,11 +44,11 @@ training_args = TrainingArguments( eval_strategy="steps", eval_steps=50, save_steps=100, - logging_steps=10, + logging_steps=10, # Log metrics every 10 steps num_train_epochs=3, per_device_train_batch_size=16, per_device_eval_batch_size=16, - report_to="wandb", + report_to="wandb", # Send logs to Weights & Biases ) trainer = Trainer( @@ -56,25 +60,27 @@ trainer = Trainer( processing_class=tokenizer, compute_metrics=compute_metrics, ) + +# Train and automatically log metrics trainer.train() -``` +```` ### ఆక్యురసీ కర్వ్స్[[accuracy-curves]] ![Accuracy Curve](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/2.png) -- **మొదట తక్కువ**: మోడల్ ఇంకా ప్యాటర్న్స్ నేర్చుకోలేదు -- **పెరుగుతుంది**: మోడల్ నేర్చుకుంటుంది కాబట్టి ఆక్యురసీ పెరుగుతుంది -- **ప్లాటోలు కనిపిస్తాయి**: ఆక్యురసీ సాధారణంగా డిస్క్రీట్ జంప్స్‌లో పెరుగుతుంది +* **మొదట తక్కువ**: మోడల్ ఇంకా ప్యాటర్న్స్ నేర్చుకోలేదు +* **పెరుగుతుంది**: శిక్షణతో ఆక్యురసీ పెరుగుతుంది +* **ప్లాటోలు కనిపిస్తాయి**: ఆక్యురసీ సాధారణంగా డిస్క్రీట్ జంప్స్‌లో పెరుగుతుంది > [!TIP] -> ఆక్యురసీ కర్వ్స్ "స్టెప్పీ"గా ఉండటానికి కారణం: లాస్ కంటిన్యూస్ అయితే, ఆక్యురసీ డిస్క్రీట్ ప్రిడిక్షన్స్‌పై ఆధారపడి ఉంటుంది. కాన్ఫిడెన్స్‌లో చిన్న మెరుగుదలలు ఫైనల్ ప్రిడిక్షన్ మార్చకపోవచ్చు, థ్రెషోల్డ్ దాటినప్పుడు మాత్రమే ఆక్యురసీ పెరుగుతుంది. +> 💡 **ఆక్యురసీ కర్వ్స్ "స్టెప్పీ" ఎందుకు ఉంటాయి**: లాస్ కంటిన్యూస్ అయితే, ఆక్యురసీ డిస్క్రీట్ ప్రిడిక్షన్స్‌పై ఆధారపడి ఉంటుంది. చిన్న మెరుగుదలలు ఫైనల్ ప్రిడిక్షన్ మార్చకపోవచ్చు, థ్రెషోల్డ్ దాటినప్పుడు మాత్రమే ఆక్యురసీ పెరుగుతుంది. ### కన్వర్జెన్స్[[convergence]] ![Convergence](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/4.png) -మోడల్ పనితీరు స్థిరపడినప్పుడు కన్వర్జెన్స్ జరుగుతుంది. +కన్వర్జెన్స్ అనేది మోడల్ పనితీరు స్థిరపడినప్పుడు జరుగుతుంది. ## లెర్నింగ్ కర్వ్ ప్యాటర్న్స్ అర్థం చేసుకోవడం[[interpreting-learning-curve-patterns]] @@ -83,30 +89,64 @@ trainer.train() ![Healthy Loss Curve](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/5.png) > [!TIP] -> ఆరోగ్యకరమైన కర్వ్స్ లక్షణాలు: -> - ట్రైన్ & వాలిడేషన్ లాస్ రెండూ స్థిరంగా తగ్గుతాయి -> - ట్రైన్/వాలిడేషన్ మధ్య చిన్న గ్యాప్ మాత్రమే ఉంటుంది -> - కర్వ్స్ స్థిరపడతాయి +> **ఆరోగ్యకరమైన కర్వ్స్ లక్షణాలు:** +> +> * ట్రైన్ & వాలిడేషన్ లాస్ రెండూ స్థిరంగా తగ్గుతాయి +> * ట్రైన్/వాలిడేషన్ మధ్య చిన్న గ్యాప్ మాత్రమే ఉంటుంది +> * కర్వ్స్ స్థిరపడతాయి + +### ప్రాక్టికల్ ఉదాహరణలు[[practical-examples]] + +#### శిక్షణ సమయంలో[[during-training]] + +1. **లాస్ కన్వర్జెన్స్**: లాస్ ఇంకా తగ్గుతున్నదా లేదా ప్లాటో అవుతోందా? +2. **ఓవర్‌ఫిట్టింగ్ గుర్తులు**: ట్రైన్ లాస్ తగ్గుతూనే వాలిడేషన్ లాస్ పెరుగుతున్నదా? +3. **లెర్నింగ్ రేట్**: కర్వ్స్ అస్థిరమా లేదా చాలా ఫ్లాట్‌గా ఉందా? +4. **స్థిరత్వం**: ఆకస్మిక స్పైక్స్ లేదా డ్రాప్స్ కనిపిస్తున్నాయా? + +#### శిక్షణ తర్వాత[[after-training]] + +1. **చివరి పనితీరు**: మోడల్ అంగీకారమైన స్థాయిలో ఉందా? +2. **ప్రభావవంతత**: తక్కువ ఎపాక్స్‌లో అదే పనితీరు సాధ్యమా? +3. **జనరలైజేషన్**: ట్రైన్ & వాలిడేషన్ పనితీరుకు మధ్య తేడా ఎంత? +4. **ట్రెండ్స్**: అదనపు శిక్షణ పనితీరును మెరుగుపరుస్తుందా? + +> [!TIP] +> 🔍 **Weights & Biases డాష్‌బోర్డు ఫీచర్స్**: +> +> * బహుళ రన్స్‌ని సైడ్ బై సైడ్ పోల్చవచ్చు +> * కస్టమ్ మెట్రిక్స్ & విజువలైజేషన్స్ +> * అనామాలస్ కోసం అలర్ట్స్ +> * ఫలితాలను టీమ్‌తో షేర్ చేయవచ్చు ### ఓవర్‌ఫిట్టింగ్[[overfitting]] ![Overfitting](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/10.png) -లక్షణాలు: -- ట్రైన్ లాస్ తగ్గుతూనే ఉంటుంది -- వాలిడేషన్ లాస్ పెరగడం మొదలవుతుంది లేదా స్థిరపడుతుంది +**లక్షణాలు:** + +* ట్రైన్ లాస్ తగ్గుతూనే ఉంటుంది +* వాలిడేషన్ లాస్ పెరగడం లేదా ప్లాటో అవుతుంది +* ట్రైన్ ఆక్యురసీ ఎక్కువ, వాలిడేషన్ ఆక్యురసీ తక్కువ -పరిష్కారాలు: -- రెగ్యులరైజేషన్ (డ్రాపౌట్, వెయిట్ డికే) -- ఎర్లీ స్టాప్పింగ్ -- డేటా ఆగ్మెంటేషన్ -- చిన్న మోడల్ వాడటం +**పరిష్కారాలు:** + +* రెగ్యులరైజేషన్: డ్రాపౌట్, వెయిట్ డికే +* ఎర్లీ స్టాప్పింగ్ +* డేటా ఆగ్మెంటేషన్ +* చిన్న మోడల్ వాడటం ```python from transformers import EarlyStoppingCallback trainer = Trainer( - ..., + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation"], + data_collator=data_collator, + processing_class=tokenizer, + compute_metrics=compute_metrics, callbacks=[EarlyStoppingCallback(early_stopping_patience=3)], ) ``` @@ -115,96 +155,102 @@ trainer = Trainer( ![Underfitting](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/7.png) -లక్షణాలు: -- ట్రైన్ & వాలిడేషన్ లాస్ రెండూ ఎక్కువగా ఉంటాయి -- త్వరగా ప్లాటో అవుతాయి +**లక్షణాలు:** + +* ట్రైన్ & వాలిడేషన్ లాస్ రెండూ ఎక్కువగా ఉంటాయి +* ట్రైన్ ఆక్యురసీ & వాలిడేషన్ ఆక్యురసీ తక్కువ +* పనితీరు త్వరగా ప్లాటో అవుతుంది -పరిష్కారాలు: -- పెద్ద మోడల్ వాడటం -- ఎక్కువ ఎపాక్స్ శిక్షణ -- లెర్నింగ్ రేట్ సర్దడం +**పరిష్కారాలు:** + +* పెద్ద మోడల్ వాడటం +* ఎక్కువ ఎపాక్స్ శిక్షణ +* లెర్నింగ్ రేట్ సర్దడం +* డేటా సరిచూసుకోవడం ### ఎరాటిక్ లెర్నింగ్ కర్వ్స్[[erratic-learning-curves]] ![Erratic Learning Curves](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/3.png) ![Erratic Learning Curves](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/9.png) -లక్షణాలు: -- లాస్/ఆక్యురసీ తరచూ ఊగుతాయి -- స్పష్టమైన ట్రెండ్ ఉండదు +**లక్షణాలు:** + +* లాస్/ఆక్యురసీ తరచూ ఊగుతాయి +* స్పష్టమైన ట్రెండ్ లేదు -పరిష్కారాలు: -- లెర్నింగ్ రేట్ తగ్గించడం -- బ్యాచ్ సైజ్ పెంచడం -- గ్రేడియంట్ క్లిప్పింగ్ +**పరిష్కారాలు:** + +* లెర్నింగ్ రేట్ తగ్గించడం +* బ్యాచ్ సైజ్ పెంచడం +* గ్రేడియంట్ క్లిప్పింగ్ ```python +from transformers import TrainingArguments + training_args = TrainingArguments( - ..., - learning_rate=2e-5, # ముందు ఎక్కువ ఉంటే తగ్గించండి + output_dir="./results", + learning_rate=1e-4, per_device_train_batch_size=32, ) ``` ## ముఖ్య పాయింట్లు[[key-takeaways]] -లెర్నింగ్ కర్వ్స్ అర్థం చేసుకోవడం ప్రభావవంతమైన మెషిన్ లెర్నింగ్ ప్రాక్టీషనర్ కావడానికి అవసరం. - -> [!TIP] -> ముఖ్య పాయింట్లు: -> - లెర్నింగ్ కర్వ్స్ మోడల్ శిక్షణ పురోగతిని అర్థం చేసుకోవడానికి అవసరమైన టూల్స్ -> - లాస్ మరియు ఆక్యురసీ కర్వ్స్ రెండూ పర్యవేక్షించండి, కానీ వాటి స్వభావాలు భిన్నంగా ఉంటాయి -> - ఓవర్‌ఫిట్టింగ్: ట్రైన్/వాలిడేషన్ పనితీరు వేరుపడటం -> - అండర్‌ఫిట్టింగ్: ట్రైన్ & వాలిడేషన్ రెండూ పేలవంగా ఉండటం -> - Weights & Biases వంటి టూల్స్ లెర్నింగ్ కర్వ్స్ ట్రాక్ చేయడం సులభం చేస్తాయి -> - ఎర్లీ స్టాప్పింగ్ మరియు రెగ్యులరైజేషన్ సాధారణ శిక్షణ సమస్యలను పరిష్కరిస్తాయి +* లెర్నింగ్ కర్వ్స్ మోడల్ శిక్షణ పురోగతిని అర్థం చేసుకోవడానికి అవసరమైన టూల్స్ +* లాస్ & ఆక్యురసీ కర్వ్స్ రెండూ పర్యవేక్షించండి +* ఓవర్‌ఫిట్టింగ్: ట్రైన్/వాలిడేషన్ పనితీరు వేరుపడటం +* అండర్‌ఫిట్టింగ్: ట్రైన్ & వాలిడేషన్ పనితీరు తక్కువ +* Weights & Biases వంటి టూల్స్ సులభతరం చేస్తాయి +* ఎర్లీ స్టాప్పింగ్ & రెగ్యులరైజేషన్ సాధారణ సమస్యలను పరిష్కరిస్తాయి ## సెక్షన్ క్విజ్[[section-quiz]] ### 1. ట్రైన్ లాస్ తగ్గుతున్నా వాలిడేషన్ లాస్ పెరుగుతుంటే ఏమవుతుంది? + ### 2. ఆక్యురసీ కర్వ్స్ ఎందుకు "స్టెప్పీ" ఆకారంలో ఉంటాయి? + ### 3. అస్థిర (ఎరాటిక్) లెర్నింగ్ కర్వ్స్ కనిపిస్తే ఏం చేయాలి? + ### 4. ఎర్లీ స్టాప్పింగ్ ఎప్పుడు వాడాలి? + ### 5. మోడల్ అండర్‌ఫిట్ అవుతుందని ఏది సూచిస్తుంది? + > వాలిడేషన్ ఆక్యురసీ.", explain: "ఇది ఓవర్‌ఫిట్టింగ్."}, {text: "ట్రైన్ & వాలిడేషన్ పనితీరు రెండూ పేలవంగా, త్వరగా ప్లాటో.", explain: "సరైనది!", correct: true}, {text: "లెర్నింగ్ కర్వ్స్ చాలా స్మూత్.", explain: "కాదు."}, -{text: "వాలిడేషన్ లాస్ ట్రైన్ కంటే త్వరగా తగ్గుతుంది.", explain: "ఇది మంచి సంకేతం."} -]}/> - -**పూర్తయింది మామా! చాప్టర్ 3 మొత్తం రెడీ.** -చాప్టర్ 4 (Sharing Models on the Hub) కావాలంటే చెప్పు – వెంటనే రాస్తా! \ No newline at end of file +{text: "వాలిడేషన్ లాస్ ట్రైన్ కంటే త్వరగా తగ్గుతుంది.", explain: "ఇది సమస్య కాదు."} +]}/> \ No newline at end of file From e51dbe16a3a244f44e763803a886b30e5e0f0a43 Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Mon, 1 Dec 2025 04:03:08 -0500 Subject: [PATCH 3/8] fixed block syntax --- chapters/te/chapter3/5.mdx | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/chapters/te/chapter3/5.mdx b/chapters/te/chapter3/5.mdx index af522224b..870192cf3 100644 --- a/chapters/te/chapter3/5.mdx +++ b/chapters/te/chapter3/5.mdx @@ -19,7 +19,7 @@ లెర్నింగ్ కర్వ్స్ అనేవి శిక్షణ సమయంలో మోడల్ పనితీరు మెట్రిక్స్ మార్పును చూపించే దృశ్య రూపాలు. ముఖ్యంగా పర్యవేక్షించాల్సిన రెండు కర్వ్స్: - **లాస్ కర్వ్స్**: మోడల్ ఎర్రర్ (లాస్) శిక్షణ స్టెప్స్ లేదా ఎపాక్స్‌లో ఎలా మారుతుందో చూపిస్తుంది -- **ఆక్యురసీ కర్వ్స్**: సరైన ప్రిడిక్షన్స్ శాతం ఎలా మారుతుందో చూపిస్తుంది +- **ఆక్యురసీ కర్వ్స్**: సరైన ప్రెడిక్షన్స్ శాతం ఎలా మారుతుందో చూపిస్తుంది ### లాస్ కర్వ్స్[[loss-curves]] @@ -31,7 +31,7 @@ - **తగ్గుతున్న లాస్**: శిక్షణ కొనసాగినప్పుడు లాస్ సాధారణంగా తగ్గుతుంది - **కన్వర్జెన్స్**: చివరగా లాస్ తక్కువ విలువ వద్ద స్థిరపడుతుంది -```python +``` # Example of tracking loss during training with the Trainer from transformers import Trainer, TrainingArguments import wandb @@ -63,7 +63,7 @@ trainer = Trainer( # Train and automatically log metrics trainer.train() -```` +``` ### ఆక్యురసీ కర్వ్స్[[accuracy-curves]] @@ -74,7 +74,7 @@ trainer.train() * **ప్లాటోలు కనిపిస్తాయి**: ఆక్యురసీ సాధారణంగా డిస్క్రీట్ జంప్స్‌లో పెరుగుతుంది > [!TIP] -> 💡 **ఆక్యురసీ కర్వ్స్ "స్టెప్పీ" ఎందుకు ఉంటాయి**: లాస్ కంటిన్యూస్ అయితే, ఆక్యురసీ డిస్క్రీట్ ప్రిడిక్షన్స్‌పై ఆధారపడి ఉంటుంది. చిన్న మెరుగుదలలు ఫైనల్ ప్రిడిక్షన్ మార్చకపోవచ్చు, థ్రెషోల్డ్ దాటినప్పుడు మాత్రమే ఆక్యురసీ పెరుగుతుంది. +> 💡 **ఆక్యురసీ కర్వ్స్ "స్టెప్పీ" ఎందుకు ఉంటాయి**: లాస్ కంటిన్యూస్ అయితే, ఆక్యురసీ డిస్క్రీట్ ప్రెడిక్షన్స్‌పై ఆధారపడి ఉంటుంది. చిన్న మెరుగుదలలు ఫైనల్ ప్రెడిక్షన్ మార్చకపోవచ్చు, థ్రెషోల్డ్ దాటినప్పుడు మాత్రమే ఆక్యురసీ పెరుగుతుంది. ### కన్వర్జెన్స్[[convergence]] @@ -136,7 +136,7 @@ trainer.train() * డేటా ఆగ్మెంటేషన్ * చిన్న మోడల్ వాడటం -```python +``` from transformers import EarlyStoppingCallback trainer = Trainer( @@ -184,7 +184,7 @@ trainer = Trainer( * బ్యాచ్ సైజ్ పెంచడం * గ్రేడియంట్ క్లిప్పింగ్ -```python +``` from transformers import TrainingArguments training_args = TrainingArguments( @@ -220,7 +220,7 @@ choices={[ From f603a0318e3db62640042b0c12f9222618ab98a2 Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Mon, 1 Dec 2025 04:16:24 -0500 Subject: [PATCH 4/8] removed extra quote in block --- chapters/te/chapter3/3.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapters/te/chapter3/3.mdx b/chapters/te/chapter3/3.mdx index 166463f3d..411b706d8 100644 --- a/chapters/te/chapter3/3.mdx +++ b/chapters/te/chapter3/3.mdx @@ -36,7 +36,7 @@ def tokenize_function(example): tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) data_collator = DataCollatorWithPadding(tokenizer=tokenizer) -```` +``` ### శిక్షణ[[training]] From 8406e2d24ff0df3f978ef4218a3764e07b2fcb66 Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Wed, 3 Dec 2025 21:16:08 -0500 Subject: [PATCH 5/8] resave --- chapters/te/chapter3/3.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapters/te/chapter3/3.mdx b/chapters/te/chapter3/3.mdx index 411b706d8..877de7887 100644 --- a/chapters/te/chapter3/3.mdx +++ b/chapters/te/chapter3/3.mdx @@ -262,4 +262,4 @@ choices={[ > * `processing_class` ద్వారా టోకెనైజర్ స్పష్టంగా చెప్పండి > * `TrainingArguments`లో learning rate, batch size, fp16, gradient accumulation సెట్ చేయండి > * `compute_metrics` ద్వారా కావలసిన metrics చూడవచ్చు -> * ఆధునిక optimizations (fp16, gradient accumulation) ఒక్క లైన్‌లో ఆన్ చేయవచ్చు +> * ఆధునిక optimizations (fp16, gradient accumulation) ఒక్క లైన్‌లో ఆన్ చేయవచ్చు \ No newline at end of file From 171a7703d7fc7446c0f37e734e4cf51e7ddee65f Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Wed, 3 Dec 2025 21:42:25 -0500 Subject: [PATCH 6/8] updated chapter-3 contents --- chapters/te/_toctree.yml | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/chapters/te/_toctree.yml b/chapters/te/_toctree.yml index 301decc44..decd0ae9f 100644 --- a/chapters/te/_toctree.yml +++ b/chapters/te/_toctree.yml @@ -26,4 +26,22 @@ title: సారాంశం - local: chapter1/11 title: పరీక్ష - quiz: 1 \ No newline at end of file + quiz: 1 + +- title: 3. ముందుగా శిక్షణ పొందిన నమూనాను ఫైన్-ట్యూన్ చేయడం + sections: + - local: chapter3/1 + title: పరిచయం + - local: chapter3/2 + title: డేటాను ప్రాసెస్ చేయడం + - local: chapter3/3 + title: Trainer API‌తో నమూనాను ఫైన్-ట్యూన్ చేయడం + - local: chapter3/4 + title: పూర్తి ట్రైనింగ్ లూప్ + - local: chapter3/5 + title: లెర్నింగ్ కర్వ్‌లను అర్థం చేసుకోవడం + - local: chapter3/6 + title: ఫైన్-ట్యూనింగ్, పూర్తైంది! + - local: chapter3/7 + title: అధ్యాయం ముగింపు క్విజ్ + quiz: 3 \ No newline at end of file From b52aaee2dd2c90f105b8b4ce85533194447ab106 Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Thu, 4 Dec 2025 21:12:50 -0500 Subject: [PATCH 7/8] updated Chapter-3 titles --- chapters/te/_toctree.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/chapters/te/_toctree.yml b/chapters/te/_toctree.yml index decd0ae9f..14d723725 100644 --- a/chapters/te/_toctree.yml +++ b/chapters/te/_toctree.yml @@ -27,8 +27,8 @@ - local: chapter1/11 title: పరీక్ష quiz: 1 - -- title: 3. ముందుగా శిక్షణ పొందిన నమూనాను ఫైన్-ట్యూన్ చేయడం + + - title: 3. ముందుగా శిక్షణ పొందిన నమూనాను ఫైన్-ట్యూన్ చేయడం sections: - local: chapter3/1 title: పరిచయం From 092a015ceb96ef82817e13896982e2efc968337b Mon Sep 17 00:00:00 2001 From: somu-analyst Date: Sat, 6 Dec 2025 09:48:38 -0500 Subject: [PATCH 8/8] removed indentation issues --- chapters/te/_toctree.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chapters/te/_toctree.yml b/chapters/te/_toctree.yml index 14d723725..17dd776b8 100644 --- a/chapters/te/_toctree.yml +++ b/chapters/te/_toctree.yml @@ -28,7 +28,7 @@ title: పరీక్ష quiz: 1 - - title: 3. ముందుగా శిక్షణ పొందిన నమూనాను ఫైన్-ట్యూన్ చేయడం +- title: 3. ముందుగా శిక్షణ పొందిన నమూనాను ఫైన్-ట్యూన్ చేయడం sections: - local: chapter3/1 title: పరిచయం