course/pr_1152/te/chapter3/4.md

పూర్తి శిక్షణ లూప్[[a-full-training]]

ఇప్పుడు Trainer క్లాస్ ఉపయోగించకుండా, మునుపటి సెక్షన్‌లో చూపిన అదే ఫలితాలను సాధించే విధంగా పూర్తి శిక్షణ లూప్‌ను PyTorchలో అమలు చేద్దాం. మళ్లీ చెప్తున్నాం – మీరు సెక్షన్ 2లో డేటా ప్రాసెసింగ్ పూర్తి చేసి ఉన్నారని అనుకుంటున్నాం.

🏗️ మాన్యువల్ శిక్షణ: PyTorchలో ట్రైనింగ్ లూప్ మరియు బెస్ట్ ప్రాక్టీస్ల కోసం 🤗 Transformers training documentation మరియు custom training cookbook చూడండి.

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 ఆటోమేటిక్‌గా చేసే కొన్ని దశలను మనం మాన్యువల్‌గా చేయాలి:

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

["attention_mask", "input_ids", "labels", "token_type_ids"]

ఇప్పుడు DataLoaderలు తయారు చేయవచ్చు:

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
)

ఒక బ్యాచ్ చూద్దాం:

for batch in train_dataloader:
    break
{k: v.shape for k, v in batch.items()}

{'attention_mask': torch.Size([8, 65]),
 'input_ids': torch.Size([8, 65]),
 'labels': torch.Size([8]),
 'token_type_ids': torch.Size([8, 65])}

మోడల్:

from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

టెస్ట్:

outputs = model(**batch)
print(outputs.loss, outputs.logits.shape)

tensor(0.5441, grad_fn=) torch.Size([8, 2])

ఆప్టిమైజర్:

from torch.optim import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5, weight_decay=0.01)

లెర్నింగ్ రేట్ షెడ్యూలర్:

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)

1377

GPUకి తరలించడం:

import torch

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
print(device)

device(type='cuda')

శిక్షణ లూప్[[the-training-loop]]

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)

💡 అడ్వాన్స్డ్ శిక్షణ టిప్స్:

• మిక్స్డ్ ప్రెసిషన్: torch.cuda.amp.autocast() మరియు GradScaler వాడండి
• గ్రేడియంట్ అక్యుమ్యులేషన్: ఎక్కువ బ్యాచ్ సైజ్ సిమ్యులేషన్ కోసం గ్రేడియంట్స్ ను accumulate చేయండి
• Checkpointing: మధ్యలో మోడల్ సేవ్ చేయండి

ఎవాల్యుయేషన్ లూప్[[the-evaluation-loop]]

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()

{'accuracy': 0.8431372549019608, 'f1': 0.8907849829351535}

🤗 Accelerateతో శిక్షణ లూప్[[supercharge-your-training-loop-with-accelerate]]

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లో సేవ్ చేసి కింది కమాండ్‌లతో రన్ చేయవచ్చు:

accelerate config
accelerate launch train.py

Colabలో టెస్ట్ చేయాలంటే:

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 లో ఏమి మారుతుంది?

💡 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 పెంచుతాయి