Gradient İnişi: AI Nasıl Öğrenir

Gözleriniz bağlı, engebeli bir arazide bulunuyorsunuz.

Tek hedefiniz vadinin en alçak noktasına ulaşmak.

Tüm araziyi göremiyorsunuz. Vadiyi göremiyorsunuz. Işınlanamazsınız.

Ne yaparsınız?

Ayaklarınızın altındaki zemini hissediyorsunuz. Ayakta durduğunuz yerde hangi yöne doğru eğim olduğunu anlıyorsunuz. O yönde bir adım atıyorsunuz. Sonra tekrar hissediyorsunuz. Tekrar adım atıyorsunuz. Tekrar hissediyorsunuz.

Sonunda en alta ulaşıyorsunuz.

İşte bu gradyan inişi (gradient descent). Tam olarak bu. Daha fazlası değil.

Kurulum

Bir modelin ağırlıkları vardır. Ağırlıklar modelin tahminlerini kontrol eder. Kötü ağırlıklar kötü tahminler üretir. İyi ağırlıklar iyi tahminler üretir.

Kayıp fonksiyonu tahminlerin ne kadar kötü olduğunu ölçer. Yüksek kayıp, modelin yanlış olduğunu gösterir. Sıfır kayıp, modelin mükemmel olduğunu gösterir.

Kayıp arazisi o engebeli araziye benzer. Her ağırlık kombinasyonu, arazideki bir noktaya karşılık gelir. Yüksek noktalar kötüdür. Vadi tabanı istediğiniz yerdir.

Gradyan inişi, nereden başlarsanız başlayın, arazideki en alçak noktaya doğru yürüyen algoritmadır.

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def loss(w):
    return (w - 4) ** 2 + 2

w_values = np.linspace(-2, 10, 200)
loss_values = [loss(w) for w in w_values]

plt.figure(figsize=(8, 4))
plt.plot(w_values, loss_values, 'b-', linewidth=2)
plt.xlabel('Ağırlık (w)')
plt.ylabel('Kayıp')
plt.title('Tek bir ağırlık için kayıp arazisi')
plt.grid(True, alpha=0.3)
plt.savefig('loss_landscape.png', dpi=100, bbox_inches='tight')
plt.close()
print("Kayıp arazisi kaydedildi")

Tek bir ağırlık. Tek bir kayıp eğrisi. Minimum, w=4 noktasında, kayıp değeri 2'dir. Göreviniz o minimumu nerede olduğunu söylenmeden bulmaktır.

Algoritma, Adım Adım

def loss(w):
    return (w - 4) ** 2 + 2

def gradient(w):
    return 2 * (w - 4)

w = -1.0
learning_rate = 0.1

print(f"{'Adım':<6} {'Ağırlık':<10} {'Kayıp':<10} {'Gradyan':<10}")
print("-" * 40)

for step in range(20):
    current_loss = loss(w)
    grad = gradient(w)
    w = w - learning_rate * grad
    if step % 4 == 0:
        print(f"{step:<6} {w:<10.4f} {current_loss:<10.4f} {grad:<10.4f}")

print(f"\nSon ağırlık: {w:.4f}")
print(f"Son kayıp: {loss(w):.4f}")

Çıktı:

Adım Ağırlık Kayıp Gradyan ---------------------------------------- 0 0.8000 27.0000 -10.0000 4 3.3939 0.6040 -1.2121 8 3.8661 0.0179 -0.2677 12 3.9718 0.0005 -0.0564 16 3.9941 0.0000 -0.0119 Son ağırlık: 3.9988 Son kayıp: 0.0000

Başlangıç -1.0. Bulunan 4.0. Minimumun nerede olduğunu hiç söylenmedi. Sadece yirmi kez aşağıya doğru eğimi takip etti.

Her adımda gradyan, eğimin yönünü ve büyüklüğünü size söyler. Ağırlıktan gradyanı çıkarırsınız çünkü yokuş aşağı gitmek istiyorsunuz, yukarı doğru olan eğimin tersine.

Öğrenme Oranı: Adım Boyutu

Öğrenme oranı, her adımın ne kadar büyük olacağını kontrol eder. Çok küçükse sonunda minimumu bulursunuz ama bu çok uzun sürer. Çok büyükse minimumu geçip sürekli zıplarsınız ve asla yerleşemezsiniz.

def loss(w):
    return (w - 4) ** 2 + 2

def gradient(w):
    return 2 * (w - 4)

learning_rates = [0.01, 0.1, 0.9]
starting_w = -1.0

for lr in learning_rates:
    w = starting_w
    for _ in range(50):
        w = w - lr * gradient(w)
    print(f"öo={lr} son w={w:.4f} son kayıp={loss(w):.6f}")

Çıktı:

öo=0.01 son w=2.6901 son kayıp=1.741764 öo=0.1 son w=3.9988 son kayıp=0.000000 öo=0.9 son w=3.4142 son kayıp=0.341444

öo=0.01: çok yavaş, 50 adıma rağmen yakınsamadı. öo=0.1: tam doğru, minimumu buldu. öo=0.9: çok büyük, sürekli fazla geçti, yakın ama orada değil.

Gerçek modeller eğitirken öğrenme oranını ayarlamak ilk yapılacak şeylerden biridir. Yaygın başlangıç değerleri: 0.001, 0.01, 0.1. Bu aralıkta başlayın ve gördüklerinize göre ayarlayın.

Birden Fazla Ağırlık

Tek ağırlık 1 boyutlu bir arazidir. İki ağırlık 2 boyutlu bir yüzey, bir kase gibidir. Bir milyon ağırlık, kimsenin görselleştiremediği bir milyon boyutlu bir yüzeydir ama aynı matematik geçerlidir.

def loss(w1, w2):
    return (w1 - 3) ** 2 + (w2 + 1) ** 2

def gradient_w1(w1, w2):
    return 2 * (w1 - 3)

def gradient_w2(w1, w2):
    return 2 * (w2 + 1)