Python İle Pytorch Kütüphanesi Kullanarak Derin Öğrenme Modeli Nasıl Yapılır?

Gereksinimler ve Ön Hazırlık

Pytorch ile çalışmaya başlamadan önce geliştirme ortamınızın doğru yapılandırıldığından emin olmalısınız. Modern bir Python ortamında, kütüphanelerin çakışmaması için mutlaka sanal ortam (virtual environment) kullanmanızı öneririm.

Gereksinimler şunlardır:

• Python 3.10 veya üzeri bir sürüm.
• Pytorch (torch) ve torchvision kütüphaneleri.
• NumPy ve Matplotlib (veri işleme ve görselleştirme için).
• CUDA destekli bir GPU (isteğe bağlı ancak eğitim süresini kısaltmak için önerilir).

# Sanal ortam oluşturma ve kütüphaneleri kurma
python -m venv derin_ogrenme_env
source derin_ogrenme_env/bin/activate  # Windows için: derin_ogrenme_env\Scripts\activate
pip install torch torchvision numpy matplotlib

Kurulum tamamlandıktan sonra, import torch komutu ile kütüphanenin yüklendiğini doğrulayabilirsiniz. Eğer GPU desteğiniz varsa, torch.cuda.is_available() fonksiyonu ile donanım hızlandırmanın aktif olup olmadığını kontrol etmeniz önemlidir.

Veri Setini Hazırlama ve Yükleme

Derin öğrenme modelleri kaliteli veriye ihtiyaç duyar. Pytorch içerisinde bulunan Dataset ve DataLoader sınıfları, verileri modele beslemek için en verimli yöntemdir. Bu sınıflar, verinin belleği yormadan "batch" (yığın) halinde işlenmesini sağlar.

import torch
from torch.utils.data import DataLoader, TensorDataset

# Örnek veri oluşturma (100 örnek, 10 özellik)
X = torch.randn(100, 10)
y = torch.randint(0, 2, (100,)).float()

# Veri seti ve yükleyici
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)

Burada TensorDataset ile verilerimizi Pytorch'un anlayacağı tensör formatına çevirdik. DataLoader ise veriyi 10'arlı gruplar halinde karıştırarak (shuffle) modele sunmamızı sağlar. Bu sayede modelin veriyi ezberlemesini (overfitting) engelleriz.

Sinir Ağı Mimarisi Tasarlama

Pytorch'ta bir model oluşturmak için nn.Module sınıfından kalıtım alan bir sınıf tanımlanır. Bu sınıf içerisinde katmanları (layers) tanımlar ve verinin bu katmanlardan nasıl geçeceğini belirleyen forward metodunu yazarız.

import torch.nn as nn

class BasitModel(nn.Module):
    def __init__(self):
        super(BasitModel, self).__init__()
        self.katman1 = nn.Linear(10, 32) # Giriş 10, Çıkış 32
        self.relu = nn.ReLU()            # Aktivasyon fonksiyonu
        self.katman2 = nn.Linear(32, 1)  # Çıkış katmanı

    def forward(self, x):
        x = self.katman1(x)
        x = self.relu(x)
        x = self.katman2(x)
        return torch.sigmoid(x)

model = BasitModel()

nn.Linear katmanı, ağırlıklar ve sapma (bias) değerlerini içeren tam bağlantılı bir katmandır. ReLU ise modelin doğrusal olmayan karmaşık ilişkileri öğrenmesini sağlayan temel bir aktivasyon fonksiyonudur.

Kayıp Fonksiyonu ve Optimize Edici Seçimi

Modelin ne kadar hata yaptığını ölçmek için bir kayıp fonksiyonu (loss function), bu hatayı düzeltmek için ise bir optimize edici (optimizer) gerekir. Sınıflandırma problemleri için genellikle BCELoss veya CrossEntropyLoss tercih edilir.

import torch.optim as optim

criterion = nn.BCELoss() # Binary Cross Entropy
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam optimizasyon algoritması

