Sigmoid

Kanca

10. ML dersinde sigmoid’i lojistik regresyonda gördük — bir “ham skoru” olasılığa çeviren bir araçtı. 5. derste ise aynı fonksiyonun DERİN ağlarda gradyanı yok ettiğini gördük. Bu iki gözlemi birleştirelim: sigmoid’in şekli, TAM OLARAK neden bu iki sonucu birlikte doğuruyor?

Sezgi

Sigmoid, herhangi bir sayıyı (0, 1) aralığına sıkıştıran S şeklinde bir eğridir. Uçlarda (çok büyük veya çok küçük girdilerde) neredeyse düzleşir — çıktı 0’a veya 1’e “yapışır” ve girdideki küçük değişikliklere neredeyse hiç tepki vermez. Bu düzleşmeye doygunluk (saturation) denir.

Sigmoid sekmesinde, mavi çizgi (f(x)) ve turuncu kesikli çizgiyi (f’(x), türev) karşılaştır: türev sadece x=0 civarında büyük, uçlara doğru neredeyse SIFIRLANIYOR (kırmızı gölgeli bölgeler). Bu derste bu şeklin NEDEN bu kadar önemli olduğunu göreceğiz.

Mekanizma

Önce sigmoid’in temel davranışına bakalım:

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

x_degerleri = np.array([-10, -5, -2, 0, 2, 5, 10])
print(f"{'x':>6} {'sigmoid(x)':>12}")
for x in x_degerleri:
    print(f"{x:>6} {sigmoid(x):>12.5f}")
print("\nÇıktı HER ZAMAN (0, 1) aralığında -- 10. ML dersindeki lojistik regresyonun AYNI fonksiyonu.")

     x   sigmoid(x)
   -10      0.00005
    -5      0.00669
    -2      0.11920
     0      0.50000
     2      0.88080
     5      0.99331
    10      0.99995

Çıktı HER ZAMAN (0, 1) aralığında -- 10. ML dersindeki lojistik regresyonun AYNI fonksiyonu.

Çıktı her zaman (0, 1) aralığında — x=-10’da neredeyse 0, x=10’da neredeyse 1. Şimdi türevine bakalım:

def sigmoid_turev(x):
    s = sigmoid(x)
    return s * (1 - s)

print(f"\n{'x':>6} {'sigmoid(x)':>12} {'türev':>10}")
for x in x_degerleri:
    print(f"{x:>6} {sigmoid(x):>12.5f} {sigmoid_turev(x):>10.6f}")
print("\nTürev x=0'da MAKSİMUM (0.25), |x| büyüdükçe HIZLA sıfıra yaklaşıyor -- 5. dersteki 'doygunluk' tam olarak bu.")

     x   sigmoid(x)      türev
   -10      0.00005   0.000045
    -5      0.00669   0.006648
    -2      0.11920   0.104994
     0      0.50000   0.250000
     2      0.88080   0.104994
     5      0.99331   0.006648
    10      0.99995   0.000045

Türev x=0'da MAKSİMUM (0.25), |x| büyüdükçe HIZLA sıfıra yaklaşıyor -- 5. dersteki 'doygunluk' tam olarak bu.

Türev x=0’da tam olarak 0.25 (maksimum), ama x=10’da sadece 0.000045! Çoğu kişi “sigmoid’in 0 ile 1 arasında çıktı vermesi, onu ‘güvenli’ bir aktivasyon yapar” sanır. Eksik, çünkü çıktının sınırlı olması, gradyanın da (türevin) sınırlı ve çoğu bölgede neredeyse SIFIR olması anlamına geliyor — bu tam olarak 5. derste gördüğümüz kaybolan gradyanın kaynağı.

Matematik

Kod

PyTorch’un autograd’ı ile elle türettiğimiz formülü doğrulayalım:

x_torch = torch.tensor([-10.0, -5.0, -2.0, 0.0, 2.0, 5.0, 10.0], requires_grad=True)
y_torch = torch.sigmoid(x_torch)
y_torch.sum().backward()  # her x için ayrı ayrı gradyan almak için .sum().backward() kullanıyoruz

print(f"\n{'x':>6} {'PyTorch sigmoid':>16} {'PyTorch gradyan':>16} {'Elle hesaplanan':>16}")
for i, x in enumerate(x_degerleri):
    print(f"{x:>6} {y_torch[i].item():>16.5f} {x_torch.grad[i].item():>16.6f} {sigmoid_turev(x):>16.6f}")
print("\nPyTorch'un autograd'ı ile elle türettiğimiz formül BİREBİR aynı sonucu veriyor.")

     x  PyTorch sigmoid  PyTorch gradyan  Elle hesaplanan
   -10          0.00005         0.000045         0.000045
    -5          0.00669         0.006648         0.006648
    -2          0.11920         0.104994         0.104994
     0          0.50000         0.250000         0.250000
     2          0.88080         0.104994         0.104994
     5          0.99331         0.006648         0.006648
    10          0.99995         0.000045         0.000045

PyTorch'un autograd'ı ile elle türettiğimiz formül BİREBİR aynı sonucu veriyor.

Birebir aynı sonuçlar. Şimdi bu “hassasiyet” kaybının somut etkisine bakalım:

# 5. dersteki 15 katmanlı ağı hatırla: sigmoid'in doygunluğu, DERİN ağlarda gradyanı yok ediyordu.
# Burada TEK bir sigmoid katmanının, girdinin büyüklüğüne göre ne kadar "hassas" kaldığını görelim.
girdi_araligi = np.linspace(-10, 10, 5)
hassasiyet = sigmoid_turev(girdi_araligi)
print(f"\nGirdi büyüklüğü arttıkça (uzaklaştıkça) hassasiyet (türev):")
for g, h in zip(girdi_araligi, hassasiyet):
    cubuk = "█" * int(h * 100)
    print(f"  x={g:>6.1f}  türev={h:.4f}  {cubuk}")

Girdi büyüklüğü arttıkça (uzaklaştıkça) hassasiyet (türev):
  x= -10.0  türev=0.0000  
  x=  -5.0  türev=0.0066  
  x=   0.0  türev=0.2500  █████████████████████████
  x=   5.0  türev=0.0066  
  x=  10.0  türev=0.0000  

Nerede işe yarar

Sigmoid, tarihsel önemine rağmen bugün DİKKATLİ kullanılması gereken bir araçtır:

• Çıktı katmanında olasılık üretmek için hâlâ standart. 10. ML dersindeki gibi, ikili sınıflandırmanın SON katmanında sigmoid doğal bir seçimdir (gizli katmanlarda değil).
• Kapı (gate) mekanizmalarında. LSTM gibi mimarilerde (NLP kategorisinde göreceğiz), “ne kadarını geçireyim” sorusuna 0-1 arası bir cevap gerektiğinde.
• Gizli katmanlarda NADİREN tercih edilir. 5. derste gördüğümüz kaybolan gradyan riski yüzünden, modern derin ağların gizli katmanlarında genelde ReLU (8. ders) tercih edilir.

Bu 3 hatayı yaparsın:

1. Derin bir ağın TÜM gizli katmanlarında sigmoid kullanmak — 5. dersteki 928 milyon kat fark bunun neden riskli olduğunu gösteriyor.
2. Girdileri büyük ölçekte (örn. -100 ile 100 arası) sigmoid’e vermek — bu, neredeyse HER noktayı doygunluk bölgesine iter.
3. Sigmoid’in türevini her seferinde $e^{-x}$‘ten yeniden hesaplamak — $\sigma(x)(1-\sigma(x))$ formülü, zaten hesaplanmış $\sigma(x)$‘i yeniden kullanarak çok daha verimlidir.

Kendini test et

Özet