PyTorch چیست؟ آموزش کامل ساخت و آموزش شبکه عصبی با پایتون

PyTorch یا پایتورچ یکی از مهم‌ترین فریم‌ورک‌های برنامه‌نویسی هوش مصنوعی، یادگیری ماشین و یادگیری عمیق است. بسیاری از مدل‌های پردازش متن، بینایی ماشین، تولید تصویر، پردازش صوت و مدل‌های زبانی با PyTorch توسعه یا آموزش داده می‌شوند.

اگر بخواهید تنها از یک مدل هوش مصنوعی آماده در اپلیکیشن خود استفاده کنید، معمولاً اتصال به یک API کافی است. اما اگر بخواهید معماری مدل را بسازید، داده‌های آموزشی را کنترل کنید، وزن‌ها را تغییر دهید یا یک مدل اختصاصی آموزش دهید، باید با فریم‌ورک‌هایی مانند PyTorch آشنا باشید.

در این آموزش یاد می‌گیرید:

• PyTorch چیست و چه کاربردی دارد.
• Tensor چیست.
• تفاوت Tensor با آرایه NumPy چیست.
• CPU، GPU، CUDA و MPS چگونه استفاده می‌شوند.
• Dataset و DataLoader چه کاری انجام می‌دهند.
• Autograd چگونه گرادیان را محاسبه می‌کند.
• شبکه عصبی را با nn.Module بسازید.
• Loss Function و Optimizer را تنظیم کنید.
• یک مدل واقعی را آموزش دهید.
• مدل را روی داده آزمایشی ارزیابی کنید.
• وزن‌های مدل را ذخیره و بارگذاری کنید.
• برای یک تصویر جدید پیش‌بینی انجام دهید.
• تفاوت آموزش مدل با استفاده از API هوش مصنوعی را درک کنید.

پروژه عملی این مقاله، ساخت یک شبکه عصبی برای تشخیص نوع پوشاک در مجموعه‌داده FashionMNIST است.

PyTorch چیست؟

PyTorch یک کتابخانه متن‌باز یادگیری ماشین است که ابزارهای موردنیاز برای محاسبات Tensor، ساخت شبکه عصبی، محاسبه خودکار گرادیان، آموزش مدل و اجرای Inference را فراهم می‌کند.

با PyTorch می‌توانید پروژه‌هایی مانند موارد زیر بسازید:

• طبقه‌بندی تصویر
• تشخیص اشیا
• پردازش زبان طبیعی
• تحلیل احساسات
• مدل‌های تبدیل گفتار به متن
• شبکه‌های عصبی کانولوشنی
• مدل‌های Transformer
• مدل‌های تولید متن
• مدل‌های تولید تصویر
• سیستم‌های پیشنهاددهنده
• مدل‌های پیش‌بینی
• مدل‌های چندوجهی
• پروژه‌های پژوهشی یادگیری عمیق

طبق مستندات مقدماتی PyTorch، یک گردش کار معمول یادگیری ماشین شامل آماده‌سازی داده، ساخت مدل، بهینه‌سازی پارامترها و ذخیره مدل آموزش‌دیده است.

PyTorch چگونه تلفظ می‌شود؟

PyTorch معمولاً «پای‌تورچ» تلفظ و در فارسی به شکل‌های زیر نوشته می‌شود:

• پایتورچ
• پای‌تورچ
• PyTorch

در محتوای فارسی بهتر است در اولین استفاده، هر دو شکل نوشته شود:

PyTorch یا پایتورچ

PyTorch چه تفاوتی با هوش مصنوعی آماده دارد؟

PyTorch یک مدل هوش مصنوعی نیست. این فریم‌ورک ابزاری برای ساخت، آموزش و اجرای مدل است.

برای مثال:

• PyTorch ابزار توسعه مدل است.
• شبکه عصبی، معماری مدل است.
• وزن‌های آموزش‌دیده، دانش آموخته‌شده مدل هستند.
• API روشی برای دسترسی نرم‌افزار به مدل آماده است.

اگر فقط بخواهید یک مدل زبانی آماده را به اپلیکیشن متصل کنید، نیازی نیست آن مدل را با PyTorch از ابتدا آموزش دهید. می‌توانید از API هوش مصنوعی استفاده کنید.

اگر بخواهید یک مدل طبقه‌بندی اختصاصی برای داده‌های خودتان بسازید، PyTorch یکی از گزینه‌های مناسب است.

کاربرد PyTorch در مدل‌های زبانی بزرگ

بخش مهمی از ابزارهای مدل‌های زبانی بزرگ بر پایه PyTorch کار می‌کنند.

برای نمونه، PyTorch در این مراحل کاربرد دارد:

• تعریف معماری Transformer
• آموزش اولیه مدل
• فاین‌تیون (Fine-tuning)
• آموزش LoRA
• محاسبه Gradient
• اجرای مدل روی GPU
• مدیریت وزن‌ها
• Quantization
• ارزیابی مدل
• تبدیل مدل به فرمت‌های دیگر

کتابخانه Transformers نیز در بسیاری از مدل‌ها از PyTorch به‌عنوان Backend استفاده می‌کند.

تفاوت PyTorch و TensorFlow

PyTorch و TensorFlow دو فریم‌ورک شناخته‌شده یادگیری عمیق هستند.

انتخاب میان این دو به تیم، مدل، زیرساخت و ابزارهای مورد استفاده بستگی دارد. برای یادگیری مفاهیم شبکه عصبی و کار با مدل‌های مدرن متن‌باز، PyTorch مسیر مناسبی است.

اجزای مهم PyTorch

پیش‌نیازهای آموزش

برای اجرای این آموزش به موارد زیر نیاز دارید:

• Python نسخه 3.10 یا جدیدتر
• pip
• آشنایی مقدماتی با پایتون
• حداقل چند گیگابایت فضای خالی
• اینترنت برای دریافت دیتاست
• GPU اختیاری

پروژه FashionMNIST روی CPU نیز اجرا می‌شود. GPU می‌تواند سرعت آموزش را افزایش دهد، اما برای یادگیری این مثال ضروری نیست.

مرحله اول: ساخت پوشه پروژه

یک پوشه جدید ایجاد کنید:

mkdir pytorch-fashion-classifier
cd pytorch-fashion-classifier

محیط مجازی بسازید.

در Linux و macOS:

python3 -m venv .venv
source .venv/bin/activate