Adam, öğrenme oranını (learning rate) otomatik ayarlayan oldukça popüler ve kararlı bir optimize edicidir. lr=0.001 değeri, modelin ağırlıklarını ne kadar büyük adımlarla güncelleyeceğini belirler.

Modeli Eğitme Süreci

Eğitim döngüsü, verinin modelden geçirilmesi, hatanın hesaplanması ve ağırlıkların güncellenmesi aşamalarından oluşur. Bu süreç "epoch" adı verilen döngülerle tekrarlanır.

for epoch in range(20): # 20 tur eğitim
    for batch_X, batch_y in dataloader:
        optimizer.zero_grad()      # Önceki gradyanları temizle
        outputs = model(batch_X)   # Tahmin yap
        loss = criterion(outputs.squeeze(), batch_y) # Hatayı hesapla
        loss.backward()            # Geri yayılım (Backpropagation)
        optimizer.step()           # Ağırlıkları güncelle
    print(f"Epoch {epoch+1}, Kayıp: {loss.item():.4f}")

optimizer.zero_grad() komutu hayati önem taşır; çünkü Pytorch gradyanları biriktirir. Her adımda eski gradyanları temizlemezseniz, model yanlış yönde güncellenir. loss.backward() ise türev alarak her bir parametrenin hataya ne kadar katkıda bulunduğunu hesaplar.

Model Performans Karşılaştırması

Kritik Uyarı: Üretim ortamında (production) model eğitirken, verilerinizi mutlaka "eğitim", "doğrulama" ve "test" setlerine ayırın. Sadece eğitim verisi ile test yapmak, modelin gerçek dünyadaki başarısını yanıltıcı şekilde yüksek gösterir. Kodunuzda asla hassas verileri (şifre, kimlik bilgisi) ham halde model eğitimine dahil etmeyin.

Sıkça Sorulan Sorular

GPU olmadan derin öğrenme modeli eğitilebilir mi?

Evet, eğitilebilir. Ancak işlem süresi CPU üzerinde çok daha uzun sürecektir. Küçük modeller veya öğrenme aşaması için CPU yeterlidir ancak büyük veri setlerinde GPU kullanımı şarttır.

Overfitting (Aşırı Öğrenme) nasıl engellenir?

Dropout katmanları ekleyerek, veri setini artırarak (data augmentation) veya "early stopping" yöntemini kullanarak modelin veriyi ezberlemesinin önüne geçebilirsiniz.

Pytorch'ta model nasıl kaydedilir?

torch.save(model.state_dict(), 'model.pth') komutu ile modelin ağırlıklarını kolayca kaydedebilir ve daha sonra model.load_state_dict() ile geri yükleyebilirsiniz.

Neden Adam optimizer tercih etmeliyim?

Adam, farklı parametreler için farklı öğrenme oranları hesapladığı için çoğu başlangıç seviyesi ve orta seviye problemde manuel ayar yapmadan iyi sonuçlar verir.

Pytorch ve TensorFlow arasındaki fark nedir?

Pytorch daha "Pythonic" bir yapıya sahip olup hata ayıklaması daha kolaydır. TensorFlow ise daha geniş bir ekosisteme sahiptir; ancak Pytorch son yıllarda akademik ve endüstriyel kullanımda liderliği ele almıştır.

PyTorch Modellerini Üretime Hazırlama: Deployment ve Model Optimizasyonu

Eğitim sürecini başarıyla tamamladığınız bir modeli gerçek dünya senaryolarında kullanmak, yani "deployment" (yayına alma) aşaması, modelin performansını korumak için kritik bir adımdır. PyTorch modellerini doğrudan bir web sunucusunda çalıştırmak yerine, genellikle TorchScript veya ONNX formatlarına dönüştürerek daha hafif ve hızlı bir çalışma ortamı sağlarız.

TorchScript ile Modeli Serileştirme

