Tamil Newsதிங்கள், 16 நவம்பர் 2026
சமீபத்தியம்
நாடு மீண்டும் வங்குரோத்து (bankruptcy) நிலையை நோக்கி நகர்வதாக முன்னாள் அமைச்சர் ராஜித சேனாரத்ன (Rajitha Senaratne) எச்சரிக்கைதம்புட்டேகமயில் (Thambuttegama) நிவாரணம் தேவைப்படும் குடும்பம் ஒன்றுக்கு வீடு: முன்னாள் ஜனாதிபதி சந்திரிகா பண்டாரநாயக்க குமாரதுங்க (Chandrika Bandaranaike Kumaratunga) சொந்த நிதியில் நிர்மாணம்புதுப்பிப்பு (Updated): புற்றுநோய் கதிர்வீச்சுச் சிகிச்சை (radiotherapy): ஐந்து வைத்தியசாலைகளுக்கான கருவிக் கொள்வனவு தாமதம் குறித்து மருத்துவர் எச்சரிக்கைபுதுப்பிப்பு (Updated): கங்குவா (Kanguva) பின்னடைவுக்குப் பிறகு சூர்யா (Suriya): மூன்றாவது ரூ.200 கோடி வசூலை (box office) நோக்கி சீன் (Scene)பாகிஸ்தான் (Pakistan) தார்பேலா (Tarbela) நீர்மின் திட்டத்தில் (hydropower project) தடுப்புச் சுவர் இடிந்ததாகத் தகவல்இலங்கைச் (Sri Lanka) சுற்றுலாவை (tourism) மேம்படுத்த சர்வதேச ஒலிபரப்பு நிறுவனங்கள் (broadcasting organisations) விருப்பம்: அமைச்சர் (Minister)நொச்சியாகமவில் (Nochchiyagama) கொலைக்கு உதவிய குற்றச்சாட்டில் 38 வயது நபர் கைதுசிங்கராஜ காட்டில் (Sinharaja Forest) அரிய பூச்சி, ஊர்வன இனங்களைச் சேகரித்த குற்றச்சாட்டில் நான்கு சீன நாட்டவர் (Chinese nationals) கைது

AlexNet-ஐ வேகமாகப் பயிற்றுவித்தல்: mixed precision, gradient accumulation மற்றும் checkpointing

விளக்கப்படம்: A liquid-cooled GPU compute blade from the MareNostrum 5 supercomputer at the Barcelona Supercomputing Center. படம்: Steve Jurvetson, CC BY 4.0, via Wikimedia Commons.

விளக்கப்படம்: A liquid-cooled GPU compute blade from the MareNostrum 5 supercomputer at the Barcelona Supercomputing Center. படம்: Steve Jurvetson, CC BY 4.0, via Wikimedia Commons.

தானியங்கி Mixed Precision (AMP / FP16), Gradient Accumulation (சிறிய GPU-களில் பெரிய batch அளவுகளை உருவகப்படுத்த), உங்கள் சிறந்த சரிபார்ப்பு மாதிரியை மட்டும் சேமிக்கும் Smart Model Checkpointing ஆகியவற்றை இணைக்கும் மேம்படுத்தப்பட்ட பயிற்சி ஸ்கிரிப்ட் இதோ.

1. வன்பொருள் சீரமைப்பு மற்றும் வேக மேம்பாட்டு வழிகாட்டி

நீங்கள் இயக்கும் வன்பொருளின் அடிப்படையில் உங்கள் அமைப்புகளைத் தேர்ந்தெடுங்கள்:

வன்பொருள் சூழல்பரிந்துரைக்கப்படும் batch_sizeaccum_stepsபயனுறு Batch அளவுMixed Precision (use_amp)
Colab Free / தொடக்க நிலை GPU (T4, RTX 3060 — 8–16 GB VRAM)1281128True (FP16)
குறைந்த VRAM GPU (GTX 1650, RTX 2060 — 4–6 GB VRAM)324128True (FP16)
Workstation / Cloud GPU (A100, RTX 4090 — 24+ GB VRAM)2561256True (BF16/FP16)
CPU மட்டும்32264False (AMP-ஐ முடக்குக)
  • Mixed Precision (FP16) எப்படி உதவுகிறது: PyTorch-இன் torch.amp, convolutions மற்றும் matrix பெருக்கல்களை 16-பிட் floating point-இல் இயக்கி, முக்கியமான குவிப்புகளை 32-பிட்டில் வைத்திருக்கிறது. இது GPU நினைவகப் பயன்பாட்டை கிட்டத்தட்ட பாதியாகக் குறைத்து, NVIDIA Tensor Core GPU-களில் பயிற்சியை 1.5× முதல் 2.5× வரை வேகப்படுத்துகிறது.
  • Gradient Accumulation எப்படி உதவுகிறது: batch_size=128 OutOfMemoryError-ஐத் தூண்டினால், batch_size=32 மற்றும் accum_steps=4 என அமையுங்கள். எடைகளைப் புதுப்பிக்கும் முன் மாதிரி நான்கு mini-batch-கள் முழுவதும் gradients-ஐத் திரட்டுகிறது; இதனால் VRAM-இல் நான்கில் ஒரு பங்கையே பயன்படுத்தி, 128-பட batch-இன் அதே பயிற்சி நிலைத்தன்மை கிடைக்கிறது.