در Windows PowerShell:

python -m venv .venv
.venv\Scripts\Activate.ps1

مرحله دوم: نصب PyTorch

برای نصب پایه می‌توانید از این دستور استفاده کنید:

pip install torch torchvision

با این حال، دستور نصب مناسب GPU به سیستم‌عامل، نوع سخت‌افزار و نسخه CUDA یا ROCm بستگی دارد. برای نصب روی GPU از ابزار انتخاب‌گر رسمی در صفحه نصب PyTorch استفاده کنید.

در این صفحه گزینه‌های زیر را انتخاب می‌کنید:

• سیستم‌عامل
• Package Manager
• زبان
• Compute Platform
• نسخه پایدار یا Preview

اگر GPU سازگار ندارید، گزینه CPU را انتخاب کنید.

فایل requirements.txt پروژه:

torch
torchvision

نصب وابستگی‌ها:

pip install -r requirements.txt

مرحله سوم: بررسی نصب

فایل check_pytorch.py را بسازید:

import torch

print("PyTorch version:", torch.__version__)
print("CUDA available:", torch.cuda.is_available())
print("MPS available:", torch.backends.mps.is_available())

if torch.cuda.is_available():
    print("CUDA device:", torch.cuda.get_device_name(0))

اجرا کنید:

python check_pytorch.py

خروجی نمونه روی سیستم بدون GPU:

PyTorch version: 2.x.x
CUDA available: False
MPS available: False

خروجی نمونه روی سیستم دارای GPU انویدیا:

PyTorch version: 2.x.x
CUDA available: True
MPS available: False
CUDA device: NVIDIA ...

Device در PyTorch چیست؟

Tensor و مدل باید روی یک Device یکسان قرار داشته باشند.

Device ممکن است یکی از این موارد باشد:

• CPU
• CUDA برای GPUهای سازگار انویدیا
• MPS برای برخی سیستم‌های Apple Silicon
• Backendهای سازگار دیگر

تابع زیر Device مناسب را انتخاب می‌کند:

import torch


def get_device() -> torch.device:
    if torch.cuda.is_available():
        return torch.device("cuda")

    if torch.backends.mps.is_available():
        return torch.device("mps")

    return torch.device("cpu")


device = get_device()

print("Selected device:", device)

برای انتقال Tensor به Device:

tensor = tensor.to(device)

برای انتقال مدل:

model = model.to(device)

اگر مدل روی GPU و داده روی CPU باشد، اجرای عملیات با خطا مواجه می‌شود.

Tensor چیست؟

Tensor ساختار اصلی داده در PyTorch است. Tensor را می‌توان آرایه‌ای چندبعدی در نظر گرفت.

نمونه Scalar یا Tensor بدون بُعد:

import torch

scalar = torch.tensor(7)

print(scalar)
print(scalar.ndim)

بردار یک‌بعدی:

vector = torch.tensor(
    [1.0, 2.0, 3.0]
)

print(vector)
print(vector.shape)

ماتریس دوبعدی:

matrix = torch.tensor(
    [
        [1.0, 2.0],
        [3.0, 4.0],
    ]
)

print(matrix)
print(matrix.shape)

Tensor سه‌بعدی:

tensor_3d = torch.tensor(
    [
        [
            [1.0, 2.0],
            [3.0, 4.0],
        ],
        [
            [5.0, 6.0],
            [7.0, 8.0],
        ],
    ]
)

print(tensor_3d.shape)

خروجی Shape:

torch.Size([2, 2, 2])

ساخت Tensorهای رایج

Tensor صفر:

zeros = torch.zeros(3, 4)

Tensor یک:

ones = torch.ones(2, 3)

اعداد تصادفی:

random_tensor = torch.rand(3, 3)

اعداد تصادفی با توزیع نرمال:

normal_tensor = torch.randn(3, 3)

دنباله اعداد:

numbers = torch.arange(
    start=0,
    end=10,
    step=2,
)

ساخت Tensor شبیه Tensor دیگر:

source = torch.rand(2, 3)

same_shape_zeros = torch.zeros_like(source)
same_shape_ones = torch.ones_like(source)

ویژگی‌های Tensor

tensor = torch.rand(
    2,
    3,
    dtype=torch.float32,
)

print("Shape:", tensor.shape)
print("Data type:", tensor.dtype)
print("Device:", tensor.device)

سه ویژگی مهم:

• shape: ابعاد Tensor
• dtype: نوع داده
• device: محل نگهداری و اجرا

انواع داده مهم

نوع داده ورودی باید با عملیات و مدل سازگار باشد.

برای مثال، تصویر ورودی مدل معمولاً Float و برچسب کلاس برای CrossEntropyLoss معمولاً torch.int64 است.

عملیات ریاضی روی Tensor

import torch

a = torch.tensor(
    [1.0, 2.0, 3.0]
)

b = torch.tensor(
    [4.0, 5.0, 6.0]
)

print("Addition:", a + b)
print("Subtraction:", a - b)
print("Element-wise multiplication:", a * b)
print("Division:", a / b)
print("Dot product:", torch.dot(a, b))

ضرب ماتریسی:

matrix_a = torch.rand(2, 3)
matrix_b = torch.rand(3, 4)

result = matrix_a @ matrix_b

print(result.shape)

خروجی:

torch.Size([2, 4])

Reshape، Squeeze و Unsqueeze

تغییر Shape:

tensor = torch.arange(12)

reshaped = tensor.reshape(3, 4)

print(reshaped)

افزودن بُعد:

image = torch.rand(28, 28)

batch_image = image.unsqueeze(0)

print(batch_image.shape)

خروجی:

torch.Size([1, 28, 28])

حذف بُعدهای دارای اندازه یک:

restored = batch_image.squeeze(0)

print(restored.shape)

در شبکه‌های عصبی، بُعد اول معمولاً Batch Size است.

تفاوت Tensor و NumPy Array

Tensor و آرایه NumPy شباهت زیادی دارند، اما Tensor می‌تواند:

• روی GPU اجرا شود.
• Gradient را نگه دارد.
• بخشی از Graph محاسباتی باشد.
• مستقیماً در شبکه عصبی استفاده شود.

تبدیل NumPy به Tensor:

import numpy as np
import torch

array = np.array(
    [1.0, 2.0, 3.0],
    dtype=np.float32,
)

tensor = torch.from_numpy(array)

print(tensor)

