Dropout

# Dropout, her forward pass'te rastgele nöronları (olasılık p ile) sıfırlar.
# Bu yüzden aynı girdi bile, train() modunda her seferinde farklı bir çıktı verebilir.
torch.manual_seed(0)
ag = nn.Sequential(nn.Linear(4, 4), nn.Dropout(0.5))
x = torch.ones(1, 4)

ag.train()
print("train() modunda aynı girdiyle 3 farklı forward pass:")
for _ in range(3):
    print(" ", ag(x).detach().numpy().round(3))

ag.eval()
print("\neval() modunda aynı girdiyle 3 farklı forward pass:")
for _ in range(3):
    print(" ", ag(x).detach().numpy().round(3))

print("\ntrain() modunda çıktı her seferinde değişiyor (rastgele maskeleme); eval() modunda sabit -- dropout kapalı.")

# 21. dersteki aynı küçük/gürültülü veri setinde, weight_decay yerine dropout deneyelim.
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(dropout_orani):
    torch.manual_seed(1)
    katmanlar = [nn.Linear(1, 64), nn.Tanh()]
    if dropout_orani > 0:
        katmanlar.append(nn.Dropout(dropout_orani))
    katmanlar += [nn.Linear(64, 64), nn.Tanh()]
    if dropout_orani > 0:
        katmanlar.append(nn.Dropout(dropout_orani))
    katmanlar.append(nn.Linear(64, 1))
    return nn.Sequential(*katmanlar)

def egit(dropout_orani, epochs=3000, lr=0.01):
    ag = ag_olustur(dropout_orani)
    optimizer = torch.optim.Adam(ag.parameters(), lr=lr)
    for _ in range(epochs):
        ag.train()  # dropout aktif
        optimizer.zero_grad()
        tahmin = ag(x_egitim)
        kayip = torch.mean((tahmin - y_egitim) ** 2)
        kayip.backward()
        optimizer.step()
    ag.eval()  # dropout kapalı -- değerlendirmede rastgelelik istenmez
    with torch.no_grad():
        egitim_kaybi = torch.mean((ag(x_egitim) - y_egitim) ** 2).item()
        test_kaybi = torch.mean((ag(x_test) - y_test) ** 2).item()
    return egitim_kaybi, test_kaybi

print(f"\n{'Dropout oranı':<16} {'Eğitim kaybı':<14} {'Test kaybı':<12}")
sonuclar = {}
for p in [0.0, 0.1, 0.3, 0.5]:
    et, tt = egit(p)
    sonuclar[p] = (et, tt)
    print(f"{p:<16} {et:<14.4f} {tt:<12.4f}")

en_iyi_p = min(sonuclar, key=lambda p: sonuclar[p][1])  # test kaybı en düşük oran
print(f"\ndropout=0: eğitim kaybı sıfıra çok yakın (ezber). dropout={en_iyi_p}: test kaybı en düşük -- 21. dersteki weight_decay'e benzer bir 'tatlı nokta'.")
print("dropout=0.5: eğitim kaybı belirgin arttı -- çok fazla nöron sıfırlanınca ağ yeterince öğrenemiyor.")

# nn.Dropout, kalan (sıfırlanmayan) değerleri 1/(1-p) ile ölçekler -- neden?
p = 0.5
katman = nn.Dropout(p)
katman.train()
girdi = torch.ones(10000)  # büyük bir örneklemle ortalamayı test edelim
cikti = katman(girdi)
print(f"\nGirdi ortalaması: {girdi.mean().item():.4f}")
print(f"Dropout(p=0.5) sonrası çıktı ortalaması: {cikti.mean().item():.4f}")
print("İkisi de ~1.0 -- 'inverted dropout' ölçeklemesi sayesinde ortalama korunuyor.")
print("Bu sayede train() ve eval() arasında modelin çıktı büyüklüğü tutarlı kalıyor.")