Adam

# Adam = Momentum (15. ders) fikri + RMSprop (17. ders) fikri birleştirilmiş.
# m: gradyanın üstel ortalaması (momentum'daki "hız" gibi)
# v: gradyan karesinin üstel ortalaması (RMSprop'taki "cache" gibi)
# Deney: basit bir vadi, L(w) = w²/2 (minimum w=0'da, gradyan g = w). Başlangıç w=5, lr=0.3.
# lr=0.3 demek: Adam'ın her adımı ~0.3 büyüklüğünde olmalı.
def adam_duzeltmesiz(adim_sayisi, lr=0.3, b1=0.9, b2=0.999):
    w, m, v = 5.0, 0.0, 0.0
    yol, adimlar = [w], []
    for t in range(1, adim_sayisi + 1):
        g = w  # L = w²/2 -> dL/dw = w
        m = b1 * m + (1 - b1) * g
        v = b2 * v + (1 - b2) * g ** 2
        adim = lr * m / (np.sqrt(v) + 1e-8)
        w -= adim
        yol.append(w)
        adimlar.append(adim)
    return yol, adimlar

yol_duzeltmesiz, adimlar_duzeltmesiz = adam_duzeltmesiz(30)
print("Bias düzeltmesi olmadan Adam, ilk 5 adımın büyüklüğü (hedef ~0.3):")
print("  " + ", ".join(f"{a:.2f}" for a in adimlar_duzeltmesiz[:5]))
print(f"\nw, minimumu (0) {np.argmax(np.array(yol_duzeltmesiz) < 0)}. adımda geçip {min(yol_duzeltmesiz):.2f} değerine kadar karşı tarafa savruluyor.")

# Sorun: m ve v, sıfırdan başlıyor -- ilk adımlarda gerçek değerlerinden çok küçük kalıyorlar.
# Adam, bunu (1 - beta^t) ile bölerek düzeltir -- "bias correction".
def adam_duzeltmeli(adim_sayisi, lr=0.3, b1=0.9, b2=0.999):
    w, m, v = 5.0, 0.0, 0.0
    yol, adimlar = [w], []
    for t in range(1, adim_sayisi + 1):
        g = w
        m = b1 * m + (1 - b1) * g
        v = b2 * v + (1 - b2) * g ** 2
        m_hat = m / (1 - b1 ** t)
        v_hat = v / (1 - b2 ** t)
        adim = lr * m_hat / (np.sqrt(v_hat) + 1e-8)
        w -= adim
        yol.append(w)
        adimlar.append(adim)
    return yol, adimlar

yol_duzeltmeli, adimlar_duzeltmeli = adam_duzeltmeli(30)
print("Bias düzeltmesi ile Adam, ilk 5 adımın büyüklüğü (hedef ~0.3):")
print("  " + ", ".join(f"{a:.2f}" for a in adimlar_duzeltmeli[:5]))
print("\nw, ~0.3'lük adımlarla minimuma iniyor ve onun etrafında küçük salınımlarla kalıyor.")
print("Fark sadece (1-beta^t) ile bölme -- ama ilk adımlar 3-5 kat büyükten, tam olması gereken boyuta iniyor.")

# İlk adımda (t=1) m ve v'nin düzeltmesiz ve düzeltmeli hâllerini karşılaştıralım (g = 1 için).
b1, b2 = 0.9, 0.999
g = 1.0
m_ham, v_ham = (1 - b1) * g, (1 - b2) * g ** 2
m_hat, v_hat = m_ham / (1 - b1), v_ham / (1 - b2)
print(f"t=1'de m = {m_ham:.3f}  (gerçek değerin {g / m_ham:.0f} katı küçük)   ->  düzeltmeli m_hat = {m_hat:.3f}")
print(f"t=1'de v = {v_ham:.5f}  (gerçek değerin {g ** 2 / v_ham:.0f} katı küçük) ->  düzeltmeli v_hat = {v_hat:.3f}")
print(f"\nAdım ∝ m/√v: düzeltmesiz {m_ham / np.sqrt(v_ham):.2f}, düzeltmeli {m_hat / np.sqrt(v_hat):.2f}")
print("m 10 kat küçük ama √v ~32 kat küçük: payda (√v) paydan (m) daha çok küçüldüğü için adım ~3 kat büyüyor.")

# PyTorch'un torch.optim.Adam'ı, bias düzeltmesini içinde otomatik yapar.
w_t = torch.tensor(5.0, requires_grad=True)
optimizer = torch.optim.Adam([w_t], lr=0.3, betas=(0.9, 0.999))
for t in range(30):
    optimizer.zero_grad()
    kayip = w_t ** 2 / 2
    kayip.backward()
    optimizer.step()
print(f"\nPyTorch Adam, 30 adım sonra: w={w_t.item():.4f}")
print(f"Elle yazdığımız (düzeltmeli) Adam: w={yol_duzeltmeli[-1]:.4f}  -- birebir aynı.")