تبدیل Tensor به NumPy:

array_again = tensor.cpu().numpy()

print(array_again)

اگر Tensor روی GPU باشد، ابتدا باید آن را به CPU منتقل کنید.

Autograd چیست؟

مدل در فرایند آموزش باید بداند هر پارامتر چه اثری بر خطا دارد. این اطلاعات از Gradient یا گرادیان به دست می‌آید.

PyTorch با سیستم Autograd مشتق عملیات را به‌صورت خودکار محاسبه می‌کند.

مثال ساده:

import torch

x = torch.tensor(
    3.0,
    requires_grad=True,
)

y = x ** 2 + 2 * x + 1

y.backward()

print("x:", x.item())
print("y:", y.item())
print("dy/dx:", x.grad.item())

تابع ما:

y = x² + 2x + 1

مشتق:

dy/dx = 2x + 2

در x = 3:

dy/dx = 8

PyTorch این مقدار را در x.grad قرار می‌دهد.

Graph محاسباتی

وقتی requires_grad=True باشد، PyTorch عملیات مرتبط را در Graph محاسباتی دنبال می‌کند.

x = torch.tensor(
    [1.0, 2.0, 3.0],
    requires_grad=True,
)

y = x * 2
z = y.mean()

z.backward()

print(x.grad)

پس از backward() گرادیان متغیرهای موردنیاز محاسبه می‌شود.

این قابلیت پایه آموزش شبکه عصبی است.

چرا Gradient را صفر می‌کنیم؟

PyTorch گرادیان‌ها را به‌صورت پیش‌فرض جمع می‌کند. بنابراین در هر مرحله آموزش باید Gradient قبلی را پاک کنیم:

optimizer.zero_grad()

یا:

optimizer.zero_grad(
    set_to_none=True
)

اگر این مرحله فراموش شود، گرادیان Batchهای قبلی با Batch جدید جمع می‌شود و آموزش رفتار مورد انتظار را نخواهد داشت.

خاموش‌کردن Gradient در Inference

هنگام ارزیابی یا پیش‌بینی نیازی به محاسبه Gradient نداریم:

with torch.no_grad():
    predictions = model(inputs)

این کار مصرف حافظه را کاهش می‌دهد و اجرای Inference را ساده‌تر می‌کند.

Dataset چیست؟

Dataset نحوه دسترسی به نمونه‌های داده را تعریف می‌کند.

هر نمونه معمولاً شامل دو بخش است:

Input
Label

برای مثال در طبقه‌بندی تصویر:

تصویر کفش
برچسب Sneaker

PyTorch Dataset معمولاً این دو متد را دارد:

__len__()

تعداد نمونه‌ها را برمی‌گرداند.

__getitem__(index)

یک نمونه مشخص را دریافت می‌کند.

DataLoader چیست؟

DataLoader داده‌های Dataset را به Batch تقسیم و برای آموزش آماده می‌کند.

کاربردهای آن:

• ساخت Batch
• Shuffle کردن داده
• بارگذاری موازی
• پیمایش ساده Dataset
• مدیریت Batchهای آخر

نمونه:

from torch.utils.data import DataLoader

train_loader = DataLoader(
    train_dataset,
    batch_size=64,
    shuffle=True,
)

طبق راهنمای Dataset و DataLoader در PyTorch، Dataset نمونه‌ها و برچسب‌ها را نگه می‌دارد و DataLoader امکان پیمایش دسته‌ای داده را فراهم می‌کند.

FashionMNIST چیست؟

FashionMNIST یک مجموعه‌داده تصویری برای آموزش طبقه‌بندی است. این دیتاست شامل تصویرهای خاکستری ۲۸ در ۲۸ پیکسل از انواع پوشاک است.

کلاس‌ها:

CLASS_NAMES = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

این دیتاست برای یادگیری مفاهیم مناسب است، اما یک معیار کامل برای ارزیابی مدل‌های بینایی ماشین در کاربرد واقعی محسوب نمی‌شود.

مرحله چهارم: دریافت Dataset

فایل data.py را بسازید:

from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

BATCH_SIZE = 64

train_dataset = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
)

test_dataset = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
)

train_loader = DataLoader(
    train_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
)

test_loader = DataLoader(
    test_dataset,
    batch_size=BATCH_SIZE,
    shuffle=False,
)

print(
    "Train samples:",
    len(train_dataset),
)

print(
    "Test samples:",
    len(test_dataset),
)

images, labels = next(
    iter(train_loader)
)

print("Image batch:", images.shape)
print("Label batch:", labels.shape)

خروجی Shape تصاویر:

torch.Size([64, 1, 28, 28])

ابعاد به‌ترتیب:

Batch Size
Channel
Height
Width

این تصاویر تک‌کاناله و خاکستری هستند.

Transform چیست؟

داده خام همیشه مستقیماً آماده ورود به مدل نیست. Transform داده را پیش‌پردازش می‌کند.

در پروژه از این Transform استفاده کرده‌ایم:

ToTensor()

این تبدیل تصویر را به Tensor تبدیل و مقدار پیکسل‌ها را برای قالب مورد انتظار آماده می‌کند.

در پروژه‌های دیگر می‌توان از تبدیل‌هایی مانند موارد زیر استفاده کرد:

• Resize
• Crop
• Normalize
• Random Rotation
• Random Flip
• Color Jitter

تبدیل‌های تصادفی معمولاً فقط برای داده Train استفاده می‌شوند و نباید بدون بررسی روی داده Test اعمال شوند.

ساخت Dataset اختصاصی

فرض کنید داده‌های شما در قالب فهرستی از ویژگی‌ها و برچسب‌ها قرار دارند:

import torch
from torch.utils.data import Dataset


class SimpleDataset(Dataset):
    def __init__(
        self,
        features,
        labels,
    ):
        self.features = torch.tensor(
            features,
            dtype=torch.float32,
        )

        self.labels = torch.tensor(
            labels,
            dtype=torch.long,
        )

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, index):
        return (
            self.features[index],
            self.labels[index],
        )

استفاده:

features = [
    [0.2, 0.5],
    [0.9, 0.1],
    [0.4, 0.7],
]

labels = [
    0,
    1,
    0,
]

dataset = SimpleDataset(
    features,
    labels,
)

print(dataset[0])

nn.Module چیست؟

در PyTorch شبکه عصبی معمولاً از nn.Module ارث‌بری می‌کند.

