6. ünite / 8

Eğit ve değerlendir: ridge, karar kütüğü ve dürüst doğrulama

Bir saat sonraki sıcaklığı ridge regresyonla tahmin et, "26 °C'yi aşacak mı?" sorusunu karar kütüğüyle sınıflandır; zaman serisini zamana göre böl ve "değişmez" tabanını geç.

Bu ünitenin sonunda

Standartlaştırılmış özelliklerle ridge regresyonu normal denklemlerle eğitmek
MAE, RMSE ve R² değerlerini yorumlamak ve persistence tabanıyla karşılaştırmak
Rastgele bölme, boşluklu zaman bölmesi ve kayan pencereli doğrulama arasındaki farkı açıklamak
Bir eşik sorusunu karar kütüğüyle sınıflandırıp doğruluğunu ölçmek

Ders notları

Tablo hazır; şimdi bir model seçip eğitiyoruz. Başlangıç için en dürüst seçim doğrusal modeldir: hızlıdır, ağırlıkları okunur ve mikrodenetleyiciye birkaç çarpmayla sığar (7. ünite). ML dersindeki doğrusal regresyon ve karar ağacı derslerinin aynısını burada gerçek sensör verisine uyguluyoruz.

Ridge regresyon

Özellikler önce standartlaştırılır (ortalama 0, σ 1), sonra (XᵀX + λI) w = Xᵀy denklemi çözülür. λ küçük bir cezadır: lag1, lag2 ve lag3 neredeyse aynı bilgiyi taşıdığı için ağırlıklar birbirini dengeleyen büyük sayılara kaçabilir; ceza onları makul tutar. Sabit terim cezalanmaz. Eğitimden sonra ağırlıklar ham ölçeğe geri çevrilir ki cihaz ölçekleme yapmadan y = w₀ + Σ wᵢxᵢ hesaplasın.

Ölçütler ve taban

MAE: ortalama mutlak hata, °C. "Ortalama kaç derece yanılıyorum?"
RMSE: büyük hataları daha çok cezalandırır; birimi yine °C.
R²: varyansın ne kadarını açıkladım? Günlük döngü yüzünden kolayca 0,95 çıkar, tek başına yanıltıcıdır.
Persistence tabanı: "bir saat sonra da şimdiki kadar olacak". Hiç eğitim gerektirmez. Modelin anlamı, bu tabanı ne kadar geçtiğidir.

beceri = 1 − RMSE_model / RMSE_taban

Sera verisinde, son %25'i test olarak ayırınca h = 6 için model RMSE yaklaşık 0,68 °C, persistence 1,24 °C çıkar: yaklaşık %45 beceri. h = 1 için fark küçüktür (0,34 ve 0,42): on dakika sonrası zaten şimdiye çok benzer.

Zaman serisini nasıl bölmeli?

Rastgele bölmede test satırının komşuları eğitimdedir; model "dün ile yarını" görmüş gibi olur. Zamana göre bölmede geçmişle eğitilir, gelecekle test edilir; ikisinin arasına ufuk kadar boşluk konur, çünkü eğitimin son satırının hedefi testin ilk satırlarına uzanır. Kayan pencereli doğrulama (walk-forward) bunu birkaç kez tekrarlar: her katta geçmişin tamamıyla eğit, hemen sonraki bloğu test et. Böylece tek bir şanslı günün sonucu yanıltmaz.

Sınıflandırma: karar kütüğü

Bazen soru sayı değil evet/hayırdır: "bir saat sonra 26 °C'yi aşacak mı?" Tek bölmeli karar ağacı (kütük) en iyi eşiği arar; sera verisinde seçtiği özellik şimdiki sıcaklıktır, eşik yaklaşık 24,8 °C ve test doğruluğu 0,94 civarıdır. Python kodundaki sade sürüm Gini yerine hata oranını küçülttüğü için biraz farklı bir eşik bulabilir. Sınıflar dengesizdir (sıcak saatler azdır): doğruluğun yanında kesinlik ve duyarlılığa da bak.

