آموزش پیشرفته PyTorch: یادگیری انتقالی، مدیریت حافظه و بهینه‌سازی مدل‌ها

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torchvision.models import resnet18, ResNet18_Weights

# تنظیم دستگاه (GPU یا CPU)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# بارگذاری مدل از پیش آموزش‌دیده
model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)

# فریز کردن لایه‌های مدل برای جلوگیری از تغییر وزن‌ها
for param in model.parameters():
    param.requires_grad = False

# جایگزینی لایه نهایی برای تطبیق با تعداد کلاس‌های جدید (مثلاً 2 کلاس: گربه و سگ)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)  # دو کلاس خروجی
model = model.to(device)

# تعریف تابع تبدیل برای پیش‌پردازش تصاویر
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

#   هستند'train' و 'test'  فرض کنید داده‌ها در پوشه‌های 
train_dataset = torchvision.datasets.ImageFolder('path/to/train', transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)

# تعریف تابع loss و بهینه‌ساز
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)

# آموزش مدل
model.train()
for epoch in range(5):  # 5 epoch برای مثال
    running_loss = 0.0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}")

print("آموزش کامل شد!")

import torch
import torch.nn as nn
import torch.optim as optim
from torch.cuda.amp import GradScaler, autocast
from torchvision.models import resnet18, ResNet18_Weights

# تنظیم دستگاه
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# بارگذاری مدل
model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scaler = GradScaler()  # برای Mixed Precision

# فرض کنید train_loader از قبل تعریف شده
model.train()
for epoch in range(5):
    running_loss = 0.0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        
        # استفاده از autocast برای محاسبات با دقت ترکیبی
        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, labels)
        
        # مقیاس‌بندی گرادیان‌ها برای جلوگیری از underflow
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
        running_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}")

print("آموزش با Mixed Precision کامل شد!")

import torch
import torchvision.models as models

# بارگذاری مدل
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
model.eval()

# اعمال Quantization پویا
quantized_model = torch.quantization.quantize_dynamic(
    model, {torch.nn.Linear}, dtype=torch.qint8
)

# ذخیره مدل
torch.jit.save(torch.jit.script(quantized_model), "quantized_resnet18.pt")

print("مدل Quantized ذخیره شد!")

from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch
from torch.utils.data import DataLoader, Dataset

# تعریف یک دیتاست نمونه
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len=128):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_len = max_len
    
    def __len__(self):
        return len(self.texts)
    
    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]
        encoding = self.tokenizer(text, return_tensors='pt', max_length=self.max_len, truncation=True, padding='max_length')
        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

# بارگذاری مدل و توکنایزر
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2).to('cuda')

# داده‌های نمونه
texts = ["این متن مثبت است", "این متن منفی است"]
labels = [1, 0]
dataset = CustomDataset(texts, labels, tokenizer)
dataloader = DataLoader(dataset, batch_size=2)

# بهینه‌ساز
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

# آموزش
model.train()
for epoch in range(3):
    for batch in dataloader:
        inputs = {k: v.to('cuda') for k, v in batch.items() if k != 'labels'}
        labels = batch['labels'].to('cuda')
        outputs = model(**inputs, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
        print(f"Epoch {epoch+1}, Loss: {loss.item()}")

print("Fine-tuning کامل شد!")