L1/L2 düzenlileştirme

# ML kategorisindeki Ridge/Lasso dersinde L1 (Lasso) ve L2 (Ridge) cezalarını görmüştük.
# Hızlı bir hatırlatma: L1, gereksiz özellikleri TAM SIFIRA çekerken, L2 küçültür ama sıfırlamaz.
np.random.seed(0)
N = 100
X = np.random.randn(N, 5)
gercek_w = np.array([3.0, -2.0, 0.0, 0.0, 0.0])  # sadece ilk 2 özellik GERÇEKTEN önemli
y = X @ gercek_w + np.random.randn(N) * 0.1

lasso = Lasso(alpha=0.1).fit(X, y)
ridge = Ridge(alpha=1.0).fit(X, y)
print("Gerçek ağırlıklar:", gercek_w)
print("Lasso (L1):        ", np.round(lasso.coef_, 4))
print("Ridge (L2):        ", np.round(ridge.coef_, 4))
print("\nLasso, önemsiz 3 özelliği TAM SIFIRA çekiyor -- Ridge küçültüyor ama sıfırlamıyor.")
print("Sinir ağlarında bu tür 'özellik seçimi' nadiren hedeftir -- asıl mesele AŞIRI ÖĞRENMEYİ önlemek.")

# Sinir ağlarında L2, genelde 'weight decay' olarak optimizer İÇİNDE uygulanır.
# Küçük, gürültülü bir veri setinde büyük bir ağ -- aşırı öğrenmeye MÜKEMMEL bir aday.
torch.manual_seed(0)
N_egitim = 15
x_egitim = torch.linspace(-3, 3, N_egitim).unsqueeze(1)
y_egitim = torch.sin(x_egitim) + torch.randn(N_egitim, 1) * 0.3

N_test = 100
x_test = torch.linspace(-3, 3, N_test).unsqueeze(1)
y_test = torch.sin(x_test)

def ag_olustur():
    torch.manual_seed(1)
    return nn.Sequential(nn.Linear(1, 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(), nn.Linear(64, 1))

def egit(weight_decay, epochs=2000, lr=0.01):
    ag = ag_olustur()
    optimizer = torch.optim.Adam(ag.parameters(), lr=lr, weight_decay=weight_decay)
    for _ in range(epochs):
        optimizer.zero_grad()
        tahmin = ag(x_egitim)
        kayip = torch.mean((tahmin - y_egitim) ** 2)
        kayip.backward()
        optimizer.step()
    egitim_kaybi = torch.mean((ag(x_egitim) - y_egitim) ** 2).item()
    test_kaybi = torch.mean((ag(x_test) - y_test) ** 2).item()
    agirlik_normu = sum(p.abs().sum().item() for p in ag.parameters())
    return egitim_kaybi, test_kaybi, agirlik_normu

print(f"\n{'weight_decay':<14} {'Eğitim kaybı':<14} {'Test kaybı':<12} {'Ağırlık normu':<14}")
sonuclar = {}
for wd in [0.0, 0.001, 0.01, 0.1]:
    et, tt, an = egit(wd)
    sonuclar[wd] = (et, tt, an)
    print(f"{wd:<14} {et:<14.4f} {tt:<12.4f} {an:<14.1f}")

print("\nwd=0: eğitim kaybı NEREDEYSE SIFIR (ezberlemiş) ama ağırlık normu devasa (666.1) -- klasik aşırı öğrenme.")
print("wd=0.01: eğitim kaybı biraz arttı ama TEST kaybı en düşük -- bu, düzenlileştirmenin 'tatlı noktası'.")
print("wd=0.1: eğitim kaybı çok arttı (yetersiz öğrenme) -- aşırı düzenlileştirme yeni bir sorun yaratıyor.")

# PyTorch'ta weight_decay, optimizer'a TEK bir parametreyle eklenir -- L2 cezasını elle
# loss'a eklemeye GEREK YOK, optimizer bunu otomatik yapar.
print("\ntorch.optim.Adam(model.parameters(), lr=0.01, weight_decay=0.01)")
print("Bu satır, her güncellemede ağırlıklara otomatik olarak w -= lr * weight_decay * w ekler.")
print("Elle eklemek isteseydik: kayip = kayip + weight_decay * sum(w**2 for w in agirliklar)")