ساختار پایه:

import torch
from torch import nn


class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(
        self,
        x: torch.Tensor,
    ) -> torch.Tensor:
        return x

در متد __init__ لایه‌ها تعریف می‌شوند و در forward مسیر عبور داده مشخص می‌شود.

معمولاً نباید متد forward را مستقیم فراخوانی کنید:

output = model.forward(inputs)

روش معمول:

output = model(inputs)

این روش Hookها و رفتار داخلی nn.Module را نیز حفظ می‌کند.

مرحله پنجم: ساخت شبکه عصبی

فایل model.py:

import torch
from torch import nn


class FashionClassifier(nn.Module):
    def __init__(self):
        super().__init__()

        self.flatten = nn.Flatten()

        self.network = nn.Sequential(
            nn.Linear(
                28 * 28,
                512,
            ),
            nn.ReLU(),
            nn.Dropout(p=0.2),
            nn.Linear(
                512,
                256,
            ),
            nn.ReLU(),
            nn.Linear(
                256,
                10,
            ),
        )

    def forward(
        self,
        x: torch.Tensor,
    ) -> torch.Tensor:
        x = self.flatten(x)
        logits = self.network(x)

        return logits

این مدل تصویر ۲۸ در ۲۸ را به بردار ۷۸۴ عضوی تبدیل می‌کند:

28 × 28 = 784

سپس داده از لایه‌های زیر عبور می‌کند:

784
→ 512
→ 256
→ 10

خروجی ده مقدار Logit است؛ یک مقدار برای هر کلاس.

لایه Linear چیست؟

لایه Linear یک تبدیل خطی روی ورودی انجام می‌دهد:

nn.Linear(
    in_features=784,
    out_features=512,
)

این لایه دارای Weight و Bias قابل آموزش است.

تابع ReLU چیست؟

ReLU یکی از توابع فعال‌سازی رایج است:

nn.ReLU()

رفتار آن:

اگر x مثبت باشد: x
اگر x منفی باشد: 0

تابع فعال‌سازی به شبکه امکان می‌دهد روابط غیرخطی را یاد بگیرد.

Dropout چیست؟

Dropout در زمان آموزش بخشی از فعال‌سازی‌ها را به‌صورت تصادفی صفر می‌کند:

nn.Dropout(p=0.2)

این روش می‌تواند در برخی مدل‌ها به کاهش بیش‌برازش یا Overfitting کمک کند.

Dropout در حالت ارزیابی باید غیرفعال باشد. به همین دلیل پیش از ارزیابی از این دستور استفاده می‌کنیم:

model.eval()

Logit چیست؟

خروجی خام لایه آخر Logit نامیده می‌شود.

نمونه:

[-1.2, 0.4, 2.7, 0.1, ...]

برای CrossEntropyLoss لازم نیست خودمان Softmax را پیش از Loss اجرا کنیم. این Loss عملیات لازم را به‌شکل مناسب انجام می‌دهد.

استفاده اشتباه:

probabilities = torch.softmax(
    logits,
    dim=1,
)

loss = loss_fn(
    probabilities,
    labels,
)

روش درست:

loss = loss_fn(
    logits,
    labels,
)

برای نمایش احتمال در مرحله Inference می‌توان Softmax را جداگانه محاسبه کرد.

Loss Function چیست؟

Loss Function میزان خطای مدل را اندازه‌گیری می‌کند.

برای طبقه‌بندی چندکلاسه:

loss_fn = nn.CrossEntropyLoss()

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

Optimizer چیست؟

Optimizer پارامترهای مدل را بر اساس Gradient به‌روزرسانی می‌کند.

نمونه با AdamW:

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=1e-3,
)

پارامتر lr همان Learning Rate است.

Learning Rate بیش از حد زیاد می‌تواند آموزش را ناپایدار کند. مقدار بسیار کم نیز ممکن است آموزش را کند کند.

مراحل یک Training Step

هر مرحله آموزش معمولاً شامل این مراحل است:

optimizer.zero_grad(
    set_to_none=True
)

logits = model(images)

loss = loss_fn(
    logits,
    labels,
)

loss.backward()

optimizer.step()

ترتیب مراحل:

1. پاک‌کردن Gradient قبلی
2. Forward Pass
3. محاسبه Loss
4. Backward Pass
5. به‌روزرسانی پارامترها

مرحله ششم: ساخت حلقه آموزش

فایل train.py:

import torch
from torch import nn
from torch.utils.data import DataLoader


def train_one_epoch(
    model: nn.Module,
    data_loader: DataLoader,
    loss_fn: nn.Module,
    optimizer: torch.optim.Optimizer,
    device: torch.device,
) -> tuple[float, float]:
    model.train()

    total_loss = 0.0
    correct_predictions = 0
    total_samples = 0

    for images, labels in data_loader:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad(
            set_to_none=True
        )

        logits = model(images)

        loss = loss_fn(
            logits,
            labels,
        )

        loss.backward()

        optimizer.step()

        batch_size = labels.size(0)

        total_loss += (
            loss.item() * batch_size
        )

        predictions = logits.argmax(
            dim=1
        )

        correct_predictions += (
            predictions == labels
        ).sum().item()

        total_samples += batch_size

    average_loss = (
        total_loss / total_samples
    )

    accuracy = (
        correct_predictions
        / total_samples
    )

    return average_loss, accuracy

model.train چه کاری انجام می‌دهد؟

این دستور مدل را وارد حالت آموزش می‌کند:

model.train()

برخی لایه‌ها در حالت Train و Eval رفتار متفاوت دارند:

• Dropout
• Batch Normalization

model.train() محاسبه Gradient را به‌تنهایی فعال نمی‌کند؛ بلکه حالت رفتاری لایه‌ها را تنظیم می‌کند.

مرحله هفتم: ساخت تابع ارزیابی

در همان فایل:

def evaluate(
    model: nn.Module,
    data_loader: DataLoader,
    loss_fn: nn.Module,
    device: torch.device,
) -> tuple[float, float]:
    model.eval()

    total_loss = 0.0
    correct_predictions = 0
    total_samples = 0

    with torch.no_grad():
        for images, labels in data_loader:
            images = images.to(device)
            labels = labels.to(device)

            logits = model(images)

            loss = loss_fn(
                logits,
                labels,
            )

            batch_size = labels.size(0)

            total_loss += (
                loss.item() * batch_size
            )

            predictions = logits.argmax(
                dim=1
            )

            correct_predictions += (
                predictions == labels
            ).sum().item()

            total_samples += batch_size

    average_loss = (
        total_loss / total_samples
    )

    accuracy = (
        correct_predictions
        / total_samples
    )

    return average_loss, accuracy

