PyTorch ile Otomatik Karışık Hassasiyet (Automatic Mixed Precision – AMP)

PyTorch ile Otomatik Karışık Hassasiyet (Automatic Mixed Precision – AMP)

Derin öğrenme modellerinin eğitimi, özellikle büyük veri kümeleri ve karmaşık mimarilerle uğraşırken, önemli hesaplama kaynakları gerektirir. Bu kaynaklar arasında bellek bant genişliği, işlemci gücü ve enerji tüketimi yer alır. Geleneksel olarak, derin öğrenme modelleri genellikle 32-bit kayan nokta (FP32) hassasiyetinde eğitilir. Ancak, bu hassasiyet çoğu zaman gereğinden fazladır ve performansı optimize etmek için potansiyel sunar. Karışık hassasiyet (Mixed Precision) eğitimi, bu potansiyeli ortaya çıkarmak için popüler bir tekniktir. PyTorch, Otomatik Karışık Hassasiyet (AMP) ile bu süreci önemli ölçüde basitleştirir. Bu makalede, PyTorch’ta AMP’nin ne olduğunu, neden kullanılması gerektiğini, nasıl çalıştığını ve pratikte nasıl uygulanacağını detaylı bir şekilde inceleyeceğiz.

Karışık Hassasiyet Nedir ve Neden Önemlidir?

Karışık hassasiyet, bir sinir ağının eğitiminde hem daha düşük hassasiyetli (örneğin, 16-bit kayan nokta – FP16) hem de daha yüksek hassasiyetli (örneğin, 32-bit kayan nokta – FP32) veri tiplerini birlikte kullanma yöntemidir. Bu yaklaşımın temel motivasyonu, bilgisayar donanımının (özellikle GPU’ların) FP16 işlemleri için optimize edilmiş olmasıdır.

FP16’nın avantajları şunlardır:

* Daha Hızlı Hesaplamalar: Modern GPU’lar, özellikle NVIDIA’nın Tensor Çekirdekleri gibi özel donanımlar, FP16 matris çarpımları ve evrişimleri gibi işlemleri FP32’ye göre çok daha hızlı gerçekleştirebilir. Bu, eğitim süresini önemli ölçüde azaltabilir.
* Daha Az Bellek Kullanımı: FP16, FP32’ye göre bellekte yarı yarıya daha az yer kaplar. Bu, daha büyük modellerin veya daha büyük toplu iş boyutlarının (batch sizes) belleğe sığdırılabilmesi anlamına gelir. Bellek bant genişliği darboğazları da azaltılır.
* Daha Düşük Enerji Tüketimi: Daha az hesaplama ve daha az bellek erişimi, genellikle daha düşük enerji tüketimi ile sonuçlanır.

Ancak, FP16’nın bazı dezavantajları da vardır:

* Daha Düşük Dinamik Aralık: FP16, FP32’ye göre daha küçük bir dinamik aralığa sahiptir. Bu, çok küçük veya çok büyük değerlerin temsil edilmesinde zorluklara yol açabilir. Özellikle gradyanlar, eğitim sırasında çok küçük hale gelebilir (underflow) ve sıfıra yuvarlanabilir, bu da eğitimin durmasına veya performansın düşmesine neden olabilir.
* Daha Düşük Hassasiyet: Bazı durumlarda, FP16’nın hassasiyet kaybı modelin doğruluğunu olumsuz etkileyebilir.

Karışık hassasiyet, bu dezavantajları en aza indirirken FP16’nın avantajlarından yararlanmayı amaçlar. Genellikle, ağırlıklar ve aktivasyonlar FP16 olarak saklanıp işlenirken, toplamalar ve gradyan hesaplamaları gibi hassasiyet gerektiren operasyonlar FP32’de tutulur. Bu, hem hız hem de doğruluk dengesini sağlamaya yardımcı olur.

PyTorch’ta Otomatik Karışık Hassasiyet (AMP)

