diff --git a/chapters/te/_toctree.yml b/chapters/te/_toctree.yml index 301decc44..17dd776b8 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 diff --git a/chapters/te/chapter3/1.mdx b/chapters/te/chapter3/1.mdx new file mode 100644 index 000000000..5d8e0e4e2 --- /dev/null +++ b/chapters/te/chapter3/1.mdx @@ -0,0 +1,36 @@ + + +# పరిచయం[[introduction]] + + + +అధ్యాయం 2లో మనం టోకెనైజర్లు మరియు ముందే శిక్షణ పొందిన మోడళ్లను ఉపయోగించి ప్రిడిక్షన్లు ఎలా చేయాలో చూశాం. అయితే ఒక నిర్దిష్ట కార్యాన్ని పరిష్కరించడానికి ముందే శిక్షణ పొందిన మోడల్‌ను ఫైన్-ట్యూన్ చేయాలంటే? ఇదే ఈ అధ్యాయం యొక్క విషయం! మీరు నేర్చుకునే అంశాలు ఇవి: + +* Hugging Face Hub నుండి పెద్ద డేటాసెట్‌ను తాజా 🤗 Datasets ఫీచర్లతో ఎలా సిద్ధం చేసుకోవాలి +* అధిక స్థాయి `Trainer` API ఉపయోగించి ఆధునిక ఉత్తమ పద్ధతులతో మోడల్‌ను ఎలా ఫైన్-ట్యూన్ చేయాలి +* ఆప్టిమైజేషన్ టెక్నిక్‌లతో కస్టమ్ ట్రైనింగ్ లూప్‌ను ఎలా అమలు చేయాలి +* ఏ రకమైన సెటప్‌లో అయినా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ నిర్వహించడానికి 🤗 Accelerate లైబ్రరీని ఎలా ఉపయోగించాలి +* ప్రస్తుతం ప్రాచుర్యంలో ఉన్న ఫైన్-ట్యూనింగ్ ఉత్తమ పద్ధతులను ఎలా అనుసరించాలి + +> [!TIP] +> 📚 ప్రారంభించే ముందు 🤗 Datasets డాక్యుమెంటేషన్‌ను ఒకసారి చూడటం మంచిది: [https://huggingface.co/docs/datasets/](https://huggingface.co/docs/datasets/) + +ఈ అధ్యాయం, 🤗 Transformers‌తో పాటు Hugging Face యొక్క ఇతర ఉపయోగకరమైన లైబ్రరీలకు కూడా పరిచయం ఇస్తుంది! 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate మరియు 🤗 Evaluate లాంటి లైబ్రరీలు కలిసి మోడల్ శిక్షణను మరింత సమర్థవంతం చేస్తాయి. + +ఈ అధ్యాయంలోని ప్రతి ముఖ్య విభాగం ఒక కొత్త నైపుణ్యాన్ని నేర్పుతుంది: + +* **సెక్షన్ 2**: ఆధునిక డేటా ప్రీప్రాసెసింగ్ మరియు సమర్థవంతమైన డేటాసెట్ నిర్వహణ +* **సెక్షన్ 3**: Trainer API యొక్క శక్తివంతమైన ఫీచర్లలో నైపుణ్యం +* **సెక్షన్ 4**: కస్టమ్ ట్రైనింగ్ లూప్ అమలు మరియు Accelerate ద్వారా డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్ + +ఈ అధ్యాయం పూర్తయ్యే సమయానికి, మీరు హై-లెవల్ APIలు మరియు కస్టమ్ ట్రైనింగ్ లూప్‌లను ఉపయోగించి మీ స్వంత డేటాసెట్‌లపై మోడళ్లను ఫైన్-ట్యూన్ చేయగలుగుతారు, అలాగే ప్రస్తుత ఉత్తమ పద్ధతులను అనుసరించగలుగుతారు. + +> [!TIP] +> 🎯 ఈ అధ్యాయం ముగిసే సమయానికి మీరు BERT మోడల్‌ను టెక్స్ట్ క్లాసిఫికేషన్ కోసం ఫైన్-ట్యూన్ చేసి ఉంటారు మరియు ఈ పద్ధతులను మీ స్వంత డేటాసెట్‌లు మరియు పనులకు ఎలా అన్వయించాలో అర్థం చేసుకుంటారు. + +ఈ అధ్యాయం పూర్తిగా **PyTorch** ఆధారంగా ఉంటుంది — ఇది ఆధునిక డీప్ లెర్నింగ్ పరిశోధన మరియు ప్రొడక్షన్‌లో ప్రామాణిక ఫ్రేమ్‌వర్క్‌గా మారింది. Hugging Face ఎకోసిస్టమ్‌లోని తాజా APIలు మరియు ఉత్తమ పద్ధతులను మనం ఉపయోగిస్తాం. + +మీరు శిక్షణ పొందిన మీ మోడల్‌ను Hugging Face Hubలో అప్‌లోడ్ చేయాలంటే, మీకు ఒక Hugging Face ఖాతా అవసరం: [ఖాతా సృష్టించండి](https://huggingface.co/join) diff --git a/chapters/te/chapter3/2.mdx b/chapters/te/chapter3/2.mdx new file mode 100644 index 000000000..4dfd59edf --- /dev/null +++ b/chapters/te/chapter3/2.mdx @@ -0,0 +1,238 @@ +# డేటా సిద్ధం చేయడం[[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తో మోడల్ ఫైన్-ట్యూన్ చేద్దాం! diff --git a/chapters/te/chapter3/3.mdx b/chapters/te/chapter3/3.mdx new file mode 100644 index 000000000..5f03fc48f --- /dev/null +++ b/chapters/te/chapter3/3.mdx @@ -0,0 +1,269 @@ + + +# 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` ఇస్తే శిక్షణ సమయంలోనే మోడల్ Hugging Face Hubకి ఆటోమేటిక్‌గా అప్‌లోడ్ అవుతుంది. + +> [!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 ప్రీ-ట్రైన్డ్ కాదు sentence pair classification కోసం. పాత హెడ్ తీసేసి, కొత్త sequence classification హెడ్ జోడించారు. ఇప్పుడు శిక్షణ ప్రారంభించాలి. + +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]] + +```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తో metricsతో శిక్షణ + +```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() +``` + +ఇప్పుడు ప్రతి ఎపాక్ చివర validation loss + metrics కనిపిస్తాయి! + +--- + +### అడ్వాన్స్డ్ శిక్షణ ఫీచర్స్[[advanced-training-features]] + +**మిక్స్డ్ ప్రెసిషన్ (fp16)** – వేగం + మెమరీ ఆదా: + +```py +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, # effective batch size = 16 +) +``` + +**లెర్నింగ్ రేట్ షెడ్యూలర్**: + +```py +training_args = TrainingArguments( + "test-trainer", + learning_rate=2e-5, + lr_scheduler_type="cosine", +) +``` + +> [!TIP] +> 🎯 **పర్ఫార్మెన్స్ ఆప్టిమైజేషన్**: డిస్ట్రిబ్యూటెడ్ ట్రైనింగ్, మెమరీ ఆప్టిమైజేషన్ కోసం [🤗 Transformers performance guide](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`లో learning rate, batch size, fp16, gradient accumulation సెట్ చేయండి +> * `compute_metrics` ద్వారా కావలసిన metrics చూడవచ్చు +> * ఆధునిక optimizations (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..a41ffb83e --- /dev/null +++ b/chapters/te/chapter3/4.mdx @@ -0,0 +1,353 @@ + + +# పూర్తి శిక్షణ లూప్[[a-full-training]] + + + +ఇప్పుడు `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 + +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, weight_decay=0.01) +``` + +లెర్నింగ్ రేట్ షెడ్యూలర్: + +```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() + + # 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 +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) +``` + +### మరిన్ని బెస్ట్ ప్రాక్టీస్స్[[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 new file mode 100644 index 000000000..870192cf3 --- /dev/null +++ b/chapters/te/chapter3/5.mdx @@ -0,0 +1,256 @@ + +# లెర్నింగ్ కర్వ్స్ అర్థం చేసుకోవడం[[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) + +- **మొదటి ఎక్కువ లాస్**: మోడల్ ప్రారంభంలో ఆప్టిమైజ్ కాని స్థితిలో ఉంటుంది +- **తగ్గుతున్న లాస్**: శిక్షణ కొనసాగినప్పుడు లాస్ సాధారణంగా తగ్గుతుంది +- **కన్వర్జెన్స్**: చివరగా లాస్ తక్కువ విలువ వద్ద స్థిరపడుతుంది + +``` +# 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( + output_dir="./results", + eval_strategy="steps", + eval_steps=50, + save_steps=100, + 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", # Send logs to Weights & Biases +) + +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, +) + +# 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]] + +### ఆరోగ్యకరమైన లెర్నింగ్ కర్వ్స్[[healthy-learning-curves]] + +![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) + +**లక్షణాలు:** + +* ట్రైన్ లాస్ తగ్గుతూనే ఉంటుంది +* వాలిడేషన్ లాస్ పెరగడం లేదా ప్లాటో అవుతుంది +* ట్రైన్ ఆక్యురసీ ఎక్కువ, వాలిడేషన్ ఆక్యురసీ తక్కువ + +**పరిష్కారాలు:** + +* రెగ్యులరైజేషన్: డ్రాపౌట్, వెయిట్ డికే +* ఎర్లీ స్టాప్పింగ్ +* డేటా ఆగ్మెంటేషన్ +* చిన్న మోడల్ వాడటం + +``` +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)], +) +``` + +### అండర్‌ఫిట్టింగ్[[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) + +**లక్షణాలు:** + +* లాస్/ఆక్యురసీ తరచూ ఊగుతాయి +* స్పష్టమైన ట్రెండ్ లేదు + +**పరిష్కారాలు:** + +* లెర్నింగ్ రేట్ తగ్గించడం +* బ్యాచ్ సైజ్ పెంచడం +* గ్రేడియంట్ క్లిప్పింగ్ + +``` +from transformers import TrainingArguments + +training_args = TrainingArguments( + output_dir="./results", + learning_rate=1e-4, + per_device_train_batch_size=32, +) +``` + +## ముఖ్య పాయింట్లు[[key-takeaways]] + +* లెర్నింగ్ కర్వ్స్ మోడల్ శిక్షణ పురోగతిని అర్థం చేసుకోవడానికి అవసరమైన టూల్స్ +* లాస్ & ఆక్యురసీ కర్వ్స్ రెండూ పర్యవేక్షించండి +* ఓవర్‌ఫిట్టింగ్: ట్రైన్/వాలిడేషన్ పనితీరు వేరుపడటం +* అండర్‌ఫిట్టింగ్: ట్రైన్ & వాలిడేషన్ పనితీరు తక్కువ +* Weights & Biases వంటి టూల్స్ సులభతరం చేస్తాయి +* ఎర్లీ స్టాప్పింగ్ & రెగ్యులరైజేషన్ సాధారణ సమస్యలను పరిష్కరిస్తాయి + +## సెక్షన్ క్విజ్[[section-quiz]] + +### 1. ట్రైన్ లాస్ తగ్గుతున్నా వాలిడేషన్ లాస్ పెరుగుతుంటే ఏమవుతుంది? + + + +### 2. ఆక్యురసీ కర్వ్స్ ఎందుకు "స్టెప్పీ" ఆకారంలో ఉంటాయి? + + + +### 3. అస్థిర (ఎరాటిక్) లెర్నింగ్ కర్వ్స్ కనిపిస్తే ఏం చేయాలి? + + + +### 4. ఎర్లీ స్టాప్పింగ్ ఎప్పుడు వాడాలి? + + + +### 5. మోడల్ అండర్‌ఫిట్ అవుతుందని ఏది సూచిస్తుంది? + +> వాలిడేషన్ ఆక్యురసీ.", explain: "ఇది ఓవర్‌ఫిట్టింగ్."}, +{text: "ట్రైన్ & వాలిడేషన్ పనితీరు రెండూ పేలవంగా, త్వరగా ప్లాటో.", explain: "సరైనది!", correct: true}, +{text: "లెర్నింగ్ కర్వ్స్ చాలా స్మూత్.", explain: "కాదు."}, +{text: "వాలిడేషన్ లాస్ ట్రైన్ కంటే త్వరగా తగ్గుతుంది.", explain: "ఇది సమస్య కాదు."} +]}/> \ 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