TorchScript, Python'dan bağımsız olarak modelin çalışmasını sağlayan bir ara formattır. Bu sayede modeliniz, Python bağımlılıklarının olmadığı ortamlarda bile (örneğin C++ tabanlı sistemlerde) çalışabilir. Aşağıdaki kod bloğu, eğitilmiş bir modeli TorchScript formatında nasıl kaydedeceğinizi gösterir:

import torch

# Modelinizi tanımladığınızı ve eğittiğinizi varsayalım
model = MyNeuralNetwork()
model.eval()

# Örnek bir girdi ile trace işlemi
example_input = torch.rand(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Modeli kaydetme
traced_model.save("model_scripted.pt")

Model Performansını İzleme ve Hata Ayıklama

Derin öğrenme projelerinde karşılaşılan en büyük zorluk, modelin neden beklenen performansı vermediğini anlamaktır. PyTorch Profiler, modelinizin eğitim sırasında hangi katmanlarda ne kadar zaman harcadığını ve bellek kullanımını detaylı bir şekilde raporlar.

Hata ayıklama sürecinde şu ipuçlarını izleyebilirsiniz:

• Gradient Clipping: Gradyan patlaması (exploding gradients) yaşıyorsanız, torch.nn.utils.clip_grad_norm_ fonksiyonunu kullanarak gradyan değerlerini sınırlayın.
• Learning Rate Scheduler: Eğitim sırasında öğrenme oranını dinamik olarak düşürmek (örneğin ReduceLROnPlateau), modelin yerel minimumlara takılmasını engeller.
• Input Normalization: Veri setinizin giriş değerlerinin 0-1 aralığında veya standart normal dağılıma sahip olduğundan emin olun; aksi takdirde modeliniz yakınsamayacaktır.

İleri Seviye Teknikler: Transfer Learning (Transfer Öğrenme)

Sıfırdan bir model eğitmek yerine, önceden eğitilmiş (pre-trained) modelleri kullanmak, özellikle kısıtlı veri setiniz olduğunda başarı oranınızı ciddi ölçüde artırır. torchvision.models kütüphanesi, ImageNet üzerinde eğitilmiş popüler mimarileri (ResNet, VGG, EfficientNet) kullanmanıza olanak tanır.

Transfer öğrenme uygularken izlemeniz gereken temel adımlar şunlardır:

1. Önceden eğitilmiş modelin ağırlıklarını dondurun (freeze).
2. Modelin son katmanını (fully connected layer), kendi sınıf sayınıza göre yeniden tanımlayın.
3. Sadece yeni eklediğiniz katmanları eğitin.

from torchvision import models

# Önceden eğitilmiş ResNet18 modelini yükle
model = models.resnet18(pretrained=True)

# Katmanları dondur
for param in model.parameters():
    param.requires_grad = False

# Son katmanı kendi veri setinize göre değiştirin
num_features = model.fc.in_features
model.fc = torch.nn.Linear(num_features, 10) # 10 sınıf olduğunu varsayalım

Profesyonel İpucu: Transfer öğrenme kullanırken, başlangıçta sadece son katmanı eğitmek modelin kararlılığını artırır. Birkaç epoch sonra, modelin daha derin katmanlarını da eğitilebilir (unfreeze) hale getirerek "fine-tuning" (ince ayar) yapabilirsiniz.

Sonuç

Python ile Pytorch kütüphanesini kullanarak derin öğrenme modeli geliştirmek, temel matematiksel mantığı ve kütüphane sözdizimini anladığınızda oldukça verimli bir süreçtir. Bu makalede adım adım veri hazırlamayı, model mimarisi kurmayı ve eğitim döngüsünü yönetmeyi öğrendiniz. Bir sonraki aşamada, kendi veri setlerinizi kullanarak daha karmaşık mimariler (CNN veya Transformer gibi) tasarlayabilir ve modellerinizi optimize edebilirsiniz.

Yasal Sorumluluk Reddi: Bu rehber eğitim amaçlıdır. Yazılımlarınızda kullanacağınız verilerin gizliliği ve güvenlik politikaları tamamen geliştiricinin sorumluluğundadır.