Phase 03: Deep Learning Core

PyTorch'a Giriş

Type: Build

Languages: Python

Prerequisites: Lesson 03.10 (Build Your Own Mini Framework)

Time: ~75 minutes

Öğrenme Hedefleri

• PyTorch'ın nn.Module, nn.Sequential ve autograd kullanarak sinir ağlarını oluşturun ve eğitiniz
• PyTorch tensörleri, GPU hızlandırması ve standart eğitim döngüsünü kullanın (zero_grad, ileri, kayb, geri, adım)
• Yeriye mini çerçeve bileşenlerini PyTorch eşdeğerlerine dönüştürün
• Profil ve aynı görev için saf Python çerçevesiniz ve PyTorch arasındaki eğitim hızı karşılaştırın

Sorun

İşleyen mini çerçeve var. Düz katman, ReLU, çıkış, seri norm, Adam, bir DataLoader, bir eğitim döngüsü. Temiz Python'da bir döngü sınıflandırma sorunu üzerinde 4 katmanlı bir ağı eğitir.

Aynı sorunda PyTorch'tan 500 kat daha yavaş.

Mini çerçevenin bir anda bir örnekle bir örneği, örümlü Python döngüleri ile işliyor. PyTorch aynı işlemleri GPU'da çalışan optimize edilmiş C++/CUDA çekirdeklerine gönderir. Tek bir NVIDIA A100'de PyTorch, ResNet-50'i (parametri 25,6M) ImageNet'de (1.28M görüntü) yaklaşık 6 saatte eğitir.

Hız tek boşluk değildir. Çerçevenin GPU desteği yok. Otomatik farklılık yok - her modül için el yazmışsınız.

PyTorch bu boşlukların her birini dolduruyor. ve bunu zaten inşa ettiğiniz aynı zihinsel modelde tutarak yapar: Modül, ileri(), parametreler(), geriye(), optimizer.step(). Anlaşmalar birbiri aktarılır. Sintaks neredeyse aynıdır. Fark şu ki PyTorch, sıfırdan tasarladığınız aynı arayüzün arkasında bir on yıllık sistem mühendisliği kapsıyor.

Anlaşım

PyTorch Neden Kazandı

TensorFlow'un 2015 yılında bir şey çalıştırmadan önce statik bir hesaplama grafiği tanımlamanızı istedi. Grafi oluşturdu, birleştirdi, sonra da veriyi içeri soktu. Debugging, grafik görselleştirmelerine bakmak anlamına geliyordu. Arsitekturayı değiştirmek, grafi sıfırdan yeniden inşa etmek anlamına geliyordu.

PyTorch 2017'de farklı bir felsefe ile başlatıldı: hevesli bir şekilde yürütülür. Python yazıyorsunuz. Hemen çalışır.y = model(x)Aslında şimdi y'yi hesaplıyor, "y'yi daha sonra hesaplayacak bir grafikte bir düğüm ekleme" değil. Bu, standart Python debugging araçları çalıştı demek. print() çalıştı. pdb çalıştı. if/else in your forward pass worked.

Piytorch'un ML araştırma makalelerinde payı %7 (2017)'den %75'e (2022) yükseldi. Meta, Google DeepMind, OpenAI, Anthropic ve Hugging Face hepsi PyTorch'i ana çerçevesini kullanıyor. TensorFlow 2.x, PyTorch'un tasarımının doğru olduğunu sessiz kabul ederek, buna karşılık hevesli bir yürütme uyguladı.

Ders: Geliştiricilerin deneyimleri bileşikler. Her seferinde debug etmek için %10 daha yavaş ama %50 daha hızlı bir çerçeve kazanır.

Tansörler

Tensor, üç kritik özelliği olan çok boyutlu bir dizi: şekil, dtype ve cihaz.

pythonCopyimport torch

x = torch.zeros(3, 4)           # shape: (3, 4), dtype: float32, device: cpu
x = torch.randn(2, 3, 224, 224) # batch of 2 RGB images, 224x224
x = torch.tensor([1, 2, 3])     # from a Python list

ShapeBir skalar şekil (), bir vektör (n), bir matris (m, n), bir görüntü parti (batch, kanallar, yüksekliği, genişliği).

DtypeDüzgünliği ve hafıza kontrolü.

Devicehesaplamaların nerede olduğunu belirler.

pythonCopydevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(3, 4, device=device)
x = x.to("cuda")
x = x.cpu()

Her işlem aynı cihaza tüm tenzorları gerektirir.RuntimeError: Expected all tensors to be on the same deviceHesaplama öncesi her şeyi aynı cihaze taşıyarak düzelt.

Reshapingsürekli zaman -- metadataları değiştirir, verileri değil.