دو تفاوت اصلی ارزیابی:

model.eval()

و:

with torch.no_grad():

اولی رفتار لایه‌ها را برای ارزیابی تنظیم و دومی محاسبه Gradient را متوقف می‌کند.

کد کامل پروژه

فایل main.py:

import random

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

RANDOM_SEED = 42
BATCH_SIZE = 64
LEARNING_RATE = 1e-3
EPOCHS = 5
MODEL_PATH = "fashion_model.pth"

CLASS_NAMES = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]


def set_seed(seed: int) -> None:
    random.seed(seed)
    torch.manual_seed(seed)

    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)


def get_device() -> torch.device:
    if torch.cuda.is_available():
        return torch.device("cuda")

    if torch.backends.mps.is_available():
        return torch.device("mps")

    return torch.device("cpu")


class FashionClassifier(nn.Module):
    def __init__(self):
        super().__init__()

        self.flatten = nn.Flatten()

        self.network = nn.Sequential(
            nn.Linear(
                28 * 28,
                512,
            ),
            nn.ReLU(),
            nn.Dropout(p=0.2),
            nn.Linear(
                512,
                256,
            ),
            nn.ReLU(),
            nn.Linear(
                256,
                len(CLASS_NAMES),
            ),
        )

    def forward(
        self,
        x: torch.Tensor,
    ) -> torch.Tensor:
        x = self.flatten(x)

        return self.network(x)


def build_data_loaders():
    train_dataset = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor(),
    )

    test_dataset = datasets.FashionMNIST(
        root="data",
        train=False,
        download=True,
        transform=ToTensor(),
    )

    train_loader = DataLoader(
        train_dataset,
        batch_size=BATCH_SIZE,
        shuffle=True,
    )

    test_loader = DataLoader(
        test_dataset,
        batch_size=BATCH_SIZE,
        shuffle=False,
    )

    return (
        train_dataset,
        test_dataset,
        train_loader,
        test_loader,
    )


def train_one_epoch(
    model,
    data_loader,
    loss_fn,
    optimizer,
    device,
):
    model.train()

    total_loss = 0.0
    correct = 0
    sample_count = 0

    for images, labels in data_loader:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad(
            set_to_none=True
        )

        logits = model(images)

        loss = loss_fn(
            logits,
            labels,
        )

        loss.backward()

        optimizer.step()

        batch_size = labels.size(0)

        total_loss += (
            loss.item() * batch_size
        )

        predictions = logits.argmax(
            dim=1
        )

        correct += (
            predictions == labels
        ).sum().item()

        sample_count += batch_size

    return (
        total_loss / sample_count,
        correct / sample_count,
    )


def evaluate(
    model,
    data_loader,
    loss_fn,
    device,
):
    model.eval()

    total_loss = 0.0
    correct = 0
    sample_count = 0

    with torch.no_grad():
        for images, labels in data_loader:
            images = images.to(device)
            labels = labels.to(device)

            logits = model(images)

            loss = loss_fn(
                logits,
                labels,
            )

            batch_size = labels.size(0)

            total_loss += (
                loss.item() * batch_size
            )

            predictions = logits.argmax(
                dim=1
            )

            correct += (
                predictions == labels
            ).sum().item()

            sample_count += batch_size

    return (
        total_loss / sample_count,
        correct / sample_count,
    )


def predict_sample(
    model,
    dataset,
    index,
    device,
):
    model.eval()

    image, true_label = dataset[index]

    image_batch = image.unsqueeze(0).to(
        device
    )

    with torch.no_grad():
        logits = model(image_batch)

        probabilities = torch.softmax(
            logits,
            dim=1,
        )

        predicted_label = probabilities.argmax(
            dim=1
        ).item()

        confidence = probabilities[
            0,
            predicted_label,
        ].item()

    return {
        "predicted_class": (
            CLASS_NAMES[predicted_label]
        ),
        "true_class": (
            CLASS_NAMES[true_label]
        ),
        "confidence": confidence,
    }


def main():
    set_seed(RANDOM_SEED)

    device = get_device()

    print("Device:", device)

    (
        train_dataset,
        test_dataset,
        train_loader,
        test_loader,
    ) = build_data_loaders()

    print(
        "Train samples:",
        len(train_dataset),
    )

    print(
        "Test samples:",
        len(test_dataset),
    )

    model = FashionClassifier().to(device)

    print(model)

    loss_fn = nn.CrossEntropyLoss()

    optimizer = torch.optim.AdamW(
        model.parameters(),
        lr=LEARNING_RATE,
    )

    for epoch in range(1, EPOCHS + 1):
        train_loss, train_accuracy = (
            train_one_epoch(
                model=model,
                data_loader=train_loader,
                loss_fn=loss_fn,
                optimizer=optimizer,
                device=device,
            )
        )

        test_loss, test_accuracy = evaluate(
            model=model,
            data_loader=test_loader,
            loss_fn=loss_fn,
            device=device,
        )

        print(
            f"Epoch {epoch}/{EPOCHS} | "
            f"Train loss: {train_loss:.4f} | "
            f"Train accuracy: "
            f"{train_accuracy:.2%} | "
            f"Test loss: {test_loss:.4f} | "
            f"Test accuracy: "
            f"{test_accuracy:.2%}"
        )

    torch.save(
        model.state_dict(),
        MODEL_PATH,
    )

    print(
        "Model saved to:",
        MODEL_PATH,
    )

    sample_result = predict_sample(
        model=model,
        dataset=test_dataset,
        index=0,
        device=device,
    )

    print("Sample result:", sample_result)


if __name__ == "__main__":
    main()

پروژه را اجرا کنید:

python main.py

در اولین اجرا FashionMNIST دانلود و آموزش شروع می‌شود.

Epoch چیست؟

هر بار که مدل تمام داده‌های Train را یک‌بار مشاهده کند، یک Epoch کامل شده است.

1 Epoch =
یک بار عبور از کل داده آموزشی

افزایش Epoch ممکن است باعث یادگیری بیشتر شود، اما اگر بیش از حد ادامه یابد، احتمال Overfitting افزایش پیدا می‌کند.

