Adagrad

Kanca

15. derste momentumun, gürültülü gradyanları YUMUŞATTIĞINI gördük — ama tüm ağırlıklara AYNI öğrenme oranını uyguluyordu. Ya bazı ağırlıklar (örn. nadir kelimelere karşılık gelenler) çok SEYREK, bazıları (yaygın kelimeler) çok SIK güncelleniyorsa? Adagrad, bu soruna cevap veren ilk “uyarlanabilir” (adaptive) optimizer.

Sezgi

Adagrad, HER ağırlık için AYRI bir öğrenme oranı tutar — ve bu oranı, o ağırlığın GEÇMİŞTEKİ gradyanlarının büyüklüğüne göre otomatik küçültür. Sık güncellenen bir ağırlık zamanla “yavaşlar”; seyrek güncellenen bir ağırlık göreli olarak “hızlı” kalır.

Optimizer yarışında Adagrad’ı (yeşil) izle — vadi yüzeyinde diğerlerinden nasıl farklı bir yörünge izliyor?

Mekanizma

Bunu somutlaştırmak için iki ağırlık düşünelim: w1 HER adımda güncelleniyor (sık bir özellik), w2 sadece 6 adımda bir güncelleniyor (seyrek bir özellik, örn. nadir görülen bir kelime).

# İki ağırlık: w1 HER adımda güncellenen "sık" bir özelliği, w2 SADECE 6 adımda
# bir güncellenen "seyrek" bir özelliği temsil ediyor (örn. nadir görülen bir kelime).
def egit(adagrad_kullan, adim_sayisi=30, lr=0.4):
    w1, w2 = 5.0, 5.0
    cache1, cache2 = 0.0, 0.0
    yol1, yol2 = [w1], [w2]
    for t in range(adim_sayisi):
        g1 = 1.0
        g2 = 5.0 if t % 6 == 0 else 0.0
        if adagrad_kullan:
            cache1 += g1 ** 2
            cache2 += g2 ** 2
            w1 -= lr * g1 / (np.sqrt(cache1) + 1e-8)
            w2 -= lr * g2 / (np.sqrt(cache2) + 1e-8)
        else:
            w1 -= lr * g1
            w2 -= lr * g2
        yol1.append(w1)
        yol2.append(w2)
    return yol1, yol2

yol1_sgd, yol2_sgd = egit(adagrad_kullan=False)
yol1_ada, yol2_ada = egit(adagrad_kullan=True)

print(f"SGD:     w1(sık)={yol1_sgd[-1]:.3f}, w2(seyrek)={yol2_sgd[-1]:.3f}")
print(f"Adagrad: w1(sık)={yol1_ada[-1]:.3f}, w2(seyrek)={yol2_ada[-1]:.3f}")
print("\nSGD, iki ağırlığı da AYNI sabit öğrenme oranıyla günceller -- hangisinin sık, hangisinin seyrek olduğunu 'bilmez'.")
print("Adagrad ise seyrek güncellenen w2'yi daha AZ küçültüyor (cache'i az büyüdüğü için efektif lr yüksek kalıyor).")

SGD:     w1(sık)=-7.000, w2(seyrek)=-5.000
Adagrad: w1(sık)=1.166, w2(seyrek)=3.707

SGD, iki ağırlığı da AYNI sabit öğrenme oranıyla günceller -- hangisinin sık, hangisinin seyrek olduğunu 'bilmez'.
Adagrad ise seyrek güncellenen w2'yi daha AZ küçültüyor (cache'i az büyüdüğü için efektif lr yüksek kalıyor).

SGD ile ikisi de BENZER şekilde küçülüyor (-7.000 ve -5.000) — SGD hangisinin sık, hangisinin seyrek olduğunu “bilmiyor”. Adagrad ile sonuç çarpıcı şekilde farklı: sık güncellenen w1 sadece 1.166’ya iniyor (küçük efektif adımlarla), seyrek w2 ise 3.707’de kalıyor (hâlâ göreli büyük adımlar alıyor). Çoğu kişi “optimizer sadece hızlandırır” sanır. Eksik, çünkü Adagrad her ağırlığa KENDİ geçmişine göre farklı davranır.

Matematik

Kod

