کدهای آماده Image Classification با PyTorch

رفیق برنامه‌نویس! اگه دنبال راه‌حلی هستی که به سرعت و با اطمینان کامل، پروژه‌های Image Classification رو تو PyTorch پیاده‌سازی کنی، جای درستی اومدی. اینجا قراره از صفر تا صد، با کدهای آماده و توضیحات شفاف، همه چیز رو زیر و رو کنیم. این کدهای آماده فقط یک شروع نیستن، بلکه مجموعه‌ای از ابزارهای قدرتمند هستن که می‌تونن سرعت توسعه‌ت رو چند برابر کنن. برای دیدن ابزارها و اسنیپت‌های بیشتر که به کارت میان، حتماً یه سر به فروشگاه ابزارهای برنامه‌نویسی ما بزن!

تماس مستقیم: 09202232789

🎯 خلاصه مقاله در یک نگاه: نقشه راه طبقه‌بندی تصاویر با PyTorch

چرا PyTorch بهترین انتخاب برای Image Classificationه؟

PyTorch مثل یک جعبه ابزار قدرتمند می‌مونه که بهت اجازه می‌ده با انعطاف‌پذیری بالا، مدل‌های یادگیر‌ی عمیق رو پیاده‌سازی کنی. وقتی صحبت از Image Classification میشه، سرعت توسعه، دیباگ آسان و جامعه کاربری فعالش حرف اول رو می‌زنه. برخلاف بعضی فریم‌ورک‌های دیگه، PyTorch با گراف‌های محاسباتی داینامیکش، مسیر رو برای تجربه و خطا (که تو کدهای پایتون آماده ما زیاد به کارت میاد) خیلی هموار می‌کنه.

قدم به قدم با PyTorch: از داده تا مدل آماده

خب، بریم سراغ بخش هیجان‌انگیز قضیه! اینجا قراره گام به گام ببینیم چطور میشه یه پروژه Image Classification رو از صفر تا صد با PyTorch بالا آورد. هدفمون اینه که یه کد تمیز و قابل فهم داشته باشیم که بشه راحت توسعه‌ش داد.

۱. پیش‌نیازها و نصب PyTorch

قبل از هر چیز، باید مطمئن بشیم که محیط برنامه‌نویسیمون آماده‌ست. اگه هنوز PyTorch رو نصب نکردی، کافیه از سایت رسمیش دستور نصب متناسب با سیستم عامل و کارت گرافیکت رو برداری. معمولاً با `pip` یا `conda` انجام میشه:

# نصب PyTorch با CUDA (برای GPU)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# یا بدون CUDA (برای CPU)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

بعد از نصب، برای اطمینان می‌تونی یه تست ساده انجام بدی:

import torch
print(torch.__version__)
print(torch.cuda.is_available()) # True اگه CUDA نصب باشه و GPU فعال باشه

۲. آماده‌سازی داده‌ها (Data Loading & Preprocessing)

داده‌ها قلب هر مدل یادگیری عمیق هستن. تو PyTorch، برای بارگذاری و پیش‌پردازش داده‌های تصویر، معمولاً از `torchvision.datasets` و `torch.utils.data.DataLoader` استفاده می‌کنیم. اینجا یه مثال با مجموعه داده CIFAR-10 رو می‌بینیم:

import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# تعریف ترانسفورم‌ها (عملیات پیش‌پردازش)
transform = transforms.Compose([
    transforms.ToTensor(), # تبدیل تصویر به Tensor
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # نرمال‌سازی
])

# بارگذاری مجموعه داده CIFAR-10
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                             download=True, transform=transform)
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                            download=True, transform=transform)

# تعریف DataLoader برای دسته‌بندی داده‌ها
train_loader = DataLoader(train_dataset, batch_size=64,
                          shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=64,
                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')

جدول زیر، چند تا از مهم‌ترین ترانسفورم‌هایی که برای تصاویر استفاده میشه رو نشون میده:

۳. تعریف معاماری مدل (Model Architecture)

حالا نوبت به قلب شبکه‌مون، یعنی مدل می‌رسه. می‌تونیم یه شبکه عصبی کانولوشنی (CNN) ساده از صفر بسازیم یا از مدل‌های از پیش آموزش‌دیده (Pre-trained Models) استفاده کنیم که کارمون رو خیلی راحت‌تر می‌کنه.

#### ساخت مدل سفارشی (Custom Model)
اینجا یه مثال ساده از یه CNN رو می‌بینیم:

import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5) # 3 کانال ورودی (RGB), 6 فیلتر, سایز فیلتر 5x5
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120) # 16 * 5 * 5 بعد از پولینگ نهایی
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, num_classes)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5) # فلت کردن
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = SimpleCNN(num_classes=10)

#### استفاده از مدل‌های از پیش آموزش‌دیده (Pre-trained Models)
مدل‌هایی مثل ResNet یا VGG که روی مجموعه داده‌های بزرگی مثل ImageNet آموزش دیدن، عملکرد خیلی بهتری دارن. ما می‌تونیم لایه نهایی این مدل‌ها رو برای مجموعه داده خودمون کاستومایز کنیم:

import torchvision.models as models

# بارگذاری ResNet18 از پیش آموزش‌دیده
model = models.resnet18(pretrained=True)

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

# تغییر لایه خروجی برای تطابق با تعداد کلاس‌های ما (مثلاً 10 کلاس برای CIFAR-10)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 10) # 10 کلاس

۴. تابع زیان و بهینه‌ساز (Loss Function & Optimizer)

برای آموزش مدل، به یک تابع زیان (Loss Function) برای محاسبه خطا و یک بهینه‌ساز (Optimizer) برای تنظیم وزن‌ها نیاز داریم. `nn.CrossEntropyLoss` برای طبقه‌بندی تصاویر عالیه و `optim.Adam` یا `optim.SGD` بهینه‌سازهای محبوبی هستن.

