উদাহরণসহ Distributed Training এবং Precision Handling

PyTorch-এ Distributed Training এবং Precision Handling করা খুবই কার্যকরী, বিশেষ করে যখন আপনার মডেলটি বড় এবং ডেটাসেটটি বিশাল হয়। নিচে এই দুটি বৈশিষ্ট্যের উদাহরণসহ বিস্তারিত আলোচনা করা হলো।

১. Distributed Training

Distributed Training ব্যবহার করে আপনি একাধিক GPU বা মেশিনে একই সময়ে প্রশিক্ষণ করতে পারেন। এটি প্রশিক্ষণের সময় এবং উত্পাদনশীলতা বাড়াতে সাহায্য করে।

১.১. PyTorch-এ Distributed Training সেটআপ

Distributed Training করতে, আপনাকে প্রথমে PyTorch এর torch.distributed প্যাকেজ ব্যবহার করতে হবে।

import torch
import torch.distributed as dist
import torch.multiprocessing as mp
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# মডেল তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

def train(rank, world_size):
    # Distributed backend সেটআপ
    dist.init_process_group("gloo", rank=rank, world_size=world_size)

    # মডেল তৈরি
    model = SimpleNN().to(rank)
    model = nn.parallel.DistributedDataParallel(model, device_ids=[rank])

    # ডেটা লোড করা
    x_train = torch.randn(1000, 10)
    y_train = torch.randn(1000, 1)
    dataset = TensorDataset(x_train, y_train)
    train_loader = DataLoader(dataset, batch_size=32, shuffle=True)

    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # প্রশিক্ষণ
    for epoch in range(10):
        for inputs, targets in train_loader:
            inputs, targets = inputs.to(rank), targets.to(rank)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            loss.backward()
            optimizer.step()

def main():
    world_size = 2  # সংখ্যা GPU
    mp.spawn(train, args=(world_size,), nprocs=world_size, join=True)

if __name__ == "__main__":
    main()

২. Precision Handling

Precision Handling (Mixed Precision Training) ব্যবহার করে আপনি GPU তে মেমোরি সঞ্চয় এবং প্রশিক্ষণের গতি বাড়াতে পারেন। PyTorch-এ এটি torch.cuda.amp ব্যবহার করে করা হয়।

২.১. Mixed Precision Training সেটআপ

from torch.cuda.amp import autocast, GradScaler

# মডেল তৈরি
model = SimpleNN().to(device)

# GradScaler তৈরি
scaler = GradScaler()

# প্রশিক্ষণ লুপে মিক্সড প্রিসিশন ব্যবহার
for epoch in range(10):
    for inputs, targets in train_loader:
        optimizer.zero_grad()

        # অটোকাস্ট ব্যবহার করে ফরোয়ার্ড পাস
        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, targets)

        # গ্রেডিয়েন্ট স্কেল করা
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()

উপসংহার

এই উদাহরণগুলি প্রদর্শন করে কিভাবে PyTorch-এ Distributed Training এবং Precision Handling করা যায়। Distributed Training আপনার মডেল প্রশিক্ষণের গতি বাড়াতে সাহায্য করে, যখন Mixed Precision Training GPU মেমোরির দক্ষ ব্যবহার নিশ্চিত করে।