2. AMP, Accumulation மற்றும் Checkpointing உடனான முழுமையான ஸ்கிரிப்ட்

import os
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# ==========================================
# 1. Modernized AlexNet with BatchNorm
# ==========================================
class ModernAlexNet(nn.Module):
    def __init__(self, num_classes: int = 10, dropout: float = 0.5):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            nn.Conv2d(64, 192, kernel_size=5, padding=2, bias=False),
            nn.BatchNorm2d(192),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            nn.Conv2d(192, 384, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(384),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(384, 256, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            
            nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        self.classifier = nn.Sequential(
            nn.Dropout(p=dropout),
            nn.Linear(256 * 6 * 6, 4096, bias=False),
            nn.BatchNorm1d(4096),
            nn.ReLU(inplace=True),
            
            nn.Dropout(p=dropout),
            nn.Linear(4096, 4096, bias=False),
            nn.BatchNorm1d(4096),
            nn.ReLU(inplace=True),
            
            nn.Linear(4096, num_classes),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        return self.classifier(x)


# ==========================================
# 2. Data Pipeline (Safe for BatchNorm1d)
# ==========================================
def get_dataloaders(dataset_type: str = "cifar10", data_dir: str = "./data", batch_size: int = 128):
    norm_mean = [0.485, 0.456, 0.406]
    norm_std = [0.229, 0.224, 0.225]

    train_transforms = transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.RandomCrop((224, 224)),
        transforms.RandomHorizontalFlip(p=0.5),
        transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
        transforms.ToTensor(),
        transforms.Normalize(mean=norm_mean, std=norm_std),
    ])

    val_transforms = transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.CenterCrop((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=norm_mean, std=norm_std),
    ])

    if dataset_type == "cifar10":
        train_dataset = datasets.CIFAR10(root=data_dir, train=True, download=True, transform=train_transforms)
        val_dataset = datasets.CIFAR10(root=data_dir, train=False, download=True, transform=val_transforms)
        num_classes = 10
    elif dataset_type == "folder":
        train_dataset = datasets.ImageFolder(root=os.path.join(data_dir, "train"), transform=train_transforms)
        val_dataset = datasets.ImageFolder(root=os.path.join(data_dir, "val"), transform=val_transforms)
        num_classes = len(train_dataset.classes)
    else:
        raise ValueError("dataset_type must be 'cifar10' or 'folder'")

    # drop_last=True prevents a final batch of size 1 from crashing BatchNorm1d
    num_workers = min(4, os.cpu_count() or 1)
    train_loader = DataLoader(
        train_dataset, batch_size=batch_size, shuffle=True,
        num_workers=num_workers, pin_memory=True, drop_last=True
    )
    val_loader = DataLoader(
        val_dataset, batch_size=batch_size, shuffle=False,
        num_workers=num_workers, pin_memory=True
    )
    return train_loader, val_loader, num_classes


# ==========================================
# 3. AMP Training & Checkpointing Utilities
# ==========================================
def train_one_epoch(model, loader, criterion, optimizer, scaler, device, use_amp: bool, accum_steps: int):
    model.train()
    running_loss, correct, total = 0.0, 0, 0
    optimizer.zero_grad(set_to_none=True)

    for step, (images, labels) in enumerate(loader):
        images = images.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        # Forward pass in mixed precision (FP16)
        with torch.amp.autocast(device_type=device.type, enabled=use_amp):
            outputs = model(images)
            loss = criterion(outputs, labels) / accum_steps

        # Scaled backward pass to prevent FP16 gradient underflow
        scaler.scale(loss).backward()

        # Update weights every `accum_steps` batches
        if (step + 1) % accum_steps == 0 or (step + 1) == len(loader):
            scaler.step(optimizer)
            scaler.update()
            optimizer.zero_grad(set_to_none=True)

        running_loss += (loss.item() * accum_steps) * images.size(0)
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()

    return running_loss / total, 100.0 * correct / total


@torch.no_grad()
def evaluate(model, loader, criterion, device, use_amp: bool):
    model.eval()
    running_loss, correct, total = 0.0, 0, 0

    for images, labels in loader:
        images = images.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        with torch.amp.autocast(device_type=device.type, enabled=use_amp):
            outputs = model(images)
            loss = criterion(outputs, labels)

        running_loss += loss.item() * images.size(0)
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()

    return running_loss / total, 100.0 * correct / total


def save_checkpoint(filepath, epoch, model, optimizer, scheduler, scaler, best_acc):
    os.makedirs(os.path.dirname(filepath), exist_ok=True)
    torch.save({
        "epoch": epoch,
        "model_state_dict": model.state_dict(),
        "optimizer_state_dict": optimizer.state_dict(),
        "scheduler_state_dict": scheduler.state_dict(),
        "scaler_state_dict": scaler.state_dict(),
        "best_acc": best_acc,
    }, filepath)


