Bölüm 3 · Klasik algoritmalar · Ders 16

Gradyan artırma

Küçük ağaçlar art arda, her biri öncekinin hatasını düzeltir

Veri. Bir kargo dronunu −10 °C ile 50 °C arasında 80 kez aynı görevle uçurduk ve batarya bitene kadar kaç dakika havada kaldığını ölçtük. Soğukta kimyasal tepkime yavaşlar, süre 30 dakikanın altına düşer; 30 °C’nin üstünde batarya koruması devreye girer, süre yine azalır. Görev planlayıcı, hava sıcaklığından uçuş süresini tahmin etmek istiyor.

80 uçuş: sıcaklık ve uçuş süresi80 uçuş · öğrenme oranı 0,10

1 / 61

Tur sayısı 100Öğrenme oranı 0.1

gradyan_artirma.pypython

import numpy as np
rng = np.random.default_rng(8)
T = np.sort(rng.uniform(-10, 50, 80)) # ortam sıcaklığı, °C
y = 62 - 30 * np.exp(-(T + 10) / 10) # soğukta düşüş
y -= 0.04 * np.maximum(0, T - 30) ** 2 # sıcakta düşüş
y += rng.normal(0, 1.5, 80) # uçuş süresi, dk
val = np.arange(80) % 4 == 3 # her 4. uçuş doğrulama
Tt, yt = T[~val], y[~val] # eğitim uçuşları
def kutuk(r):
best = (np.inf, 0, 0, 0)
for t in (Tt[1:] + Tt[:-1]) / 2: # her eşik
L = Tt <= t
a, b = r[L].mean(), r[~L].mean() # iki yaprak: ortalama
e = ((r - np.where(L, a, b)) ** 2).sum()
if e < best[0]: best = (e, t, a, b)
return best[1:]
lr = 0.1 # öğrenme oranı
F = np.full(80, yt.mean()) # başlangıç: ortalama
mse = lambda m: float(((y - F)[m] ** 2).mean()) # MSE (maske)
history = {'round': [0], 'loss': [mse(~val)],
'val_loss': [mse(val)]} # eğitim geçmişi
for tur in range(100):
r = yt - F[~val] # kalıntı (eğitim)
t, a, b = kutuk(r) # kalıntıya kütük
F += lr * np.where(T <= t, a, b) # küçültüp ekle
row = tur + 1, mse(~val), mse(val)
for k, v in zip(history, row): history[k].append(v)
kayip = history['loss']
print('kayıp', f'{kayip[0]:.1f} -> {kayip[-1]:.2f}')
print('oran', kayip[-1] / kayip[0])
vl = history['val_loss']; best = int(np.argmin(vl)) # erken durdurma
res = (y - F)[val] # doğrulama artıkları
r2 = 1 - (res ** 2).mean() / y[val].var() # doğrulamada R²
for k, v in [('loss', kayip[-1]), ('val_loss', vl[-1]),
('val_r2', r2), ('best_round', best)]:
print(f'{k:<11}{v:>9.3f}') # son ölçümler
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as f:
w = csv.writer(f); w.writerow(history) # satır başına bir tur
w.writerows(zip(*history.values()))
try:
import matplotlib.pyplot as plt # varsa grafik
for k in ('loss', 'val_loss'):
plt.plot(history['round'], history[k], label=k)
plt.yscale('log'); plt.legend(); plt.show()
except ImportError:
print('matplotlib yok: grafik atlandı')

Eğitim paneli

Eğitim çalıştırılıyor…

Sahnedeki her sayı, aynı algoritmanın tarayıcında yapılan gerçek çalıştırmasından gelir (sabit tohum, her seferinde aynı sonuç). Python kodunu kendi bilgisayarında çalıştırırsan rastgele başlangıçlar farklı olacağı için sayılar biraz değişebilir.

Veri seti

Tüm veri setleri →

Bu dersin kodu verisini kendi içinde üretir; indirilecek dosya yok. Kodu yine de aşağıda tarayıcında çalıştırabilirsin.

Kodu tarayıcıda çalıştırPython · NumPy · matplotlib · Pyodide