pythonCopyx = torch.randn(2, 3, 4)
x.view(2, 12)      # reshape to (2, 12) -- must be contiguous
x.reshape(6, 4)    # reshape to (6, 4) -- works always
x.permute(2, 0, 1) # reorder dimensions
x.unsqueeze(0)     # add dimension: (1, 2, 3, 4)
x.squeeze()        # remove size-1 dimensions

Autograd

PyTorch, tüm tensörler üzerinde yapılan her işlemini yönlendirilmiş bir asiklik grafiğe (sayım grafiği) kaydeder ve sonra bu grafiği tersine geçerek otomatik olarak gradiyenti hesaplar.

graph LR
    x["x (leaf)"] --> mul["*"]
    w["w (leaf, requires_grad)"] --> mul
    mul --> add["+"]
    b["b (leaf, requires_grad)"] --> add
    add --> loss["loss"]
    loss --> |".backward()"| add
    add --> |"grad"| b
    add --> |"grad"| mul
    mul --> |"grad"| w

PyTorch, kaset tabanlı otomatik kaydetmeyi kullanır. Her işlem ileri geçiş sırasında bir "kasete" eklenir..backward()Kaseti tersine çevirir.

pythonCopyx = torch.randn(3, requires_grad=True)
y = x ** 2 + 3 * x
z = y.sum()
z.backward()
print(x.grad)  # dz/dx = 2x + 3

Autograd'ın üç kuralı:

1. Sadece ile yaprak tenzorlarırequires_grad=Truetoplanan gradientler
2. Gradyentler varsayılan olarak biriktirir -- çağrı optimizer.zero_grad()Her geriye geçmeden önce
3. torch.no_grad()gradient izlemesini engelleyebilir (değerlendirme sırasında kullanılır)

nn.Modular

nn.ModulePyTorch'in versiyonu, otomatik parametre kayıt, rekürsiv modül keşfi, cihaz yönetimi ve durum dikt serileştirimi ekler.

pythonCopyimport torch.nn as nn

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

Bir görev verdiğindenn.Moduleveya nn.Parameter__init__PyTorch otomatik olarak kaydediyor.model.parameters()Bu yüzden mini çerçeve gibi ağırlıkları asla elden toplamak zorunda değilsiniz.

Ana yapı taşları:

Kayıp İşlevler ve Optimizerler

PyTorch, sizin inşa ettiğiniz her şeyin üretime hazır versiyonlarını gönderir.

Loss functions(dan torch.nn):

Not: CrossEntropyLossbirleşik LogSoftmax+ NLLLossBu, sessizce yanlış gradient üreten yaygın bir hata.

Optimizers(dan torch.optim):

Eğitim Çelişkisi

Her PyTorch eğitim döngüsü aynı 5 adımlı bir kalıp izler.

sequenceDiagram
    participant D as DataLoader
    participant M as Model
    participant L as Loss fn
    participant O as Optimizer

    loop Each Epoch
        D->>M: batch = next(dataloader)
        M->>L: predictions = model(batch)
        L->>L: loss = criterion(predictions, targets)
        L->>M: loss.backward()
        O->>M: optimizer.step()
        O->>O: optimizer.zero_grad()
    end

Kanonik örneği:

pythonCopyfor epoch in range(num_epochs):
    model.train()
    for inputs, targets in train_loader:
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

Bu, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir dizi metin, bir bir bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin, bir metin,

Veri kümesi ve DataLoader

PyTorch'in Datasetiki yöntemle bir soyut sınıf: __len__ve __getitem__- Evet .DataLoaderserileme, karıştırma ve çok işlemli veri yükleme ile sarılır.

pythonCopyfrom torch.utils.data import Dataset, DataLoader

class MNISTDataset(Dataset):
    def __init__(self, images, labels):
        self.images = images
        self.labels = labels

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

    def __getitem__(self, idx):
        return self.images[idx], self.labels[idx]

loader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=4)

num_workers=4GPU, mevcut partide çalışarak verileri paralel olarak yüklemek için 4 işlem oluşturur. Disk bağlı iş yüklerinde (büyük görüntüler, ses), bu tek başına eğitim hızı ikiye katlayabilir.

GPU Eğitim

Bir modelin GPU'ya geçmesi:

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

Bu, her parametreyi ve tamponu GPU'ya geri dönüşlü olarak taşıyor.

pythonCopyinputs, targets = inputs.to(device), targets.to(device)

Mixed precisionmodern GPU'larda (A100, H100, RTX 4090) hafıza kullanımını ikiye katlayarak ve ana ağırlıkları float32'de tutarken float16'da ileri/geri yürüterek geçiş hızını ikiye katlayarak:

pythonCopyfrom torch.amp import autocast, GradScaler

scaler = GradScaler()
for inputs, targets in loader:
    with autocast(device_type="cuda"):
        outputs = model(inputs)
        loss = criterion(outputs, targets)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
    optimizer.zero_grad()

Karşılaştırma: Mini Framework vs PyTorch vs JAX

Yapın

MNIST'te eğitimli 3 katlı bir MLP, sadece PyTorch primitiflerini kullanıyor.torchvision.datasetsHâlâ kendiliğimizden veriyi indiririz ve analiz ediyoruz.

Adım 1: Çöm Dosyalardan MNIST yükle

MNIST 4 gzip dosya olarak gönderir: eğitim görüntüleri (60.000 x 28 x 28), eğitim etiketleri, test görüntüleri (10.000 x 28 x 28), test etiketleri.

pythonCopyimport torch
import torch.nn as nn
import struct
import gzip
import urllib.request
import os

def download_mnist(path="./mnist_data"):
    base_url = "https://storage.googleapis.com/cvdf-datasets/mnist/"
    files = [
        "train-images-idx3-ubyte.gz",
        "train-labels-idx1-ubyte.gz",
        "t10k-images-idx3-ubyte.gz",
        "t10k-labels-idx1-ubyte.gz",
    ]
    os.makedirs(path, exist_ok=True)
    for f in files:
        filepath = os.path.join(path, f)
        if not os.path.exists(filepath):
            urllib.request.urlretrieve(base_url + f, filepath)

def load_images(filepath):
    with gzip.open(filepath, "rb") as f:
        magic, num, rows, cols = struct.unpack(">IIII", f.read(16))
        data = f.read()
        images = torch.frombuffer(bytearray(data), dtype=torch.uint8)
        images = images.reshape(num, rows * cols).float() / 255.0
    return images

def load_labels(filepath):
    with gzip.open(filepath, "rb") as f:
        magic, num = struct.unpack(">II", f.read(8))
        data = f.read()
        labels = torch.frombuffer(bytearray(data), dtype=torch.uint8).long()
    return labels

İkinci Adım: Örnekleri tanımlayın

Üç katlı MLP: 784 -> 256 -> 128 -> 10. ReLU etkinleştirmeleri. Düzenlenmesi için bırak.

pythonCopyclass MNISTModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 10),
        )

    def forward(self, x):
        return self.net(x)

Çıktı katman 10 çiğ logit (her rakamda bir) üretir.CrossEntropyLossBunu içsel olarak ele alıyor.

Parametre sayısı: 784256 + 256 + 256128 + 128 + 128*10 + 10 = 235.146.

Üçüncü Adım: Eğitim Çubuğu

Kanonik ileri-kayıp-geri adım örneği.

pythonCopydef train_one_epoch(model, loader, criterion, optimizer, device):
    model.train()
    total_loss = 0
    correct = 0
    total = 0
    for images, labels in loader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * images.size(0)
        _, predicted = outputs.max(1)
        correct += predicted.eq(labels).sum().item()
        total += labels.size(0)
    return total_loss / total, correct / total


def evaluate(model, loader, criterion, device):
    model.eval()
    total_loss = 0
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            loss = criterion(outputs, labels)
            total_loss += loss.item() * images.size(0)
            _, predicted = outputs.max(1)
            correct += predicted.eq(labels).sum().item()
            total += labels.size(0)
    return total_loss / total, correct / total

Not:torch.no_grad()Bu, otomatik derecelendirmeyi devre dışı bırakır, hafıza kullanımını azaltır ve sonuçları hızlandırır.

Dördüncü Adım: Her şeyi bir arada bağlayın

pythonCopydef main():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    download_mnist()
    train_images = load_images("./mnist_data/train-images-idx3-ubyte.gz")
    train_labels = load_labels("./mnist_data/train-labels-idx1-ubyte.gz")
    test_images = load_images("./mnist_data/t10k-images-idx3-ubyte.gz")
    test_labels = load_labels("./mnist_data/t10k-labels-idx1-ubyte.gz")

    train_dataset = torch.utils.data.TensorDataset(train_images, train_labels)
    test_dataset = torch.utils.data.TensorDataset(test_images, test_labels)
    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=64, shuffle=True
    )
    test_loader = torch.utils.data.DataLoader(
        test_dataset, batch_size=256, shuffle=False
    )

    model = MNISTModel().to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

    num_params = sum(p.numel() for p in model.parameters())
    print(f"Device: {device}")
    print(f"Parameters: {num_params:,}")
    print(f"Train samples: {len(train_dataset):,}")
    print(f"Test samples: {len(test_dataset):,}")
    print()

    for epoch in range(10):
        train_loss, train_acc = train_one_epoch(
            model, train_loader, criterion, optimizer, device
        )
        test_loss, test_acc = evaluate(
            model, test_loader, criterion, device
        )
        print(
            f"Epoch {epoch+1:2d} | "
            f"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f} | "
            f"Test Loss: {test_loss:.4f} | Test Acc: {test_acc:.4f}"
        )

    torch.save(model.state_dict(), "mnist_mlp.pt")
    print(f"\nModel saved to mnist_mlp.pt")
    print(f"Final test accuracy: {test_acc:.4f}")