Batch Size چیست؟

Batch Size تعداد نمونه‌هایی است که پیش از هر به‌روزرسانی پارامترها پردازش می‌شوند:

BATCH_SIZE = 64

Batch کوچک‌تر:

• حافظه کمتری مصرف می‌کند.
• تعداد به‌روزرسانی بیشتری دارد.
• ممکن است Gradient پرنوسان‌تر باشد.

Batch بزرگ‌تر:

• حافظه بیشتری نیاز دارد.
• ممکن است از GPU بهتر استفاده کند.
• الزاماً کیفیت بهتری ایجاد نمی‌کند.

Learning Rate چیست؟

Learning Rate اندازه تغییر پارامترها در هر مرحله را کنترل می‌کند:

LEARNING_RATE = 1e-3

مقدار بسیار بزرگ:

• آموزش ناپایدار
• نوسان Loss
• عبور از نقطه مناسب

مقدار بسیار کوچک:

• آموزش کند
• نیاز به Epoch بیشتر
• احتمال توقف در بهبود محدود

Learning Rate یکی از مهم‌ترین Hyperparameterهای آموزش است.

تفاوت Parameter و Hyperparameter

Parameter توسط مدل یاد گرفته می‌شود:

• Weight
• Bias

Hyperparameter پیش از آموزش توسط توسعه‌دهنده تعیین می‌شود:

• Learning Rate
• Batch Size
• تعداد Epoch
• اندازه لایه
• Dropout
• Optimizer

ارزیابی مدل فقط با Accuracy کافی است؟

Accuracy برای شروع مناسب است، اما همیشه کافی نیست.

معیارهای دیگر:

• Precision
• Recall
• F1 Score
• Confusion Matrix
• ROC-AUC
• Top-k Accuracy
• Loss
• Latency
• حجم مدل

برای دیتاست نامتوازن، Accuracy ممکن است تصویر گمراه‌کننده‌ای ارائه کند.

Overfitting چیست؟

Overfitting زمانی رخ می‌دهد که مدل داده Train را خوب یاد می‌گیرد، اما روی داده جدید عملکرد ضعیفی دارد.

نشانه رایج:

• Train Loss کاهش می‌یابد.
• Train Accuracy افزایش می‌یابد.
• Test Loss افزایش می‌یابد.
• Test Accuracy بهبود پیدا نمی‌کند یا کاهش می‌یابد.

راهکارهای احتمالی:

• داده بیشتر
• Data Augmentation
• Dropout
• Weight Decay
• مدل کوچک‌تر
• Early Stopping
• کاهش Epoch
• بهبود تقسیم داده
• Cross-validation

Underfitting چیست؟

Underfitting زمانی رخ می‌دهد که مدل حتی روی داده Train نیز عملکرد مناسبی ندارد.

دلایل احتمالی:

• مدل بیش از حد ساده
• Epoch کم
• Learning Rate نامناسب
• ویژگی‌های ضعیف
• داده نامناسب
• خطا در Preprocessing
• Loss نامناسب

ذخیره مدل PyTorch

روش رایج ذخیره وزن‌ها:

torch.save(
    model.state_dict(),
    "fashion_model.pth",
)

state_dict شامل پارامترهای قابل آموزش و Bufferهای مدل است.

بر اساس راهنمای رسمی ذخیره و بارگذاری مدل، ذخیره State Dictionary یکی از روش‌های اصلی و پیشنهادی برای نگهداری وزن‌های مدل است.

بارگذاری مدل

برای بارگذاری، ابتدا همان معماری را ایجاد کنید:

import torch

model = FashionClassifier()

state_dict = torch.load(
    "fashion_model.pth",
    map_location="cpu",
    weights_only=True,
)

model.load_state_dict(
    state_dict
)

model.eval()

معماری مدل باید با معماری زمان ذخیره سازگار باشد.

تنها داشتن فایل وزن کافی نیست؛ باید کد تعریف مدل، ترتیب لایه‌ها و تعداد خروجی‌ها نیز مشخص باشد.

ذخیره Checkpoint کامل

اگر می‌خواهید آموزش را بعداً ادامه دهید، علاوه بر وزن مدل، وضعیت Optimizer و Epoch را ذخیره کنید:

checkpoint = {
    "epoch": current_epoch,
    "model_state_dict": (
        model.state_dict()
    ),
    "optimizer_state_dict": (
        optimizer.state_dict()
    ),
    "train_loss": train_loss,
}

torch.save(
    checkpoint,
    "checkpoint.pth",
)

بارگذاری:

checkpoint = torch.load(
    "checkpoint.pth",
    map_location=device,
    weights_only=True,
)

model.load_state_dict(
    checkpoint["model_state_dict"]
)

optimizer.load_state_dict(
    checkpoint[
        "optimizer_state_dict"
    ]
)

start_epoch = (
    checkpoint["epoch"] + 1
)

پس از انتقال مدل به Device، ممکن است لازم باشد وضعیت Tensorهای Optimizer را نیز متناسب با Device بررسی کنید.

انجام پیش‌بینی روی یک نمونه

model.eval()

image, actual_label = test_dataset[0]

input_batch = image.unsqueeze(0).to(
    device
)

with torch.no_grad():
    logits = model(input_batch)

    probabilities = torch.softmax(
        logits,
        dim=1,
    )

    predicted_label = probabilities.argmax(
        dim=1
    ).item()

    confidence = probabilities[
        0,
        predicted_label,
    ].item()

print(
    "Prediction:",
    CLASS_NAMES[predicted_label],
)

print(
    "Actual:",
    CLASS_NAMES[actual_label],
)

print(
    "Confidence:",
    round(confidence, 4),
)

Confidence بالا به‌تنهایی تضمین نمی‌کند پیش‌بینی درست باشد. شبکه عصبی ممکن است با اطمینان زیاد نیز اشتباه کند.

انتقال Tensor از GPU به CPU

برای تبدیل خروجی GPU به NumPy:

numpy_array = (
    tensor
    .detach()
    .cpu()
    .numpy()
)

مراحل:

• detach: جداکردن از Graph
• cpu: انتقال به CPU
• numpy: تبدیل به آرایه NumPy

خطاهای رایج PyTorch

خطای Tensor روی Deviceهای متفاوت

نمونه خطا:

Expected all tensors to be on the same device

راه‌حل:

model = model.to(device)
images = images.to(device)
labels = labels.to(device)