import torch.optim as optim

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

# برای مدل‌هایی که لایه FC را تغییر داده‌ایم:
# optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
# یا اگر می‌خواهیم تمام پارامترها به روز شوند:
# optimizer = optim.Adam(model.parameters(), lr=0.001)

۵. حلقه آموزش (Training Loop)

حلقه آموزش جاییه که مدل ما واقعاً یاد می‌گیره. تو هر اپک (epoch)، مدل تمام داده‌های آموزشی رو یک بار می‌بینه، خطا رو محاسبه می‌کنه و وزن‌هاش رو به‌روز می‌کنه.

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

num_epochs = 10

for epoch in range(num_epochs):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)

        optimizer.zero_grad() # صفر کردن گرادیان‌ها

        outputs = model(inputs) # پیش‌بینی مدل
        loss = criterion(outputs, labels) # محاسبه زیان
        loss.backward() # بک‌پروپاگیشن
        optimizer.step() # به‌روزرسانی وزن‌ها

        running_loss += loss.item()
        if i % 2000 == 1999:    # هر 2000 بچ چاپ کن
            print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(train_loader)}], Loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('آموزش به پایان رسید.')

۶. ارزیابی مدل (Model Evaluation)

بعد از آموزش، باید ببینیم مدلمون چقدر خوب کار می‌کنه. برای این کار از مجموعه داده تست استفاده می‌کنیم و دقِت مدل رو محاسبه می‌کنیم.

correct = 0
total = 0
with torch.no_grad(): # گرادیان‌ها رو برای ارزیابی محاسبه نکن
    for data in test_loader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1) # گرفتن کلاس با بیشترین امتیاز
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'دقِت مدل روی 10000 تصویر تست: {100 * correct / total:.2f}%')

۷. کدهای کامل و یکپارچه برای شروع سریع

برای اینکه بتونی سریع‌تر شروع کنی و یک دید کلی از کل فرآیند داشته باشی، اینجا یه کدهای آماده کامل رو برات آوردم. می‌تونی این رو کپی کنی و با تغییرات جزئی برای پروژه‌های خودت استفاده کنی.
برای دسترسی به این مدل‌ها و اسنیپت‌های بیشتر، حتما به صفحه کدهای آماده و اسنیپت ما سر بزن!

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np

# 1. تنظیمات اولیه و آماده‌سازی دستگاه
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"استفاده از دستگاه: {device}")

# 2. آماده‌سازی داده‌ها (CIFAR-10)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# (اختیاری) نمایش چند تصویر آموزشی
def imshow(img):
    img = img / 2 + 0.5  # denormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

# dataiter = iter(train_loader)
# images, labels = next(dataiter)
# imshow(torchvision.utils.make_grid(images))
# print(' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))

# 3. تعریف معماری مدل (Simple CNN)
class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, num_classes)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = SimpleCNN(num_classes=10)
model.to(device)

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

# 5. حلقه آموزش
num_epochs = 10
print("شروع آموزش...")
for epoch in range(num_epochs):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)

        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:
            print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(train_loader)}], Loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('آموزش به پایان رسید.')

# 6. ذخیره مدل
PATH = './cifar_net.pth'
torch.save(model.state_dict(), PATH)
print(f"مدل در {PATH} ذخیره شد.")

# 7. ارزیابی مدل
model.load_state_dict(torch.load(PATH)) # بارگذاری مدل ذخیره شده
model.eval() # قرار دادن مدل در حالت ارزیابی

correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'دقِت مدل روی {total} تصویر تست: {100 * correct / total:.2f}%')

# ارزیابی دقِت بر اساس هر کلاس
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in test_loader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1

print("nدقِت بر اساس هر کلاس:")
for i in range(10):
    if class_total[i] > 0:
        print(f'دقِت {classes[i]:5s} : {100 * class_correct[i] / class_total[i]:.2f}%')
    else:
        print(f'برای کلاس {classes[i]:5s} داده ای وجود نداشت.')

بهینه‌سازی و نکات پیشرفته

آموزش یک مدل کارآمد فقط ساختن و ران کردن کد نیست. برای اینکه بهترین عملکرد رو بگیری، باید به چند نکته توجه کنی:

* **Data Augmentation:** تکنیک‌هایی مثل چرخش تصادفی، برش، تغییر رنگ و… به مدل کمک می‌کنه تا تعمیم‌پذیری (generalization) بهتری داشته باشه و Overfitting کمتر بشه. `torchvision.transforms` ابزارهای خوبی برای این کار داره.
* **Learning Rate Schedulers:** نرخ یادگیری رو در طول آموزش تغییر می‌ده. مثلاً با `torch.optim.lr_scheduler.StepLR` می‌تونی نرخ یادگیری رو بعد از چند اپک کم کنی.
* **Early Stopping:** وقتی دقِت مدل روی داده‌های اعتبارسنجی (validation data) برای چند اپک متوالی بهبود پیدا نکرد، آموزش رو متوقف کن تا از Overfitting جلوگیری بشه.
* **GPU Utilization:** همیشه مطمئن شو که داری از GPU استفاده می‌کنی (اگر داری!). PyTorch با `model.to(device)` و `inputs.to(device)` این کار رو راحت می‌کنه.

عیب‌یابی سریع (Troubleshooting)

تو مسیر پیاده‌سازی این کدها، ممکنه با مشکلاتی روبرو بشی. نگران نباش، این طبیعیه! اینجا به چند تا از رایج‌ترین مشکلات و راه‌حل‌هاشون اشاره می‌کنم:

پرسش‌های متداول (FAQ)