def load_checkpoint(filepath, model, optimizer=None, scheduler=None, scaler=None, device="cpu"):
    checkpoint = torch.load(filepath, map_location=device, weights_only=True)
    model.load_state_dict(checkpoint["model_state_dict"])
    if optimizer and "optimizer_state_dict" in checkpoint:
        optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
    if scheduler and "scheduler_state_dict" in checkpoint:
        scheduler.load_state_dict(checkpoint["scheduler_state_dict"])
    if scaler and "scaler_state_dict" in checkpoint:
        scaler.load_state_dict(checkpoint["scaler_state_dict"])
    return checkpoint.get("epoch", 0), checkpoint.get("best_acc", 0.0)


# ==========================================
# 4. Main Execution Loop
# ==========================================
if __name__ == "__main__":
    # --- Configuration ---
    BATCH_SIZE = 128          # Lower to 32 if running on <6GB VRAM
    ACCUM_STEPS = 1           # Increase to 4 if BATCH_SIZE=32 (keeps effective batch=128)
    EPOCHS = 15
    LEARNING_RATE = 1e-3
    CHECKPOINT_DIR = "./checkpoints"
    RESUME_PATH = None        # Set to "./checkpoints/last_model.pt" to resume interrupted runs

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    use_amp = (device.type == "cuda")

    # Enables cuDNN auto-tuner for fixed 224x224 input sizes (extra speed boost)
    if device.type == "cuda":
        torch.backends.cudnn.benchmark = True

    train_loader, val_loader, num_classes = get_dataloaders(
        dataset_type="cifar10", data_dir="./data", batch_size=BATCH_SIZE
    )

    model = ModernAlexNet(num_classes=num_classes).to(device)
    criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
    optimizer = optim.AdamW(model.parameters(), lr=LEARNING_RATE, weight_decay=1e-2)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
    scaler = torch.amp.GradScaler(device=device.type, enabled=use_amp)

    start_epoch = 1
    best_val_acc = 0.0

    # Resume from checkpoint if specified
    if RESUME_PATH and os.path.exists(RESUME_PATH):
        last_epoch, best_val_acc = load_checkpoint(
            RESUME_PATH, model, optimizer, scheduler, scaler, device
        )
        start_epoch = last_epoch + 1
        print(f"Resumed from epoch {last_epoch} (Best Val Acc: {best_val_acc:.2f}%)")

    print(f"Training on {device} | AMP Enabled: {use_amp} | Effective Batch Size: {BATCH_SIZE * ACCUM_STEPS}")

    for epoch in range(start_epoch, EPOCHS + 1):
        train_loss, train_acc = train_one_epoch(
            model, train_loader, criterion, optimizer, scaler, device, use_amp, ACCUM_STEPS
        )
        val_loss, val_acc = evaluate(model, val_loader, criterion, device, use_amp)
        scheduler.step()

        # Always save latest state (protects against Colab timeouts or crashes)
        save_checkpoint(
            os.path.join(CHECKPOINT_DIR, "last_model.pt"),
            epoch, model, optimizer, scheduler, scaler, best_val_acc
        )

        # Save separate file whenever validation accuracy improves
        saved_flag = ""
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            save_checkpoint(
                os.path.join(CHECKPOINT_DIR, "best_model.pt"),
                epoch, model, optimizer, scheduler, scaler, best_val_acc
            )
            saved_flag = " [Saved Best]"
        print(f"Epoch [{epoch:02d}/{EPOCHS}] "
              f"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}% | "
              f"Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.2f}%{saved_flag}")

உள்ளடக்கப்பட்ட முக்கிய மேம்படுத்தல்கள்

  • இரட்டை Checkpointing (best_model.pt & last_model.pt). last_model.pt ஒவ்வொரு epoch-இலும் உங்கள் துல்லியமான optimizer, scheduler, FP16 scaler நிலைகளைச் சேமிக்கிறது; இதனால் செயலிழப்பு அல்லது Google Colab துண்டிப்புக்குப் பிறகு தடையின்றித் தொடரலாம். best_model.pt, அதிகபட்ச சரிபார்ப்புத் துல்லியத்தை எட்டிய epoch-இன் எடைகளைப் பாதுகாக்கிறது.
  • Label Smoothing (label_smoothing=0.1). சத்தமுள்ள பயிற்சி லேபிள்களில் AlexNet-இன் பெரிய fully connected அடுக்குகள் அதீத நம்பிக்கை கொள்வதைத் தடுத்து, பொதுமைப்படுத்தலை மேம்படுத்துகிறது.
  • நினைவகம் மற்றும் வேக மாற்றங்கள். optimizer.zero_grad(set_to_none=True) tensors-ஐப் பூஜ்யமாக்குவதை விடக் குறைவான நினைவக எழுத்துகளைச் செய்கிறது; torch.backends.cudnn.benchmark = True உங்கள் நிலையான 224×224 உள்ளீட்டு வடிவத்திற்கு மிக வேகமான convolution வழிமுறைகளைத் தேர்ந்தெடுக்கிறது.

மேலும் செயற்கை நுண்ணறிவு மற்றும் தொழில்நுட்பச் செய்திகள்