Python ve NumPy bu sayfada, tarayıcında çalışır (Pyodide). Kodu değiştirip yeniden çalıştırabilirsin; dersin veri setleri çalışma klasöründe hazır. Kod matplotlib kullanırsa grafikler çıktının altında görünür, yazdığı dosyalar (ör. egitim_gecmisi.csv) indirilebilir.

gradyan_artirma.pypython

import numpy as np
rng = np.random.default_rng(8)
T = np.sort(rng.uniform(-10, 50, 80))         # ortam sıcaklığı, °C
y = 62 - 30 * np.exp(-(T + 10) / 10)          # soğukta düşüş
y -= 0.04 * np.maximum(0, T - 30) ** 2        # sıcakta düşüş
y += rng.normal(0, 1.5, 80)                   # uçuş süresi, dk
val = np.arange(80) % 4 == 3                  # her 4. uçuş doğrulama
Tt, yt = T[~val], y[~val]                     # eğitim uçuşları
def kutuk(r):
    best = (np.inf, 0, 0, 0)
    for t in (Tt[1:] + Tt[:-1]) / 2:          # her eşik
        L = Tt <= t
        a, b = r[L].mean(), r[~L].mean()      # iki yaprak: ortalama
        e = ((r - np.where(L, a, b)) ** 2).sum()
        if e < best[0]: best = (e, t, a, b)
    return best[1:]
lr = 0.1                                      # öğrenme oranı
F = np.full(80, yt.mean())                    # başlangıç: ortalama
mse = lambda m: float(((y - F)[m] ** 2).mean())  # MSE (maske)
history = {'round': [0], 'loss': [mse(~val)],
           'val_loss': [mse(val)]}            # eğitim geçmişi
for tur in range(100):
    r = yt - F[~val]                          # kalıntı (eğitim)
    t, a, b = kutuk(r)                        # kalıntıya kütük
    F += lr * np.where(T <= t, a, b)          # küçültüp ekle
    row = tur + 1, mse(~val), mse(val)
    for k, v in zip(history, row): history[k].append(v)
kayip = history['loss']
print('kayıp', f'{kayip[0]:.1f} -> {kayip[-1]:.2f}')
print('oran', kayip[-1] / kayip[0])
vl = history['val_loss']; best = int(np.argmin(vl))  # erken durdurma
res = (y - F)[val]                            # doğrulama artıkları
r2 = 1 - (res ** 2).mean() / y[val].var()     # doğrulamada R²
for k, v in [('loss', kayip[-1]), ('val_loss', vl[-1]),
             ('val_r2', r2), ('best_round', best)]:
    print(f'{k:<11}{v:>9.3f}')                # son ölçümler
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as f:
    w = csv.writer(f); w.writerow(history)    # satır başına bir tur
    w.writerows(zip(*history.values()))
try:
    import matplotlib.pyplot as plt           # varsa grafik
    for k in ('loss', 'val_loss'):
        plt.plot(history['round'], history[k], label=k)
    plt.yscale('log'); plt.legend(); plt.show()
except ImportError:
    print('matplotlib yok: grafik atlandı')

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.

Nasıl çalışır

Başlangıç modeli düz bir çizgidir: bütün uçuşların ortalaması.
Kalıntı = gerçek − tahmin. Kare hatanın gradyanı tam olarak budur; adı buradan gelir.
Kalıntıya bir kütük uydurulur: tek eşik, iki yaprak, her yaprak kendi kalıntılarının ortalaması.
Kütük öğrenme oranıyla küçültülüp modele eklenir; sonra yeni kalıntılar hesaplanır. Basamaklar üst üste binerek eğriyi çizer.
Şunu dene: öğrenme oranını 1 yap. Model birkaç turda oturur ama gürültüyü de kovalar; 0,1 ile daha yavaş ve daha düzgün öğrenir.

Neden önemli

XGBoost, LightGBM ve CatBoost bu fikrin hızlı ve düzenlileştirilmiş hâlleridir; tablo verisinde Kaggle yarışmalarını yıllardır onlar kazanır. Robotik ve enerji sistemlerinde batarya ömrü, motor sıcaklığı ve arıza süresi tahmininde sık kullanılır.

ESOF 323, 11. hafta: robotlarda derin öğrenme →