PyTorch: Sıfırdan İleri Seviyeye Kapsamlı [2026 Rehberi]
Yazar: Burak Balkı | Kategori: AI & Machine Learning | Okuma Süresi: 44 dk
PyTorch'u temelden ileri seviyeye, kurulumdan performans optimizasyonuna kadar detaylıca inceleyen bu 2026 rehberi, derin öğrenme projelerinizi başarıyla hay...
# PyTorch: Sıfırdan İleri Seviyeye Kapsamlı [2026 Rehberi]
**Yazar:** Burak Balkı (Bilgisayar Mühendisi, Full Stack Developer)
### BÖLÜM 1 - Giriş Paragrafı (Hook + Context)
Yapay zeka ve makine öğrenimi, 2026 yılında da teknoloji dünyasının en heyecan verici alanlarından biri olmaya devam ediyor. Özellikle derin öğrenme modellerinin karmaşıklığı ve hesaplama yoğunluğu arttıkça, bu modelleri verimli bir şekilde geliştirmek ve dağıtmak için güçlü araçlara olan ihtiyaç da katlanarak büyüyor. İşte tam bu noktada **PyTorch**, esnek yapısı, sezgisel API'si ve dinamik hesaplama grafiği ile araştırmacılar ve geliştiriciler arasında vazgeçilmez bir araç haline gelmiştir. Bu kapsamlı 2026 rehberinde, PyTorch'un temel prensiplerinden başlayarak, ileri seviye tekniklere, performans optimizasyonlarına ve gerçek dünya projelerine kadar A'dan Z'ye her yönünü keşfedeceksiniz. Amacımız, bu rehber sonunda PyTorch ile kendi derin öğrenme projelerinizi başarıyla hayata geçirecek bilgi ve becerilere sahip olmanızı sağlamaktır.
## PyTorch Nedir?
PyTorch, Python tabanlı açık kaynaklı bir makine öğrenimi kütüphanesidir. Özellikle derin öğrenme uygulamaları için tasarlanmıştır. Dinamik hesaplama grafiği, GPU hızlandırma desteği ve güçlü tensor operasyonları sayesinde hızlı prototipleme ve araştırmadan üretime kadar geniş bir yelpazede kullanılır. PyTorch, esnekliği ve Python ekosistemiyle kolay entegrasyonu sayesinde sinir ağı modelleri oluşturmak, eğitmek ve dağıtmak için ideal bir platform sunar.
PyTorch, Facebook'un yapay zeka araştırma laboratuvarı (FAIR) tarafından geliştirilen ve 2016'da piyasaya sürülen, Torch kütüphanesinin Python tabanlı bir versiyonudur. Güncel 2026 itibarıyla, özellikle PyTorch 2.x serisi ile derleyici tabanlı optimizasyonlar ve daha verimli dağıtık eğitim yetenekleri sunarak sektördeki yerini sağlamlaştırmıştır. Sezgisel API tasarımı, Python'a yakın sözdizimi ve güçlü topluluk desteği sayesinde hem akademik araştırmalarda hem de endüstriyel uygulamalarda hızla benimsenmiştir. PyTorch, özellikle bilgisayar görüşü, doğal dil işleme ve konuşma tanıma gibi alanlarda çığır açan modellere güç vermektedir. Esnekliği sayesinde deneysel yaklaşımları kolayca test etmenizi sağlarken, TorchScript gibi araçlarla üretim ortamlarına kolayca entegre edilebilir.
### BÖLÜM 3 - Neden PyTorch Kullanmalısınız? (Değer Önerisi)
PyTorch'un popülaritesi tesadüf değildir; sunduğu bir dizi somut fayda ve problem çözme yeteneği sayesinde geliştiricilerin ve araştırmacıların ilk tercihlerinden biri olmuştur. 2026 yılı itibarıyla PyTorch ekosistemi, model geliştirme sürecini hızlandıran ve kolaylaştıran sayısız araç ve kütüphane ile daha da olgunlaşmıştır.
**PyTorch'u Tercih Etme Nedenleri:**
* **Dinamik Hesaplama Grafiği (Define-by-Run):** PyTorch'un en belirgin özelliklerinden biri, modelin her ileri geçişte dinamik olarak oluşturulan bir hesaplama grafiği kullanmasıdır. Bu, hata ayıklamayı (debugging) standart Python kodunda olduğu gibi kolaylaştırır ve karmaşık kontrol akışlarına sahip modellerin (örneğin, RNN'ler) oluşturulmasını çok daha esnek hale getirir. TensorFlow'un eski statik grafikleriyle karşılaştırıldığında bu, geliştiricilere büyük bir özgürlük sunar.
* **Pythonic Yaklaşım ve Sezgisel API:** PyTorch, Python dilinin doğal akışına ve sözdizimine sıkı sıkıya bağlıdır. Bu, Python bilen geliştiricilerin kütüphaneyi hızla öğrenmesini ve kullanmasını sağlar. NumPy benzeri tensor işlemleri, veri manipülasyonunu tanıdık ve verimli kılar.
* **Güçlü GPU Desteği:** CUDA entegrasyonu sayesinde, PyTorch modelleri NVIDIA GPU'lar üzerinde yüksek performansla çalıştırılabilir. Bu, derin öğrenme modellerinin eğitim süresini dramatik şekilde kısaltır ve büyük veri kümeleriyle çalışmayı mümkün kılar. 2026'da GPU teknolojilerindeki ilerlemelerle PyTorch'un bu yeteneği daha da kritik hale gelmiştir.
* **Hızlı Prototipleme ve Araştırma:** Dinamik grafik ve kolay hata ayıklama özellikleri, araştırmacıların yeni model mimarilerini ve algoritmalarını hızlı bir şekilde denemesine olanak tanır. Bu, özellikle akademik çalışmalarda ve Ar-Ge projelerinde büyük bir avantajdır.
* **Zengin Ekosistem ve Topluluk:** PyTorch'un arkasında büyük ve aktif bir topluluk bulunmaktadır. `torchvision`, `torchaudio`, `torchtext`, `transformers` (Hugging Face) gibi kütüphaneler, bilgisayar görüşü, doğal dil işleme ve ses işleme gibi alanlarda hazır modeller ve veri setleri sunar. Stack Overflow'da geniş bir destek bulabilir, GitHub'da sayısız örnek projeye erişebilirsiniz. PyTorch'un GitHub deposu 2026 itibarıyla on binlerce yıldıza sahiptir ve sürekli gelişmektedir.
* **Üretime Hazırlık (TorchScript, ONNX):** PyTorch, modelleri üretim ortamlarına dağıtmak için çeşitli mekanizmalar sunar. TorchScript, Python bağımlılığı olmadan C++ ortamlarında çalışabilen optimize edilmiş model grafiklerini dışa aktarmayı sağlar. ONNX (Open Neural Network Exchange) desteği ise modellerin farklı çerçeveler arasında taşınabilirliğini kolaylaştırır.
* **Dağıtık Eğitim Kolaylığı:** Büyük modellerin ve veri setlerinin eğitimi için dağıtık eğitim kritik öneme sahiptir. PyTorch'un `DistributedDataParallel` ve `torch.distributed` modülleri, çoklu GPU ve çoklu makine üzerinde dağıtık eğitimi nispeten basit hale getirir. 2026'da bu özellikler, daha büyük ve karmaşık modellerin eğitimi için vazgeçilmezdir.
**Kimler İçin Uygun, Kimler İçin Değil?**
* **Uygun:** Derin öğrenme araştırmacıları, yapay zeka mühendisleri, veri bilimciler, Python ekosistemine aşina olanlar, hızlı prototipleme ve esnek model geliştirme arayanlar. Özellikle deneysel çalışmalar ve karmaşık mimariler için idealdir.
* **Uygun Değil:** Çok düşük seviyeli donanım optimizasyonu gerektiren gömülü sistemler veya Python kullanmak istemeyen geliştiriciler için alternatifler (örneğin, C++ tabanlı kütüphaneler) daha uygun olabilir. Ancak 2026'da PyTorch'un C++ frontend desteği de oldukça gelişmiştir.
### BÖLÜM 4 - PyTorch vs Alternatifler (Karşılaştırma Tablosu)
PyTorch, derin öğrenme dünyasında güçlü bir oyuncu olsa da, TensorFlow ve JAX gibi başka popüler kütüphaneler de bulunmaktadır. Her birinin kendine özgü avantajları ve kullanım senaryoları vardır. Aşağıdaki tablo, 2026 itibarıyla bu üç kütüphaneyi temel özellikler açısından karşılaştırmaktadır.
| Özellik | PyTorch (2.x) | TensorFlow (2.x) | JAX (0.4.x) |
| :----------------- | :------------------------------------------------ | :------------------------------------------------ | :-------------------------------------------------- |
| **Hesaplama Grafiği** | Dinamik (Define-by-Run) | Statik (Define-and-Run), Dinamik (Eager Execution) | Dinamik (JIT derleme ile statikleşir) |
| **Öğrenme Eğrisi** | Pythonic, NumPy benzeri, nispeten kolay | Daha dik, kendine özgü API, Keras ile kolaylaşır | Fonksiyonel programlama, NumPy benzeri, orta zorluk |
| **Ekosistem** | Zengin (torchvision, Hugging Face), araştırma odaklı | Çok zengin (Keras, TF Hub, TFLite), üretim odaklı | Gelişmekte, araştırma odaklı, XLA tabanlı |
| **Topluluk** | Çok aktif, hızlı destek, araştırma topluluğu | Çok büyük, endüstriyel ve akademik destek | Gelişmekte, Google tarafından destekleniyor |
| **Kurumsal Destek**| Meta (Facebook) tarafından güçlü destek | Google tarafından güçlü destek | Google tarafından güçlü destek |
| **Kullanım Alanı** | Araştırma, hızlı prototipleme, NLP, bilgisayar görüşü | Üretim, büyük ölçekli dağıtım, mobil, gömülü sistemler | Yüksek performanslı sayısal hesaplama, araştırma |
| **Hata Ayıklama** | Standart Python debugger ile kolay | Eager execution ile kolay, statik grafiklerde zor | Fonksiyonel yapı nedeniyle farklı yaklaşım |
2026 itibarıyla, PyTorch ve TensorFlow hala en yaygın kullanılan derin öğrenme kütüphaneleridir. PyTorch esnekliği ve Pythonic yapısıyla araştırmacılar ve hızlı prototipleme yapanlar için öne çıkarken, TensorFlow Keras entegrasyonu ve geniş üretim araç setleriyle büyük ölçekli dağıtımlar için güçlü bir seçenektir. JAX ise fonksiyonel programlama ve yüksek performanslı hesaplama yetenekleriyle niş bir kitleye hitap etmektedir. Seçim, projenizin ihtiyaçlarına, ekibinizin deneyimine ve önceliklerinize göre değişecektir.
### BÖLÜM 5 - Kurulum ve İlk Adımlar (Getting Started)
PyTorch'u sisteminize kurmak oldukça basittir. 2026 yılı itibarıyla, en güncel ve kararlı sürüm genellikle `pip` veya `conda` aracılığıyla kolayca yüklenebilir. Kurulum sırasında dikkat etmeniz gereken en önemli nokta, kullandığınız CUDA sürümüne (eğer GPU kullanacaksanız) ve Python sürümünüze uygun paketi seçmektir.
**Ön Gereksinimler:**
* Python 3.8+ (2026 itibarıyla önerilen sürüm)
* `pip` veya `conda` paket yöneticisi
* (Opsiyonel) NVIDIA GPU ve uyumlu CUDA Toolkit (GPU hızlandırma için)
**Adım Adım Kurulum (GPU Destekli - CUDA 12.x Örneği):**
1. **Python Ortamı Oluşturma (Önerilen):** Çakışmaları önlemek için sanal bir ortam kullanmanız şiddetle tavsiye edilir.
```bash
python3 -m venv pytorch_env_2026
source pytorch_env_2026/bin/activate # Linux/macOS
# pytorch_env_2026\Scripts\activate # Windows
```
2. **PyTorch Kurulum Komutunu Belirleme:** PyTorch'un resmi web sitesi ([pytorch.org](https://pytorch.org/)) ana sayfasında, işletim sisteminize, paket yöneticinize, Python sürümünüze ve CUDA sürümünüze (veya CPU only seçeneğine) göre özelleştirilmiş kurulum komutunu bulabilirsiniz. 2026'da genellikle PyTorch 2.x serisi kullanılır.
*Örnek (Linux, pip, CUDA 12.x):*
```bash
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
```
*Örnek (Linux, pip, CPU Only):*
```bash
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
```
3. **Kurulumu Doğrulama:** Kurulumun başarılı olup olmadığını kontrol etmek için Python etkileşimli kabuğunu açın ve PyTorch'u içe aktarın.
```python
import torch
print(torch.__version__)
print(torch.cuda.is_available()) # GPU varsa True döner
print(torch.cuda.device_count()) # Kaç GPU olduğunu gösterir
```
Eğer `True` ve GPU sayısını görüyorsanız, GPU hızlandırmanız başarıyla kurulmuş demektir. Aksi takdirde, CPU üzerinde çalışacaksınız.
> **Pro Tip:** Eğer CUDA sürümünüzle ilgili uyumsuzluklar yaşıyorsanız, PyTorch'un resmi web sitesindeki kurulum sihirbazını dikkatlice takip edin. Bazen eski bir CUDA sürümü veya uyumsuz bir sürücü, GPU kullanımını engelleyebilir.
### BÖLÜM 6 - Temel Kullanım ve Örnekler (Core Usage)
PyTorch'un kalbi, `Tensor` adı verilen çok boyutlu dizilerdir. NumPy dizilerine benzerler ancak GPU'larda çalışabilirler ve otomatik türev alma yeteneğine sahiptirler. İşte temel tensor işlemleri ve basit bir sinir ağı örneği.
**Örnek 1: Tensor Oluşturma ve Temel İşlemler**
**Problem:** Farklı şekillerde tensorlar oluşturmak ve üzerinde temel matematiksel işlemler yapmak.
**Çözüm:** `torch.tensor()`, `torch.zeros()`, `torch.ones()`, `torch.rand()` gibi fonksiyonları kullanarak tensorlar oluşturabilir ve `+`, `-`, `*`, `/` gibi operatörlerle işlem yapabilirsiniz.
```python
import torch
# Skaler (0 boyutlu tensor)
scalar_tensor = torch.tensor(3.14)
print(f"Skaler: {scalar_tensor}, Boyut: {scalar_tensor.dim()}")
# Vektör (1 boyutlu tensor)
vector_tensor = torch.tensor([1, 2, 3, 4])
print(f"Vektör: {vector_tensor}, Boyut: {vector_tensor.dim()}")
# Matris (2 boyutlu tensor)
matrix_tensor = torch.tensor([[1, 2], [3, 4]])
print(f"Matris: {matrix_tensor}, Boyut: {matrix_tensor.dim()}")
# Rastgele tensor oluşturma
random_tensor = torch.rand(2, 3) # 2x3 boyutunda rastgele sayılar
print(f"Rastgele Tensor:\n{random_tensor}")
# Sıfırlarla dolu tensor
zeros_tensor = torch.zeros(3, 3)
print(f"Sıfır Tensoru:\n{zeros_tensor}")
# Tensor işlemleri
tensor_a = torch.tensor([[1., 2.], [3., 4.]])
tensor_b = torch.tensor([[5., 6.], [7., 8.]])
sum_tensor = tensor_a + tensor_b
prod_tensor = tensor_a * tensor_b # Element-wise çarpma
matmul_tensor = torch.matmul(tensor_a, tensor_b) # Matris çarpımı
print(f"Toplam:\n{sum_tensor}")
print(f"Element-wise Çarpma:\n{prod_tensor}")
print(f"Matris Çarpımı:\n{matmul_tensor}")
```
**Örnek 2: GPU Kullanımı**
**Problem:** Tensorları CPU'dan GPU'ya taşımak ve GPU üzerinde işlem yapmak.
**Çözüm:** `tensor.to('cuda')` veya `tensor.cuda()` yöntemlerini kullanarak tensorları GPU'ya taşıyabilirsiniz. İşlemler otomatik olarak GPU'da gerçekleştirilir.
```python
import torch
if torch.cuda.is_available():
device = torch.device("cuda")
print("GPU mevcut. İşlemler GPU üzerinde yapılacak.")
else:
device = torch.device("cpu")
print("GPU mevcut değil. İşlemler CPU üzerinde yapılacak.")
x = torch.rand(5, 5, device=device) # Tensor'u doğrudan GPU'da oluştur
y = torch.rand(5, 5).to(device) # Tensor'u CPU'da oluşturup sonra GPU'ya taşı
z = x + y
print(f"GPU üzerinde oluşturulan ve toplanan tensor:\n{z}")
print(f"Sonuç tensorunun cihazı: {z.device}")
```
**Örnek 3: Otomatik Türev Alma (Autograd)**
**Problem:** Bir fonksiyonun parametrelerine göre türevlerini (gradyanlarını) otomatik olarak hesaplamak.
**Çözüm:** `requires_grad=True` ile tensorları tanımlayarak PyTorch'un `autograd` motorunu etkinleştirin. Sonra `.backward()` metodunu çağırarak geriye yayılımı başlatın.
```python
import torch
x = torch.tensor(2.0, requires_grad=True)
y = x**2 + 3*x + 1
y.backward() # Türev hesaplama
print(f"x'in türevi: {x.grad}") # dy/dx = 2x + 3. x=2 için 2*2 + 3 = 7
a = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
b = a * 2
# b'nin ortalamasını alıp skaler bir değere dönüştürmek
c = b.sum()
c.backward()
print(f"a'nın türevi: {a.grad}") # [2.0, 2.0, 2.0]
```
**Örnek 4: Basit Bir Sinir Ağı**
**Problem:** Çok katmanlı bir perceptron (MLP) oluşturmak ve ileri geçiş (forward pass) yapmak.
**Çözüm:** `torch.nn.Module` sınıfından miras alarak kendi ağınızı tanımlayın ve `forward` metodunu uygulayın.
```python
import torch
import torch.nn as nn
import torch.nn.functional as F
class SimpleMLP(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(SimpleMLP, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
out = self.fc1(x)
out = self.relu(out)
out = self.fc2(out)
return out
# Model parametreleri
input_size = 10
hidden_size = 20
output_size = 5
# Model oluşturma
model = SimpleMLP(input_size, hidden_size, output_size)
print("Model Yapısı:")
print(model)
# Rastgele bir girdi oluşturma
input_data = torch.randn(1, input_size) # Batch boyutu 1, girdi boyutu 10
# İleri geçiş yapma
output = model(input_data)
print(f"\nGirdi boyutu: {input_data.shape}")
print(f"Çıktı boyutu: {output.shape}")
print(f"Çıktı değerleri:\n{output}")
```
### BÖLÜM 7 - İleri Seviye Teknikler (Advanced Patterns)
PyTorch'u üretim ortamlarında veya karmaşık araştırma projelerinde kullanırken, sadece temel işlemleri bilmek yetmez. İşte 2026'da sıkça kullanılan bazı ileri seviye teknikler ve tasarım desenleri.
**1. Özel Katmanlar ve Modüller Oluşturma:**
**Problem:** PyTorch'un standart katmanları (Linear, Conv2d vb.) ihtiyaçlarınızı karşılamadığında kendi özel katmanınızı tanımlamak.
**Çözüm:** `nn.Module` sınıfından miras alarak kendi özel katmanınızı oluşturabilir ve `forward` metodunda özel hesaplamalarınızı yapabilirsiniz. `nn.Parameter` kullanarak öğrenilebilir ağırlıkları tanımlayın.
```python
import torch
import torch.nn as nn
class CustomActivation(nn.Module):
def forward(self, x):
# Özel bir aktivasyon fonksiyonu, örneğin Leaky ReLU'nun farklı bir varyasyonu
return torch.max(0.1 * x, x)
class CustomLinear(nn.Module):
def __init__(self, in_features, out_features):
super().__init__()
self.weight = nn.Parameter(torch.randn(out_features, in_features))
self.bias = nn.Parameter(torch.randn(out_features))
def forward(self, x):
return F.linear(x, self.weight, self.bias) # torch.nn.functional kullanmak
class AdvancedMLP(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.custom_fc1 = CustomLinear(input_size, hidden_size)
self.custom_act = CustomActivation()
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = self.custom_fc1(x)
x = self.custom_act(x)
x = self.fc2(x)
return x
model = AdvancedMLP(10, 20, 5)
input_data = torch.randn(1, 10)
output = model(input_data)
print("Özel katmanlı model çıktısı:", output.shape)
```
**2. Transfer Öğrenimi (Transfer Learning):**
**Problem:** Kısıtlı veriyle iyi performans gösteren bir model geliştirmek veya model eğitim süresini kısaltmak.
**Çözüm:** Büyük bir veri kümesi üzerinde eğitilmiş önceden eğitilmiş (pretrained) modelleri kullanarak, modelin son katmanlarını kendi verinize göre fine-tune etmek. `torchvision.models` kütüphanesi bu konuda zengin seçenekler sunar.
```python
import torch
import torch.nn as nn
import torchvision.models as models
# Önceden eğitilmiş ResNet-18 modelini yükle
# weights=models.ResNet18_Weights.IMAGENET1K_V1 2026'da güncel bir örnek olabilir
model_ft = models.resnet18(weights=models.ResNet18_Weights.DEFAULT) # PyTorch 2.x'te önerilen yol
# Tüm parametreleri dondur (freeze) - sadece son katmanı eğiteceğiz
for param in model_ft.parameters():
param.requires_grad = False
# Son katmanı kendi sınıf sayımıza göre değiştir
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 10) # Örneğin, 10 sınıflı bir problem için
# Artık sadece model_ft.fc katmanının parametreleri eğitilebilir durumda
# Bir optimizör tanımlayıp eğitimi başlatabilirsiniz
optimizer = torch.optim.SGD(model_ft.fc.parameters(), lr=0.001, momentum=0.9)
print("Transfer Öğrenimi için modelin son katmanı güncellendi.")
```
**3. Model Kaydetme ve Yükleme:**
**Problem:** Eğitilmiş bir modeli daha sonra kullanmak veya dağıtmak.
**Çözüm:** `torch.save()` ve `torch.load()` fonksiyonlarını kullanarak modelin durum sözlüğünü (state_dict) veya tüm modeli kaydedip yükleyebilirsiniz. `state_dict` genellikle daha esnektir.
```python
import torch
import torch.nn as nn
class MyModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(10, 1)
def forward(self, x):
return self.linear(x)
model = MyModel()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# Modelin durumunu kaydetme
PATH = "model_state_dict_2026.pt"
torch.save(model.state_dict(), PATH)
print(f"Model durumu '{PATH}' dosyasına kaydedildi.")
# Modeli yükleme
loaded_model = MyModel()
loaded_model.load_state_dict(torch.load(PATH))
loaded_model.eval() # Çıkarım moduna geç
# Yüklenen modeli kullanma
input_data = torch.randn(1, 10)
output = loaded_model(input_data)
print(f"Yüklenen modelden çıktı:\n{output}")
```
**4. TorchScript ile Model Optimizasyonu ve Dağıtımı:**
**Problem:** Python bağımlılığı olmadan, C++ ortamında veya mobil cihazlarda yüksek performansla model çalıştırmak.
**Çözüm:** PyTorch modellerini TorchScript'e dönüştürerek optimize edilmiş ve bağımsız çalışabilen bir formata getirin. `torch.jit.trace` veya `torch.jit.script` kullanabilirsiniz.
```python
import torch
import torch.nn as nn
class MyTorchScriptModel(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.relu = nn.ReLU()
self.fc1 = nn.Linear(32 * 26 * 26, 10) # Örnek boyutlar
def forward(self, x):
x = self.conv1(x)
x = self.relu(x)
x = torch.flatten(x, 1)
x = self.fc1(x)
return x
model = MyTorchScriptModel()
example_input = torch.rand(1, 1, 28, 28) # Örnek bir girdi
# Modeli TorchScript'e trace etme
traced_model = torch.jit.trace(model, example_input)
# Kaydetme
scripted_model_path = "traced_model_2026.pt"
traced_model.save(scripted_model_path)
print(f"TorchScript modeli '{scripted_model_path}' olarak kaydedildi.")
# Yükleme ve kullanma
loaded_script_model = torch.jit.load(scripted_model_path)
output = loaded_script_model(example_input)
print(f"TorchScript modelinden çıktı:\n{output.shape}")
```
### BÖLÜM 8 - Best Practices & Anti-Patterns
PyTorch ile yüksek performanslı, sürdürülebilir ve güvenilir derin öğrenme modelleri geliştirmek için belirli en iyi uygulamaları takip etmek ve yaygın hatalardan kaçınmak kritik öneme sahiptir. 2026'da üretim ortamlarında bu prensiplere uyum, proje başarısını doğrudan etkiler.
✅ **DOĞRU YAKLAŞIMLAR:**
* **Veri Yükleyicilerini (DataLoader) Etkin Kullanın:** Büyük veri kümeleriyle çalışırken `torch.utils.data.Dataset` ve `DataLoader` kullanarak verileri verimli bir şekilde yükleyin ve batch'lere ayırın. Bu, eğitim döngüsünü hızlandırır ve bellek yönetimini optimize eder.
* **GPU Kullanımını Optimize Edin:** Mümkün olduğunda tüm tensorları ve modelleri GPU'ya taşıyın (`.to(device)`). Küçük tensorları sürekli CPU-GPU arasında taşımaktan kaçının, bu performans kaybına neden olur. Özellikle `torch.cuda.amp` ile otomatik karışık hassasiyetli eğitimi kullanarak bellek ve hızdan tasarruf edin.
* **`model.eval()` ve `torch.no_grad()` Kullanın:** Çıkarım (inference) yaparken modelinizi `model.eval()` moduna alın ve `torch.no_grad()` bağlam yöneticisini kullanın. Bu, gradyan hesaplamalarını devre dışı bırakarak bellek tüketimini azaltır ve çıkarım hızını artırır.
* **Öğrenme Oranı Zamanlayıcıları (Learning Rate Schedulers) Kullanın:** Eğitimin ilerleyen aşamalarında öğrenme oranını dinamik olarak ayarlayarak modelin daha iyi yakınsamasını sağlayın. `torch.optim.lr_scheduler` modülündeki zamanlayıcılar (örneğin, `ReduceLROnPlateau`, `CosineAnnealingLR`) çok faydalıdır.
* **Model Checkpoint'leri Düzenli Kaydedin:** Eğitimin belirli aralıklarında modelin ağırlıklarını ve optimizörün durumunu kaydederek, kesintilerde eğitime devam edebilir veya en iyi modeli geri yükleyebilirsiniz. Sadece `state_dict` kaydetmek, model mimarisi değişirse daha esneklik sağlar.
* **Aşırı Uyumdan (Overfitting) Kaçının:** Dropout, Batch Normalization, veri büyütme (data augmentation) ve erken durdurma (early stopping) gibi teknikleri kullanarak modelinizin eğitim verilerine aşırı uyum sağlamasını engelleyin. Bu, modelin genelleme yeteneğini artırır.
* **Deterministik Davranış İçin Seed Ayarlayın:** Araştırma veya yeniden üretilebilirlik için `torch.manual_seed()`, `numpy.random.seed()` ve Python `random.seed()` kullanarak rastgele sayı üreteçlerini sabitleyin. Bu, aynı kodun her çalıştırıldığında aynı sonuçları vermesini sağlar.
* **TorchScript ve ONNX ile Üretim Ortamına Hazırlık:** Modellerinizi üretim ortamına dağıtmadan önce TorchScript veya ONNX formatına dönüştürerek performans optimizasyonu ve platformlar arası uyumluluk sağlayın.
❌ **YANLIŞ YAKLAŞIMLAR (Anti-Patterns):**
* **Tensorları Sürekli CPU-GPU Arasında Taşımak:** Her işlem için tensorları CPU'dan GPU'ya veya tersine taşımak, ciddi performans darboğazlarına yol açar. Bir tensoru bir cihaza atadıktan sonra mümkün olduğunca o cihazda tutun.
* **Gereksiz Yere `requires_grad=True` Kullanmak:** Çıkarım sırasında veya gradyan hesaplamasına ihtiyaç duymadığınız katmanlarda `requires_grad=True` kullanmak, gereksiz bellek tüketimine ve yavaşlamaya neden olur. `torch.no_grad()` veya `param.requires_grad = False` ile devre dışı bırakın.
* **Büyük Batch Boyutları Kullanmaktan Korkmamak:** Bazen daha büyük batch boyutları, GPU kullanımını optimize ederek eğitim süresini kısaltabilir. Ancak çok büyük batch'ler bellek dışı hatalara neden olabilir veya genelleme performansını düşürebilir. Doğru dengeyi bulun.
* **Sadece Varsayılan Öğrenme Oranını Kullanmak:** Optimizörlerin varsayılan öğrenme oranları her zaman en iyisi değildir. Öğrenme oranını ve diğer hiperparametreleri (momentum, ağırlık düşüşü vb.) deneyerek modelinizin performansını önemli ölçüde artırabilirsiniz.
* **Eğitim ve Test Verilerini Karıştırmak:** Veri sızıntısını (data leakage) önlemek için eğitim, doğrulama ve test veri kümelerini kesinlikle ayrı tutun. Test kümesini sadece modelin nihai performansını değerlendirmek için kullanın.
* **Güvenlik Zafiyetlerini Göz Ardı Etmek:** Modelinizi üretim ortamına dağıtırken, modelin girdi doğrulamasını (input validation) ve olası adversarial saldırılara karşı dayanıklılığını göz önünde bulundurun. Modelin eğitildiği verilerin hassasiyetine dikkat edin ve gizlilik protokollerini uygulayın.
### BÖLÜM 9 - Yaygın Hatalar ve Çözümleri (Troubleshooting)
PyTorch ile derin öğrenme projeleri geliştirirken, özellikle yeni başlayanlar veya karmaşık modellerle uğraşanlar için bazı yaygın hatalarla karşılaşmak kaçınılmazdır. İşte 2026'da sıkça görülen sorunlar ve bunların çözümleri.
1. **Problem: `RuntimeError: CUDA out of memory.`**
* **Sebep:** GPU belleği, modelin veya veri batch'inin boyutunu kaldıramayacak kadar dolu. Bu, genellikle çok büyük bir model, yüksek çözünürlüklü görüntüler veya büyük bir batch boyutu kullanıldığında meydana gelir.
* **Çözüm:**
* Batch boyutunu küçültün.
* Daha küçük model mimarileri kullanın.
* Görüntü boyutlarını küçültün.
* `torch.cuda.empty_cache()` çağırarak kullanılmayan GPU belleğini serbest bırakın (eğitim döngüsünün başında veya sonunda).
* `torch.cuda.amp` ile karışık hassasiyetli eğitimi (mixed-precision training) kullanın (FP16, FP32'ye göre daha az bellek tüketir).
* Gereksiz `requires_grad=True` kullanımından kaçının, çıkarım sırasında `torch.no_grad()` kullanın.
2. **Problem: `ValueError: Expected input of size X, got size Y` veya şekil uyuşmazlıkları.**
* **Sebep:** Sinir ağının katmanlarına beklenen boyutta (shape) bir tensor yerine farklı boyutta bir tensor verilmesi. Bu genellikle `view()`, `reshape()`, `flatten()` gibi işlemlerin yanlış uygulanmasından veya veri ön işleme hatalarından kaynaklanır.
* **Çözüm:**
* Her katmanın giriş ve çıkış boyutlarını dikkatlice kontrol edin.
* `tensor.shape` veya `tensor.size()` kullanarak tensorların boyutlarını adım adım takip edin.
* `print()` ifadeleriyle veya bir debugger ile modelin `forward` metodunu çalıştırırken tensor boyutlarını izleyin.
* Özellikle `nn.Linear` katmanına girmeden önce tensorları doğru şekilde düzleştirdiğinizden (flatten) emin olun.
3. **Problem: Model eğitimi sırasında gradyanların kaybolması (vanishing gradients) veya patlaması (exploding gradients).**
* **Sebep:** Derin ağlarda geriye yayılım sırasında gradyanların çok küçük (vanishing) veya çok büyük (exploding) hale gelmesi, bu da modelin öğrenmesini engeller. Vanishing gradients genellikle ReLU dışı aktivasyon fonksiyonları ve çok derin ağlarda görülürken, exploding gradients büyük öğrenme oranları veya kötü ağırlık başlangıç değerleri ile ortaya çıkar.
* **Çözüm:**
* **Vanishing Gradients için:** ReLU veya Leaky ReLU gibi aktivasyon fonksiyonları kullanın. Batch Normalization ekleyin. Kalan bağlantılar (residual connections) içeren ağlar (ResNet gibi) kullanın. Uygun ağırlık başlangıç değerleri (He, Xavier initialization) kullanın.
* **Exploding Gradients için:** Gradyan kırpma (gradient clipping) uygulayın (`nn.utils.clip_grad_norm_`). Öğrenme oranını düşürün. Batch Normalization kullanın.
4. **Problem: Modelin eğitim verileri üzerinde iyi performans gösterirken test verilerinde kötü performans sergilemesi (Overfitting).**
* **Sebep:** Modelin eğitim verilerini ezberlemesi ve genelleme yeteneğini kaybetmesi.
* **Çözüm:**
* Daha fazla eğitim verisi toplayın veya veri büyütme (data augmentation) teknikleri kullanın.
* Modelin karmaşıklığını azaltın (daha az katman, daha az nöron).
* Dropout katmanları ekleyin.
* Ağırlık düşüşü (weight decay) ile L2 düzenlileştirme kullanın.
* Erken durdurma (early stopping) uygulayın.
* Modelinizin mimarisini basitleştirin veya daha az parametreye sahip bir model kullanın.
### BÖLÜM 10 - Performans Optimizasyonu
PyTorch modellerinin eğitimi ve çıkarımı, özellikle büyük veri kümeleri ve karmaşık modellerle çalışırken zaman ve kaynak yoğun olabilir. 2026'da rekabetçi kalmak için performans optimizasyonu kritik öneme sahiptir. İşte PyTorch'ta performansı artırmak için kullanabileceğiniz bazı kanıtlanmış teknikler.
**1. Otomatik Karışık Hassasiyetli Eğitim (Automatic Mixed Precision - AMP):**
AMP, PyTorch 1.6'dan itibaren yerleşik olarak sunulan ve 2026'da standart hale gelen bir özelliktir. Modelleri FP16 (yarım hassasiyet) ve FP32 (tek hassasiyet) formatlarını birlikte kullanarak eğitir. Bu, GPU belleğini yarıya indirirken eğitim hızını önemli ölçüde artırabilir (genellikle %20-50).
```python
import torch
import torch.nn as nn
from torch.cuda.amp import autocast, GradScaler
# Örnek model ve veri
model = nn.Linear(1000, 1000).cuda() # Model GPU'da olmalı
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scaler = GradScaler() # Gradyanları ölçeklemek için
input_data = torch.randn(64, 1000).cuda()
target = torch.randn(64, 1000).cuda()
loss_fn = nn.MSELoss()
# Normal eğitim (FP32)
optimizer.zero_grad()
output_fp32 = model(input_data)
loss_fp32 = loss_fn(output_fp32, target)
loss_fp32.backward()
optimizer.step()
print(f"FP32 Loss: {loss_fp32.item():.4f}")
# Karışık hassasiyetli eğitim (AMP)
optimizer.zero_grad()
with autocast(): # Otomatik olarak tensorları FP16'ya çevirir
output_amp = model(input_data)
loss_amp = loss_fn(output_amp, target)
scaler.scale(loss_amp).backward() # Ölçeklenmiş gradyanlar için backward
scaler.step(optimizer) # Ölçeklenmiş gradyanları güncelle
scaler.update(