PyTorch’ta Otomatik Karışık Hassasiyet (AMP), karışık hassasiyet eğitimini kolaylaştırmak için tasarlanmış bir özelliktir. Manuel olarak hangi operasyonların hangi hassasiyette çalışacağına karar vermek yerine, PyTorch’un AMP modülü bunu otomatik olarak yönetir. AMP, CUDA cihazlarında (NVIDIA GPU’lar) çalışır ve torch.cuda.amp modülü aracılığıyla erişilebilir.

AMP’nin temel bileşenleri şunlardır:

1. torch.cuda.amp.autocast Konteynırı: Bu konteynır, içine alınan kod bloklarındaki operasyonların otomatik olarak doğru veri tiplerinde (FP16 veya FP32) çalışmasını sağlar. autocast bağlamı etkinleştirildiğinde, PyTorch hangi operasyonların FP16’ya dönüştürülebileceğini akıllıca belirler. Örneğin, matris çarpımları ve evrişimler gibi hesaplama açısından yoğun operasyonlar FP16’ya dönüştürülebilirken, hassasiyet gerektiren diğer operasyonlar FP32’de kalır. Bu, torch.autograd.autocast olarak da bilinir ve FP32 ve FP16’nın yanı sıra bfloat16 gibi diğer veri tiplerini de destekleyebilir.

2. torch.cuda.amp.GradScaler Sınıfı: FP16’nın sınırlı dinamik aralığı nedeniyle gradyanlar çok küçük hale gelebilir (underflow). GradScaler, bu sorunu çözmek için gradyanları eğitimin belirli bir aşamasında ölçeklendirir. Ölçeklendirme, gradyanların FP16’nın temsil edebileceği aralığa taşınmasına yardımcı olur. Eğitim tamamlandıktan sonra, gradyanlar orijinal ölçeklerine geri ölçeklendirilir. Bu işlem, loss.backward() çağrılmadan önce gradyanların ölçeklenmesi ve optimizer.step() çağrıldıktan sonra ölçeklendirmenin kaldırılması adımlarını içerir.

### AMP Nasıl Çalışır?

AMP’nin arkasındaki temel mekanizma şöyledir:

* Otomatik Veri Tipi Seçimi (autocast): autocast konteynırı etkinleştirildiğinde, PyTorch belirli operasyonları (örneğin, torch.nn.Linear, torch.nn.Conv2d) otomatik olarak FP16’ya dönüştürür. Bu dönüşüm, operasyonun girişlerinin FP16’ya dönüştürülmesini ve operasyonun FP16 tensörleri üzerinde çalıştırılmasını içerir. Ancak, bazı operasyonlar (örneğin, bazı normalleştirme katmanları veya softmax gibi hassas çıktılar üreten operasyonlar) FP32’de tutulur. Bu, modelin doğruluğunu korumaya yardımcı olur.
* Gradyan Ölçeklendirme (GradScaler):
1. Ölçekleme: GradScaler, loss.backward() çağrılmadan önce kayıp değerini büyük bir faktörle çarpar. Bu, gradyanları da aynı faktörle ölçekler.
2. Geri Yayılım: Ölçeklenmiş kayıp, normal geri yayılım sürecinden geçer. Bu işlem, FP16’da saklanan ağırlıklar ve ara çıktılarla gerçekleştirilir, ancak gradyanlar FP32’de hesaplanır.
3. Ölçeklendirme Kaldırma: optimizer.step() çağrılmadan önce, GradScaler, hesaplanan gradyanları orijinal ölçeklerine geri bölerek ölçeklendirmeyi kaldırır. Bu, gradyanların doğru değerlere sahip olmasını sağlar.
4. Taşma Kontrolü: GradScaler, gradyanlarda bir taşma (overflow) olup olmadığını da kontrol eder. Eğer bir taşma tespit edilirse, bu adım atlanır ve gradyanlar sıfırlanır, böylece modelin güncellenmesi engellenir. Bu, eğitim sürecinin kararlılığını artırır.

### AMP’nin Avantajları

PyTorch’ta AMP kullanmanın başlıca avantajları şunlardır:

* Performans Artışı: Eğitim sürelerinde önemli ölçüde azalma sağlar. Donanım özelliklerine bağlı olarak %1.5x ila %4x arasında hız artışı görülebilir.
* Bellek Verimliliği: Daha az bellek kullanımı, daha büyük modellerin veya daha büyük toplu iş boyutlarının kullanılmasına olanak tanır.
* Basit Uygulama: autocast konteynırı ve GradScaler sınıfı sayesinde, mevcut bir PyTorch kodunu minimum değişiklikle AMP’ye uyarlamak mümkündür. Genellikle sadece birkaç satır kod eklemek yeterlidir.
* Doğruluk Korunumu: GradScaler ve akıllı veri tipi seçimi sayesinde, FP16’nın getirdiği hassasiyet ve dinamik aralık sorunları büyük ölçüde giderilir. Çoğu durumda, FP32 ile elde edilen doğruluk seviyesi korunur.

### PyTorch’ta AMP Uygulaması

PyTorch’ta AMP’yi uygulamak oldukça basittir. Aşağıda, tipik bir eğitim döngüsünde AMP’nin nasıl kullanılacağına dair bir örnek bulunmaktadır:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.cuda.amp import autocast, GradScaler

Modelinizi, kayıp fonksiyonunuzu ve optimize edicinizi tanımlayın
model = YourModel() # Örnek bir model sınıfı
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

GPU'ya taşıyın (eğer mevcutsa)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

GradScaler'ı başlatın
scaler = GradScaler()

Eğitim döngüsü
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    for inputs, targets in dataloader: # Dataloader'ınız
        inputs, targets = inputs.to(device), targets.to(device)

        optimizer.zero_grad()

        # autocast konteynırı içinde ileri geçişi gerçekleştirin
        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, targets)

        # GradScaler kullanarak geri yayılımı gerçekleştirin
        scaler.scale(loss).backward()

        # Gradyanları çözün ve optimize ediciyi güncelleyin
        scaler.step(optimizer)

        # Ölçekleyiciyi bir sonraki adım için güncelleyin
        scaler.update()

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.4f}')

Modelinizi kaydedin (isteğe bağlı)
torch.save(model.state_dict(), 'model_with_amp.pth')

Yukarıdaki kod örneğinde dikkat edilmesi gereken noktalar şunlardır:

* scaler = GradScaler(): Bir GradScaler nesnesi oluşturulur. Bu nesne, gradyan ölçeklendirme işlemini yönetecektir.
* with autocast():: İleri geçiş (forward pass) ve kayıp hesaplaması autocast konteynırı içine alınır. Bu, bu blok içindeki uygun operasyonların otomatik olarak FP16’ya dönüştürülmesini sağlar.
* scaler.scale(loss).backward(): Geleneksel loss.backward() yerine scaler.scale(loss).backward() kullanılır. Bu, kaybı ölçekler ve ardından ölçeklenmiş kaybı kullanarak geri yayılımı gerçekleştirir.
* scaler.step(optimizer): Geleneksel optimizer.step() yerine scaler.step(optimizer) kullanılır. Bu, ölçeklenmiş gradyanları kontrol eder, eğer taşma yoksa gradyanların ölçeklendirmesini kaldırır ve ardından optimize ediciyi kullanarak ağırlıkları günceller.
* scaler.update(): scaler.step() çağrıldıktan sonra scaler.update() çağrılır. Bu, gradyanlardaki taşma durumuna göre ölçekleme faktörünü ayarlar. Eğer bir taşma olmuşsa, ölçekleme faktörü azaltılır; eğer taşma olmamışsa, faktör artırılabilir.

### AMP ile İlgili Dikkat Edilmesi Gerekenler ve İpuçları