Simülasyon

Eğit ve değerlendir: regresyon ve sınıflandırma

Sıcaklığı h adım sonrası için doğrusal (ridge) modelle tahmin et ya da "1 saat sonra 26 °C'yi aşacak mı?" sorusunu karar kütüğüyle sınıflandır. Rastgele bölme, zamana göre bölme ve kayan pencereli doğrulamayı karşılaştır; "değişmez" tabanını geçebiliyor musun?

1 kat, 249 test örneği · model: MAE 0,546, RMSE 0,681 °C, R² 0,959 "Değişmez" tabanı: RMSE 1,239 °C

GörevDoğrulamaUfuk h60 dkRidge λ1,0

Kod

walk_forward.py: kayan pencereli doğrulama (Python)

import numpy as np

def walk_forward(n, folds, min_train, gap):
    block = (n - min_train) // folds
    for f in range(folds):
        start = min_train + f * block
        stop = n if f == folds - 1 else start + block
        train = np.arange(0, max(0, start - gap))   # geçmişin tamamı, boşluklu
        test = np.arange(start, stop)               # hemen sonraki blok
        yield train, test

def evaluate(X, y, now, fit, h):
    rows = []
    for train, test in walk_forward(len(y), 4, len(y) // 3, gap=h):
        model = fit(X[train], y[train])
        e = y[test] - model(X[test])
        base = y[test] - now[test]                  # persistence: "değişmez"
        rows.append((np.sqrt((e ** 2).mean()), np.sqrt((base ** 2).mean())))
    for k, (m, b) in enumerate(rows):
        print(f"fold {k}: model RMSE {m:.3f}  baseline {b:.3f}  skill {1 - m / b:+.0%}")
    return rows

stump.h: eğitilmiş karar kütüğü cihazda (C++)

// Python'da bulunan eşik buraya yapıştırılır
const float HOT_THRESHOLD = 24.81f;    // özellik: şimdiki sıcaklık

uint8_t willBeHot(float tempNow) {     // 1: bir saat içinde 26 °C üstü bekleniyor
  return tempNow > HOT_THRESHOLD ? 1 : 0;
}

void loop() {
  float t = readTemperature();
  if (willBeHot(t)) openWindowEarly();  // erken önlem: pencere şimdi aralanır
  delay(600000UL);                      // 10 dakika
}

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.

egitim.pypython

import numpy as np
D = np.genfromtxt('sera-sensorleri.csv', delimiter=',', names=True)  # 7 gün, 10 dakikada bir
T = D['sicaklik'].copy()
bad = ~np.isfinite(T) | (T > 60) | (T < -20)  # okunamayan ve imkansız değerler
i = np.arange(len(T))
T[bad] = np.interp(i[bad], i[~bad], T[~bad])  # doğrusal ara değerle doldur
def lag(x, k):                                # out[i] = x[i - k]
    out = np.full(len(x), np.nan)
    out[k:] = x[:-k]
    return out
hs = np.sin(2 * np.pi * D['saat'] / 24)       # saat döngüseldir: sin/cos çifti
hc = np.cos(2 * np.pi * D['saat'] / 24)
H = 6                                         # 1 saat sonrası
X = np.column_stack([T, lag(T, 1), lag(T, 2), lag(T, 3), lag(T, 6), hs, hc, D['isik'] / 1023])
y = np.full(len(T), np.nan)
y[:-H] = T[H:]
ok = np.isfinite(X).all(axis=1) & np.isfinite(y)
X, y, now = X[ok], y[ok], T[ok]               # now: persistence tabanı için
def fit_ridge(X, y, lam=1.0):
    mu, sd = X.mean(0), X.std(0) + 1e-9       # standartlaştır
    Z = np.column_stack([np.ones(len(X)), (X - mu) / sd])
    A = Z.T @ Z + lam * np.diag([0] + [1] * X.shape[1])  # sabit terim cezalanmaz
    w = np.linalg.solve(A, Z.T @ y)           # normal denklemler
    return lambda Xn: np.column_stack([np.ones(len(Xn)), (Xn - mu) / sd]) @ w
def scores(y, p):
    e = y - p
    return np.abs(e).mean(), np.sqrt((e ** 2).mean()), 1 - (e ** 2).sum() / ((y - y.mean()) ** 2).sum()
n = len(y)
cut = int(n * 0.75)
tr, te = np.arange(cut - H), np.arange(cut, n)  # zamana göre bölme, arada H satır boşluk
f = fit_ridge(X[tr], y[tr])
print("time split   MAE %.3f  RMSE %.3f  R2 %.3f" % scores(y[te], f(X[te])))
print("persistence  MAE %.3f  RMSE %.3f  R2 %.3f" % scores(y[te], now[te]))  # "değişmez" tabanı
idx = np.random.default_rng(7).permutation(n)  # rastgele bölme: zaman serisinde yanıltıcı
f2 = fit_ridge(X[idx[:cut]], y[idx[:cut]])
print("random split MAE %.3f  RMSE %.3f  R2 %.3f" % scores(y[idx[cut:]], f2(X[idx[cut:]])))
c = (y > 26).astype(int)                      # sınıf: 1 saat sonra 26 C üstü mü?
best = (1.0, 0.0)
for t in np.unique(X[tr, 0]):                 # karar kütüğü: tek eşik
    err = ((X[tr, 0] > t).astype(int) != c[tr]).mean()
    if err < best[0]:
        best = (err, t)
acc = ((X[te, 0] > best[1]).astype(int) == c[te]).mean()
print("stump: temp > %.2f -> hot, test accuracy %.3f" % (best[1], acc))

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.

Kendin dene

Simülasyonda regresyon kipinde ufku 6 yap ve önce rastgele bölmeyi, sonra zamana göre bölmeyi seç: RMSE nasıl değişti ve hangisine güvenirsin? Kayan pencereli doğrulamayı aç ve katlar arasındaki farkı yorumla. Modelin "değişmez" tabanını kaç yüzde geçtiğini yaz. Sonra sınıflandırma kipine geç: kütük hangi özelliği ve eşiği seçti, kesinlik ve duyarlılık kaç? Python kodunu çalıştırıp aynı karşılaştırmayı CSV üzerinde yap.

Laboratuvarda aç: DHT22

Sık yapılan hatalar

Zaman serisini rastgele bölüp çıkan hatayı rapor etmek: komşu satırlar eğitimde olduğu için sonuç iyimserdir.
Zaman bölmesinde boşluk bırakmamak: eğitimin son hedefleri test dönemine taşar.
Persistence tabanını hiç hesaplamamak: R² = 0,96 etkileyici görünür ama taban zaten 0,9'u veriyor olabilir.
Standartlaştırmanın ortalama ve σ değerlerini tüm veriden hesaplamak: test döneminin bilgisi eğitime sızar.

Yazılım mühendisliği bağlantısı

Değerlendirme kodu da üretim kodudur: bir hata, yanlış bir modeli sahaya gönderir.

Bölme fonksiyonları için özellik testleri yaz: "testteki her indeks eğitimdeki her indeksten en az h büyük".
Her deneyde veri sürümü, özellik listesi, bölme ve ölçütleri bir deney kaydına yaz; tekrarlanamayan bir sonuç sonuç değildir.
Modelin tabanı geçemediği durumda CI'ın kırmızıya dönmesi bir kabul ölçütüdür.

Kendini sına

Persistence tabanı neyi tahmin eder?
Zaman serisinde rastgele bölme neden yanıltıcıdır?
Model RMSE 0,68 °C, persistence 1,24 °C. Beceri yaklaşık kaçtır?
Ridge regresyondaki λ cezası ne işe yarar?

Bu üniteden sonra bitirme projesinde

Model ve dürüst değerlendirme: Özellik tablosu, sızıntı testi, ridge modeli; zamana göre bölme ve kayan pencereyle tabana karşı RMSE (G2, G3).

Parçalar ve ilgili sayfalar

S2DHT22