10 dönemden sonra beklenen çıkış: ~97.8% test doğruluğu. CPU'da eğitim süresi: ~30 saniye. GPU'da: ~5 saniye. Aynı mimari olan mini çerçeve üzerinde: ~45 dakika.

Kullan

Hızlı karşılaştırma: Mini Framework vs PyTorch

Ara yüzü neredeyse aynı, farkı kapının altındaki her şey.

Kaydetme ve yükleme modelleri

pythonCopytorch.save(model.state_dict(), "model.pt")

model = MNISTModel()
model.load_state_dict(torch.load("model.pt", weights_only=True))
model.eval()

Her zaman sakla .state_dict()Bu, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir parçası olarak, bir sistemin bir diğerine, bir sistemin bir parçası olarak, bir sistemin bir diğerine, bir sistemin bir diğerine, bir diğerine, bir diğerinin, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, bir diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine, diğerine de, diğerine, diğerine de, diğerine, diğerine de, diğerine, diğerine, diğerine, diğerine de, diğerine, diğerine de, diğerine de, diğerine, diğerine de, diğerine, diğerine, diğerine de

Öğrenme Tarifi Planlama

pythonCopyscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer, T_max=10
)
for epoch in range(10):
    train_one_epoch(model, train_loader, criterion, optimizer, device)
    scheduler.step()

PyTorch 15+ programcı gönderir: StepLR, ExponentialLR, CosineAnnealingLR, OneCycleLR, ReduceLROnPlateau. Hepsi aynı optimizer arayüzüne bağlanır.

Gönder

Bu ders iki eser üretir:

• outputs/prompt-pytorch-debugger.md-- PyTorch eğitiminde yaygın hataların teşhis edilmesi için bir uyarı
• outputs/skill-pytorch-patterns.md-- PyTorch eğitim modelleri için bir beceri referansı

Egzersizler

1. Add batch normalization.Ekle nn.BatchNorm1dHer doğrusal katmanın ardından (aktivasyondan önce). Test doğruluğu ve eğitim hızı ile sadece bırakma sürümünün karşılaştırın.

1. Implement a learning rate finder.Bir dönem boyunca, öğrenme oranının (1e-7'den 1.0) eksponansal olarak artması ile eğitim verin.

1. Port to GPU with mixed precision.Ekletorch.amp.autocastve GradScalerA100'de, ~2x hızlanma bekleyin.

1. Build a custom Dataset.Moda-MNIST'i (MNIST ile aynı biçimde ancak giyim eşyalarıyla) indir.FashionMNISTDataset(Dataset)sınıfı __getitem__ve __len__Aynı MLP'yi çalıştırıp doğruluğu karşılaştır. Fashion-MNIST daha zor -- %88 vs. %98 bekleyin.

1. Replace Adam with SGD + momentum.Tren ile SGD(params, lr=0.01, momentum=0.9)-Könbürgenlik eğrilerini karşılaştırın.CosineAnnealingLRBir programlama yapıp SGD'nin 10'a kadar Adam'ı yakaladığını gör.

Anahtar Terimler

Daha Fazla Okumak

• Paszke et al., "PyTorch: Bir İmperatif Stylo, Yüksek Performanslı Derin Öğrenme Kütüphanesi" (2019) -- PyTorch'in tasarım anlaşmaları açıklayan orijinal makale
• PyTorch Tutorial: "PyTorch'i Örneklerle Öğrenmek" (https://pytorch.org/tutorials/beginner/pytorch_with_examples.html) -- tenzorlardan nn.Module'ye resmi yol
• PyTorch Performance Tuning Guide (https://pytorch.org/tutorials/recipes/recipes/tuning_guide.html) -- karışık hassasiyet, DataLoader çalışanları, sabit hafıza ve diğer üretim optimizasyonları
• Horace He, "Deep Learning Go Brrrr" (Dünyöğrenmeyi Dönüştürmek)https://horace.io/brrr_intro.html) -- neden GPU eğitimi hızlı, PyTorch spesifik optimizasyon stratejileri ile

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.