* Donanım Uyumluluğu: AMP, CUDA özellikli NVIDIA GPU’larda en iyi şekilde çalışır. Özellikle Tensor Çekirdekleri olan GPU’lar (Volta mimarisi ve sonrası) önemli performans artışları sunar.
* Veri Tipleri: Varsayılan olarak AMP, FP16 ve FP32’yi kullanır. Ancak, autocast fonksiyonu, dtype argümanı ile farklı veri tiplerini destekleyebilir (örneğin, torch.bfloat16). bfloat16, özellikle TPU’larda ve belirli NVIDIA GPU’larda daha iyi performans gösterebilir.
* Kayıp Fonksiyonu: Bazı özel kayıp fonksiyonları için, gradyan hesaplamalarının hassasiyetini korumak amacıyla kayıp fonksiyonunu FP32’de tutmak gerekebilir. Ancak, autocast genellikle bu durumu otomatik olarak yönetir. Eğer emin değilseniz, kayıp hesaplamasını autocast bloğunun dışında tutabilirsiniz.
* Model Mimarisi: Çoğu modern sinir ağı mimarisi AMP ile uyumludur. Ancak, çok nadir durumlarda, belirli katmanların veya operasyonların FP16’da sayısal olarak kararsız hale gelmesi söz konusu olabilir. Bu tür durumlar için, ilgili katmanları veya operasyonları FP32’de tutmak için autocast konteynırını daha dar bir alana uygulayabilir veya özel olarak bu katmanlar için veri tipini manuel olarak ayarlayabilirsiniz.
* Test Etme: Her zaman olduğu gibi, AMP’yi kullanırken modelinizin doğruluğunu dikkatlice test edin. Çoğu durumda, doğrulukta önemli bir düşüş olmaz, ancak nadir de olsa bazı modellerde küçük değişiklikler gözlemlenebilir.
* Optimizasyon Ayarları: GradScaler‘ın varsayılan ayarları genellikle iyi sonuç verir. Ancak, çok kararsız eğitim durumlarında init_scale parametresini ayarlamak veya growth_interval gibi parametreleri değiştirmek faydalı olabilir.
* Dağıtılmış Eğitim (Distributed Training): AMP, torch.nn.parallel.DistributedDataParallel gibi dağıtılmış eğitim stratejileriyle sorunsuz bir şekilde çalışır.

### AMP’nin Gelişimi ve Geleceği

PyTorch’ta AMP, sürekli olarak geliştirilmektedir. Yeni donanım özelliklerinin desteği, performans optimizasyonları ve kullanım kolaylığı üzerine çalışmalar devam etmektedir. PyTorch’un gelecekteki sürümlerinde, AMP’nin daha da entegre hale gelmesi ve daha geniş bir donanım yelpazesinde daha iyi performans sunması beklenmektedir. Ayrıca, bfloat16 gibi yeni veri tiplerinin desteği ve bu veri tiplerinin kullanımını daha da kolaylaştıran araçlar geliştirilmektedir.

TensorRT gibi çıkarım (inference) optimizasyon araçları da karışık hassasiyetten faydalanır. Eğitimde elde edilen AMP’nin faydaları, çıkarım aşamasında da modelin daha hızlı ve daha az bellek kullanarak çalışmasını sağlayabilir.

### Sonuç

PyTorch’ta Otomatik Karışık Hassasiyet (AMP), derin öğrenme modellerinin eğitimini hızlandırmak ve bellek kullanımını optimize etmek için güçlü ve kullanımı kolay bir araçtır. torch.cuda.amp.autocast ve torch.cuda.amp.GradScaler sınıfları sayesinde, geliştiriciler karmaşık manuel hassasiyet yönetimiyle uğraşmak zorunda kalmadan bu teknikten yararlanabilirler. AMP, modern derin öğrenme iş akışlarında performansı artırmak ve daha büyük modellerle daha verimli çalışmak için vazgeçilmez bir özellik haline gelmiştir. Uygulaması nispeten basittir ve çoğu durumda modelin doğruluğunu korurken önemli ölçüde hız kazanımı sağlar. Bu nedenle, GPU tabanlı derin öğrenme projelerinde AMP’nin kullanılması şiddetle tavsiye edilir.