خطای Shape

نمونه:

mat1 and mat2 shapes cannot be multiplied

ابعاد خروجی لایه قبلی و ورودی لایه Linear را بررسی کنید.

برای مشاهده Shape:

print(x.shape)

خطای نوع داده

برای CrossEntropyLoss برچسب‌ها باید معمولاً Long باشند:

labels = labels.long()

ورودی مدل نیز معمولاً Float است:

images = images.float()

خطای CUDA out of memory

راهکارهای اولیه:

• کاهش Batch Size
• انتخاب مدل کوچک‌تر
• کاهش اندازه تصویر
• بستن فرایندهای دیگر GPU
• استفاده از Mixed Precision در پروژه سازگار
• اجرای مدل روی CPU
• استفاده از API به‌جای اجرای مدل سنگین محلی

Loss به NaN تبدیل می‌شود

علل احتمالی:

• Learning Rate زیاد
• داده دارای NaN یا Infinity
• عملیات عددی ناپایدار
• Gradient بسیار بزرگ
• نرمال‌سازی نامناسب
• Loss نامناسب

بررسی داده:

print(
    torch.isnan(images).any()
)

print(
    torch.isinf(images).any()
)

دقت مدل تغییر نمی‌کند

بررسی کنید:

• loss.backward() اجرا می‌شود.
• optimizer.step() وجود دارد.
• Gradient بدون دلیل غیرفعال نشده است.
• برچسب‌ها صحیح هستند.
• مدل در حالت Train قرار دارد.
• Learning Rate مناسب است.
• خروجی مدل با Loss سازگار است.
• داده Shuffle می‌شود.

مدل را از ابتدا آموزش دهیم یا از مدل آماده استفاده کنیم؟

آموزش از ابتدا همیشه بهترین راه نیست.

آموزش از ابتدا مناسب است اگر:

• داده اختصاصی و کافی دارید.
• معماری خاصی نیاز دارید.
• وظیفه بسیار تخصصی است.
• سخت‌افزار و زمان کافی دارید.
• تیم یادگیری ماشین دارید.
• هدف پژوهش یا توسعه مدل است.

مدل آماده مناسب است اگر:

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

Fine-tuning مناسب است اگر:

• مدل پایه مناسب است.
• رفتار تخصصی‌تری می‌خواهید.
• داده برچسب‌خورده محدود اما مناسب دارید.
• آموزش کامل مدل هزینه زیادی دارد.

چه زمانی از API درواره استفاده کنیم؟

PyTorch برای ساخت و آموزش مدل است. اما بسیاری از کسب‌وکارها قصد ساخت مدل از صفر ندارند؛ آن‌ها می‌خواهند قابلیت هوش مصنوعی را به نرم‌افزار خود اضافه کنند.

در این شرایط API مناسب‌تر است:

• ساخت چت‌بات
• خلاصه‌سازی متن
• تولید محتوا
• تحلیل تصویر
• تولید کد
• استخراج اطلاعات
• ساخت Agent
• ترجمه
• پردازش صوت
• تولید تصویر یا ویدئو

با API درواره می‌توانید بدون دانلود وزن‌های بزرگ، نصب Driver یا مدیریت سرور GPU به مدل‌های مختلف دسترسی داشته باشید.

نمونه استفاده از API درواره با پایتون

نصب کتابخانه‌ها:

pip install openai python-dotenv

فایل .env:

DARVAREH_API_KEY=YOUR_DARVAREH_API_KEY
DARVAREH_MODEL_ID=YOUR_MODEL_ID

نمونه کد:

import os

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

api_key = os.getenv(
    "DARVAREH_API_KEY"
)

model_id = os.getenv(
    "DARVAREH_MODEL_ID"
)

if not api_key:
    raise RuntimeError(
        "DARVAREH_API_KEY تنظیم نشده است."
    )

if not model_id:
    raise RuntimeError(
        "DARVAREH_MODEL_ID تنظیم نشده است."
    )

client = OpenAI(
    api_key=api_key,
    base_url="https://api.darvareh.ir/v1",
)

response = client.chat.completions.create(
    model=model_id,
    messages=[
        {
            "role": "system",
            "content": (
                "شما یک دستیار فارسی دقیق هستید."
            ),
        },
        {
            "role": "user",
            "content": (
                "یک مسیر یادگیری PyTorch "
                "برای برنامه‌نویس پایتون پیشنهاد بده."
            ),
        },
    ],
    temperature=0.2,
    max_tokens=800,
)

print(
    response
    .choices[0]
    .message
    .content
)

Model ID و قیمت مدل‌ها را از صفحه مدل‌های درواره دریافت کنید.

مقایسه PyTorch و API هوش مصنوعی

در بسیاری از پروژه‌ها می‌توان هر دو را ترکیب کرد:

• مدل کوچک اختصاصی با PyTorch
• مدل زبانی بزرگ از طریق API
• طبقه‌بندی اولیه به‌صورت محلی
• تولید پاسخ نهایی با درواره
• مدل تشخیص داخلی در کنار مدل‌های عمومی API

مسیر یادگیری پیشنهادی PyTorch

مرحله اول: پایتون و ریاضی پایه

• Python
• NumPy
• جبر خطی مقدماتی
• مشتق
• احتمال و آمار مقدماتی

مرحله دوم: Tensor و Autograd

• Shape
• dtype
• Device
• Broadcasting
• Matrix Multiplication
• Gradient
• Graph محاسباتی

مرحله سوم: شبکه عصبی

• Linear Layer
• Activation
• Loss
• Optimizer
• Forward Pass
• Backward Pass

مرحله چهارم: داده

• Dataset
• DataLoader
• Transform
• Train، Validation و Test
• Batch
• Shuffle

مرحله پنجم: مدل‌های تصویری

• CNN
• Convolution
• Pooling
• Data Augmentation
• Transfer Learning

مرحله ششم: پردازش متن

• Tokenization
• Embedding
• Sequence Model
• Attention
• Transformer

مرحله هفتم: پروژه عملی

• انتخاب مسئله
• آماده‌سازی داده
• تعریف Baseline
• آموزش
• ارزیابی
• ذخیره مدل
• ساخت API یا رابط کاربری

چک‌لیست آموزش مدل