Bu tek-yönlü küçülmenin somut etkisini görelim, sonra PyTorch’un torch.optim.Adagrad’ı ile doğrulayalım:

# Adagrad'ın "efektif öğrenme oranı" (lr / sqrt(cache)), her güncellemede KÜÇÜLÜR.
cache1 = 0.0
print("\nw1 (her adımda g=1 alan 'sık' ağırlık) için efektif öğrenme oranının çöküşü:")
for t in range(1, 31, 5):
    cache1 = t  # g1=1 sabit olduğu için cache1, adım sayısına eşit büyüyor
    efektif_lr = 0.4 / (np.sqrt(cache1) + 1e-8)
    print(f"  adım {t}: efektif_lr = {efektif_lr:.4f}")

print("\nBu çöküş, Adagrad'ın en büyük ZAYIFLIĞI: uzun eğitimlerde efektif öğrenme oranı o kadar küçülür ki öğrenme neredeyse DURUR.")

w1 (her adımda g=1 alan 'sık' ağırlık) için efektif öğrenme oranının çöküşü:
  adım 1: efektif_lr = 0.4000
  adım 6: efektif_lr = 0.1633
  adım 11: efektif_lr = 0.1206
  adım 16: efektif_lr = 0.1000
  adım 21: efektif_lr = 0.0873
  adım 26: efektif_lr = 0.0784

Bu çöküş, Adagrad'ın en büyük ZAYIFLIĞI: uzun eğitimlerde efektif öğrenme oranı o kadar küçülür ki öğrenme neredeyse DURUR.

# PyTorch'un torch.optim.Adagrad'ı ile aynı sonucu doğrulayalım.
w1_t = torch.tensor(5.0, requires_grad=True)
w2_t = torch.tensor(5.0, requires_grad=True)
optimizer = torch.optim.Adagrad([w1_t, w2_t], lr=0.4)

for t in range(30):
    optimizer.zero_grad()
    g1 = 1.0
    g2 = 5.0 if t % 6 == 0 else 0.0
    w1_t.grad = torch.tensor(g1)
    w2_t.grad = torch.tensor(g2)
    optimizer.step()

print(f"\nPyTorch Adagrad: w1={w1_t.item():.3f}, w2={w2_t.item():.3f}")
print(f"Elle yazdığımız Adagrad: w1={yol1_ada[-1]:.3f}, w2={yol2_ada[-1]:.3f}  -- neredeyse aynı (küçük farklar epsilon uygulama detayından).")

PyTorch Adagrad: w1=1.166, w2=3.707
Elle yazdığımız Adagrad: w1=1.166, w2=3.707  -- neredeyse aynı (küçük farklar epsilon uygulama detayından).

PyTorch’un sonucu (w1=1.166, w2=3.707) elle yazdığımız versiyonla BİREBİR aynı.

Nerede işe yarar

Adagrad, özellikle SEYREK verilerde (NLP kategorisinde göreceğimiz kelime embedding’leri gibi) faydalıdır:

• Seyrek özellikli problemlerde (örn. nadir kelimeler) iyi çalışır — nadir görülen özellikler, göreli büyük güncellemeler almaya devam eder.
• Uzun eğitimlerde efektif öğrenme oranı çok küçülebilir — bu, Adagrad’ın en bilinen ZAYIFLIĞI (bir sonraki derste RMSprop bunu nasıl çözdüğünü göreceğiz).
• Pratikte RMSprop veya Adam, Adagrad’ın bu zayıflığını gidermiş halleri olarak tercih edilir — ama Adagrad, “uyarlanabilir öğrenme oranı” fikrinin temelini attı.

Bu 3 hatayı yaparsın:

1. Adagrad’ı çok UZUN eğitimlerde kullanıp öğrenmenin neden durduğunu anlamamak — cache sürekli büyüdüğü için efektif lr sıfıra yaklaşır.
2. “Uyarlanabilir” kelimesini duyunca öğrenme oranını hiç ayarlamaya gerek olmadığını sanmak — başlangıç $\eta$ hâlâ önemlidir.
3. Adagrad’ı YOĞUN (dense, her özelliğin her örnekte göründüğü) verilerde kullanıp RMSprop/Adam’ın daha iyi çalışacağı bir durumu kaçırmak.

Kendini test et

Özet