• داده Train و Test جدا هستند.
• داده Test در آموزش استفاده نمی‌شود.
• Seed تنظیم شده است.
• Shape داده بررسی شده است.
• dtype صحیح است.
• مدل و داده روی Device یکسان هستند.
• model.train() قبل از آموزش اجرا می‌شود.
• Gradient در هر Batch صفر می‌شود.
• loss.backward() اجرا می‌شود.
• Optimizer پارامترها را به‌روزرسانی می‌کند.
• model.eval() قبل از ارزیابی اجرا می‌شود.
• ارزیابی داخل torch.no_grad() انجام می‌شود.
• معیارهای Train و Test ثبت می‌شوند.
• بهترین Checkpoint نگهداری می‌شود.
• مدل روی داده واقعی آزمایش می‌شود.
• محدودیت‌های مدل ثبت می‌شوند.

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

PyTorch چیست؟

PyTorch یک فریم‌ورک متن‌باز یادگیری ماشین برای کار با Tensor، ساخت شبکه عصبی، محاسبه Gradient، آموزش مدل و اجرای Inference است.

آیا PyTorch برای مبتدیان مناسب است؟

اگر با پایتون و مفاهیم پایه برنامه‌نویسی آشنا باشید، PyTorch مسیر مناسبی برای یادگیری عملی شبکه‌های عصبی است. یادگیری ریاضی پایه نیز در درک بهتر مدل‌ها کمک می‌کند.

آیا برای PyTorch به GPU نیاز داریم؟

خیر. مثال‌ها و مدل‌های کوچک روی CPU اجرا می‌شوند. GPU برای آموزش مدل‌های بزرگ‌تر یا افزایش سرعت مفید است.

CUDA چیست؟

CUDA پلتفرم محاسباتی مورد استفاده برای اجرای بسیاری از عملیات PyTorch روی GPUهای سازگار انویدیا است.

Tensor چیست؟

Tensor آرایه‌ای چندبعدی و ساختار اصلی داده در PyTorch است که می‌تواند روی CPU یا GPU اجرا شود و Gradient را نگه دارد.

Autograd چیست؟

Autograd سیستم محاسبه خودکار مشتق و Gradient در PyTorch است. این سیستم امکان اجرای Backpropagation را فراهم می‌کند.

تفاوت Dataset و DataLoader چیست؟

Dataset نحوه دسترسی به نمونه‌ها را تعریف می‌کند. DataLoader نمونه‌ها را به Batch تبدیل، مرتب یا Shuffle و برای حلقه آموزش آماده می‌کند.

چرا از model.eval استفاده می‌کنیم؟

این دستور لایه‌هایی مانند Dropout و Batch Normalization را وارد حالت ارزیابی می‌کند. بدون آن ممکن است نتیجه Inference با رفتار آموزش تولید شود.

چرا از torch.no_grad استفاده می‌کنیم؟

در ارزیابی و Inference نیازی به محاسبه Gradient نیست. torch.no_grad() مصرف حافظه و سربار محاسباتی مربوط به Gradient را کاهش می‌دهد.

فایل pth چیست؟

پسوند .pth یا .pt معمولاً برای ذخیره وزن‌ها، State Dictionary یا Checkpointهای PyTorch استفاده می‌شود.

PyTorch بهتر است یا API هوش مصنوعی؟

برای ساخت، آموزش و کنترل مستقیم مدل، PyTorch مناسب است. برای استفاده سریع از مدل‌های آماده بدون مدیریت GPU و زیرساخت، API هوش مصنوعی انتخاب ساده‌تری است.

آیا می‌توان مدل PyTorch را به API تبدیل کرد؟

بله. می‌توانید مدل را در یک Backend مانند FastAPI بارگذاری و Endpoint پیش‌بینی ایجاد کنید. برای ترافیک واقعی باید هم‌زمانی، Batch، صف، Timeout، مانیتورینگ و منابع سخت‌افزاری را نیز مدیریت کنید.

جمع‌بندی

PyTorch یکی از مهم‌ترین ابزارهای توسعه یادگیری ماشین و یادگیری عمیق است. این فریم‌ورک با فراهم‌کردن Tensor، Autograd، لایه‌های شبکه عصبی، Optimizer، Dataset و DataLoader، تمام اجزای اصلی آموزش یک مدل را در اختیار توسعه‌دهنده قرار می‌دهد.

در این مقاله یاد گرفتیم:

• PyTorch چیست.
• Tensor چگونه ساخته و پردازش می‌شود.
• مدل و داده چگونه به GPU منتقل می‌شوند.
• Autograd چگونه Gradient را محاسبه می‌کند.
• Dataset و DataLoader چگونه کار می‌کنند.
• شبکه عصبی با nn.Module چگونه ساخته می‌شود.
• Loss و Optimizer چه نقشی دارند.
• Training Loop و Evaluation Loop چگونه پیاده‌سازی می‌شوند.
• مدل FashionMNIST چگونه آموزش داده می‌شود.
• وزن مدل چگونه ذخیره و بارگذاری می‌شود.
• چه زمانی PyTorch و چه زمانی API مناسب‌تر است.

اگر هدفتان یادگیری ساختار داخلی مدل، توسعه شبکه عصبی یا آموزش مدل اختصاصی است، PyTorch ابزار ارزشمندی خواهد بود. اگر هدف اصلی شما افزودن سریع قابلیت هوش مصنوعی به سایت، اپلیکیشن یا محصول است، استفاده از مدل‌های آماده از طریق API می‌تواند مسیر کوتاه‌تری باشد.

برای استفاده از مدل‌های هوش مصنوعی بدون مدیریت مستقیم زیرساخت GPU، در درواره ثبت‌نام کنید، یک API Key بسازید و مدل مناسب پروژه را از صفحه مدل‌ها انتخاب کنید.

مقالات مرتبط

• Hugging Face چیست؟ آموزش Transformers و اجرای مدل با پایتون
• آموزش هوش مصنوعی با پایتون و ساخت پروژه واقعی
• Fine-Tuning چیست؟ آموزش LoRA و QLoRA
• راهنمای کامل مدل‌های هوش مصنوعی
• Inference چیست؟ راهنمای اجرای مدل هوش مصنوعی
• Embedding چیست و چه کاربردی دارد؟
• آموزش دریافت API هوش مصنوعی و ساخت API Key
• API هوش مصنوعی چیست؟

برای مطالعه شرایط استفاده و محدودیت‌های مسئولیت، صفحه «سلب مسئولیت» را مشاهده کنید.