Makine Öğrenmesi / Başlangıç / Ders 03

Ders 03 · Başlangıç · ~60 dk

Yanlılık–varyans ve çapraz doğrulama

Sentetik bir yorulma deneyinin verisinde polinom derecesini seçerken, modelin görmediği partilerde ne kadar hata yapacağını dürüstçe ölçmeyi öğreneceğiz: yanlılık–varyans dengesi, k-katlı ve gruplu çapraz doğrulama, iç içe arama.

Bu derste öğrenecekleriniz

  • Az uyum ve aşırı uyumu eğitim ve doğrulama hatasından tanımak
  • Beklenen hatayı indirgenemez hata, yanlılık² ve varyansa ayırmak; Monte Carlo ile ölçmek
  • k-katlı çapraz doğrulamayı sıfırdan yazmak ve scikit-learn ile karşılaştırmak
  • Gruplu veride GroupKFold kullanmak; rastgele bölmenin iyimserliğini göstermek
  • Öğrenme ve doğrulama eğrilerini yorumlamak
  • GridSearchCV ile hiperparametre seçmek ve iç içe çapraz doğrulamayla dürüst hata raporlamak
Seviye
Başlangıç
Süre
~60 dk
Kütüphaneler
NumPy, scikit-learn, Matplotlib

1. Problem: yorulma ömrünü tahmin etmek

Bir krank mili, bir köprü bağlantısı ya da bir cephe ankrajı, akma dayanımının çok altındaki gerilmelerle de kırılabilir; yeter ki bu gerilmeler milyonlarca kez tekrarlansın. Bu olaya yorulma denir. Yorulma deneyinde numuneye sabit genlikli çevrimsel bir gerilme uygulanır ve kırılana kadar geçen çevrim sayısı $N$ kaydedilir. Farklı gerilme genliklerinde ($S_a$) yapılan deneyler, log–log eksenlerde S–N (Wöhler) eğrisini verir.

Yüksek gerilmelerde eğri yaklaşık bir doğrudur: $N \propto S_a^{-m}$ (Basquin bağıntısı). Belli bir gerilmenin altında eğri belirgin biçimde yataylaşır; birçok çelikte bu bölge yorulma sınırı olarak anılır. Geçişin olduğu yere diz noktası denir.

Yorulma ömrü doğası gereği saçılır. Aynı gerilmede denenen ve birbirinin aynısı görünen numunelerin ömrü birkaç kat farklı olabilir. Bu yüzden ömür logaritmik ölçekte incelenir: $\log_{10} N$'deki 0,2'lik bir fark, ömürde yaklaşık 1,6 katlık bir farka karşılık gelir ($10^{0{,}2} \approx 1{,}58$). Saçılmanın bir kısmı partiden gelir. Aynı döküm partisinden (heat) işlenen numuneler kimyasal bileşim, iç yapı ve yüzey durumu bakımından birbirine daha çok benzer. Bir partinin bütün numuneleri ortalamanın biraz üstünde ya da altında kalabilir.

Bu derste sentetik bir deney programı kullanıyoruz. Gizli “gerçek” eğri, diz noktasında yumuşakça kırılan iki eğimli bir Basquin doğrusudur:

$$ \begin{aligned} & \log_{10} N = \log_{10} N_d - m_1 u \\ & \qquad + (m_2 - m_1)\,\delta\,\ln\!\left(1 + e^{-u/\delta}\right) \end{aligned} $$ $$ u = \log_{10}\left(S_a / S_d\right) $$

Diz noktasının çok üstünde ($u \gg \delta$) son terim sıfıra gider ve eğim $-m_1$ olur. Çok altında ($u \ll -\delta$) logaritmik terim $-u/\delta$'ya yaklaşır ve eğim $-m_2$ olur. Seçtiğimiz değerler: $S_d$ = 200 MPa, $\log_{10} N_d = 6$, $m_1 = 5$, $m_2 = 25$, $\delta = 0{,}012$. Bir partinin bütün numunelerine ortak bir kayma $b_p \sim \mathcal N(0, \tau^2)$ eklenir, $\tau = 0{,}15$; her numuneye ayrıca parti içi saçılma $\varepsilon \sim \mathcal N(0, \sigma_w^2)$ gelir, $\sigma_w = 0{,}12$:

$$ y = f(x) + b_p + \varepsilon $$

Burada $x = \log_{10} S_a$ özellik, $y = \log_{10} N$ hedeftir. Yeni bir partiden gelen yeni bir numune için toplam saçılma $\sigma = \sqrt{\tau^2 + \sigma_w^2} = 0{,}192$ dekaddır. Hiçbir model bu indirgenemez hatanın (irreducible error) altına inemez.

Deney planı 170–400 MPa arasında, log ölçekte eşit aralıklı 18 gerilme düzeyinden oluşuyor. İç düzeylerin her birinde bir parti, eğrinin uçlarını sabitlemek için en düşük ve en yüksek düzeyde üçer parti deneniyor; her partiden 4 numune. Toplam 22 parti ve 88 numune geliştirme kümesini oluşturur. Rastgele gerilmelerde denenmiş 6 yeni parti (24 numune) ise test için ayrıldı. Veri sentetik olduğu için bir şey daha yapabiliyoruz: 1000 yeni partiden 4000 numunelik bir örneklem üretip her modelin gerçek genelleme hatasını ölçmek. Gerçek bir laboratuvarda bu imkân yoktur. Dersin amacı, eldeki 88 numuneden bu sayıya ne kadar dürüst yaklaşabileceğimizi görmek.

Mühendislik notu

Neden log N hedef, log S özellik?

Deneyde gerilme genliğini biz seçeriz; rastgele olan ömürdür. En küçük kareler ise hatanın yalnızca hedefte olduğunu varsayar (Ders 02'deki regresyon seyrelmesi uyarısı). Ayrıca ömür saçılması logaritmik ölçekte yaklaşık simetriktir; yorulma ömrü için log-normal dağılım yaygın bir varsayımdır. Bu yüzden modeli $\log N$'yi $\log S_a$'dan tahmin edecek biçimde kuruyoruz.

Dikkat

Bu veri neyi temsil etmiyor?

Veri sentetiktir ve parametreler yalnızca anlatım içindir; hiçbir malzemeyi, detay sınıfını ya da standart S–N eğrisini temsil etmez. Gerçek yorulma verisinde başka konular da vardır: belli bir çevrimde kırılmadan durdurulan numuneler (sansürlü veri, runout), gerilme düzeyine göre değişen saçılma, ortalama gerilme etkisi. En uzun ömürler burada 1,4×10⁸ çevrime çıkıyor; gerçek programlarda bu kadar uzun deneyler nadirdir. Tasarımda kullanılan S–N eğrileri yönetmeliklerin tarif ettiği yöntemlerle ve karakteristik (alt sınır) değerlerle belirlenir. Bu dersteki modeller yalnızca ortalama eğriyi tahmin eder.

Sorumuzu açıkça yazalım: yeni bir partiden gelen bir numunenin, 170–400 MPa aralığındaki herhangi bir gerilmede ömrü ne olur? Doğrulama yöntemini bu soru belirleyecek.

2. Model karmaşıklığı: az uyum ve aşırı uyum

Diz noktası yüzünden ilişki bir doğru değil. Esnek bir aday olarak $\log S_a$'nın polinomlarını deneyelim. Polinomu doğrudan $x$ ile değil, deney aralığını $[-1, 1]$'e taşıyan $z$ ile kuruyoruz:

$$ z = \frac{2x - (x_{\min} + x_{\max})}{x_{\max} - x_{\min}} $$ $$ \hat y = w_0 + w_1 z + w_2 z^2 + \dots + w_d z^d $$

Model parametrelerine göre hâlâ doğrusaldır: tasarım matrisinin sütunları $1, z, \dots, z^d$ olur ve çözüm, Ders 02'deki en küçük karelerin aynısıdır. Değişen tek şey derece $d$. Derece, modelin karmaşıklığını belirleyen bir hiperparametredir (hyperparameter): parametreler ($w_j$) veriden öğrenilir, hiperparametre ise öğrenmeden önce seçilir.

Polinom uydurma, sıfırdan (koddan)
def z(x):
    """log S'yi deney aralığında [−1, 1]'e taşır; yüksek derecede sayısal kararlılık için gerekli."""
    return (2 * x - (LO + HI)) / (HI - LO)


def polinom_uydur(x, y, derece):
    V = np.vander(z(x), derece + 1, increasing=True)         # sütunlar: 1, z, z², …, z^d
    w, *_ = np.linalg.lstsq(V, y, rcond=None)
    return w
Dikkat

Polinomu ölçeklenmemiş girdiyle kurmayın

$\log_{10} S_a$ değerleri 2,23 ile 2,60 arasında. Bu dar aralıkta $x^{11}$ ile $x^{12}$ neredeyse aynı sütundur. 12. derece Vandermonde matrisinin koşul sayısı $[-1, 1]$ ölçeğinde $4{,}1\times10^{4}$, ham $\log S_a$ ile $10^{19}$'un üstünde. Çift duyarlıklı sayılar yaklaşık 16 basamak taşır; bu büyüklükte bir koşul sayısının kendisi bile güvenilir biçimde hesaplanamaz ve çözümün bütün basamakları kaybolur (Hazırlık 2'deki koşul sayısı tartışması). scikit-learn'de bunun karşılığı, PolynomialFeatures'tan önce bir ölçekleyici koymaktır.

Dereceyi 1'den 12'ye kadar artırıp her polinomu geliştirme kümesinin tamamına uyduralım. Eğitim hatası (aynı 88 numune üzerindeki RMSE) derece 1'de 0,386, derece 4'te 0,146, derece 12'de 0,123 dekad: dereceyle hiç artmıyor. Artamaz da, çünkü $d$. derece polinomlar $(d+1)$. derecelerin içinde yer alır ($w_{d+1} = 0$ seçmek yeter); en küçük kareler minimumu ancak aynı kalabilir ya da düşebilir. Yeni 4000 numunedeki gerçek hata ise başka bir hikâye anlatıyor: 0,357'den başlıyor, derece 3–8 arasında 0,203–0,207 düzeyine iniyor ve derece 12'de 0,233'e çıkıyor.

  • Az uyum (underfitting): derece 1–2 diz noktasını temsil edemiyor. Hata hem eğitimde hem yeni veride yüksek; derece 1'de 0,386 ve 0,357.
  • Aşırı uyum (overfitting): yüksek derecelerde eğitim hatası düşmeyi sürdürürken gerçek hata yeniden artıyor. Model, bu veri kümesine özgü saçılmayı ve parti kaymalarını da öğrenmiştir; ezberlenen rastlantılar yeni partilerde tekrarlanmaz.

Sık duyulan bir kural, eğitim hatası indirgenemez hatanın (0,192) belirgin biçimde altına inen modelin ezberlediğini söyler. Bu kural kabadır. Bu veri kümesinde gizli gerçek eğrinin kendi eğitim RMSE'si 0,155, en iyi model olan derece 4'ünki 0,146; ikisi de 0,192'nin altında. Elimizdeki 22 partinin saçılması şans eseri beklenenden küçük; üstelik veriye uydurulan her model, gürültünün bir kısmını kaçınılmaz olarak soğurur. Aşırı uyumu gösteren tek bir eşik değil, eğitim hatası düşerken görülmemiş partilerdeki hatanın yükselmesidir.

Derece 1'de eğitim hatasının gerçek hatadan büyük çıkması ilk bakışta tuhaf görünebilir. Nedeni deney planı: doğrunun en çok yanıldığı iki uç düzey, planda üçer partiyle, yani üç kat ağırlıkla temsil ediliyor. Gerçek hatayı ise aralığa düzgün dağılmış gerilmelerde ölçüyoruz.

3. Yanlılık–varyans ayrışımı

Gerçek hata neden önce azalıp sonra artıyor? Cevap, hatanın üç parçaya ayrılmasında. Aynı deney planını tekrar tekrar uyguladığımızı düşünelim: her seferinde yeni partiler, yeni numuneler, dolayısıyla yeni bir veri kümesi $D$ ve yeni bir model $\hat f_D$. Belli bir $x_0$ noktasındaki tahmin, veri kümesine göre değişen rastgele bir değişkendir. Ortalamasına $\bar f(x_0) = \E_D[\hat f_D(x_0)]$ diyelim.

Türetme

Beklenen kare hatanın üç parçası

Yeni gözlem $y_0 = f(x_0) + e_0$ olsun; $\E[e_0] = 0$, $\mathrm{Var}(e_0) = \sigma^2$ ve $e_0$ eğitim verisinden bağımsız. Kısalık için $x_0$'ı ve $D$ alt indisini yazmayalım: $\hat f = \hat f_D(x_0)$. Beklenen değer hem $D$ hem $e_0$ üzerinden alınır:

$$ \begin{aligned} \E\big[(y_0 - \hat f)^2\big] &= \E\big[(e_0 + f - \hat f)^2\big] \\ &= \sigma^2 + \E\big[(f - \hat f)^2\big] \end{aligned} $$

Çapraz terim $2\,\E[e_0]\,\E[f - \hat f]$, bağımsızlık ve $\E[e_0] = 0$ yüzünden sıfırdır. İkinci terimde $\bar f$'yi ekleyip çıkaralım:

$$ \begin{aligned} \E\big[(f - \hat f)^2\big] &= \E\big[(f - \bar f + \bar f - \hat f)^2\big] \\ &= (f - \bar f)^2 \\ &\quad + \E\big[(\hat f - \bar f)^2\big] \end{aligned} $$

Yine çapraz terim sıfırdır, çünkü $\E[\bar f - \hat f] = 0$. Sonuç:

$$ \begin{aligned} \E\big[(y_0 - \hat f)^2\big] = {}& \sigma^2 + \big(\bar f - f\big)^2 \\ &+ \E\big[(\hat f - \bar f)^2\big] \end{aligned} $$

Üç terimin anlamı:

  • İndirgenemez hata $\sigma^2$: verideki saçılma. Yeni bir partiden yeni bir numune için $\sigma^2 = \tau^2 + \sigma_w^2$, yani $0{,}15^2 + 0{,}12^2 = 0{,}0369$ dekad².
  • Yanlılık² (bias²): ortalama modelin gerçek eğriden sistematik sapması. Esnekliği yetmeyen bir model, ne kadar veri verirseniz verin bunu azaltamaz.
  • Varyans (variance): modelin bir veri kümesinden ötekine ne kadar oynadığı. Esnek model verideki rastlantıları da öğrendiği için çok oynar.

Bu ifade tek bir $x_0$ içindir; aralık boyunca ortalamasını alınca beklenen test hatası elde edilir. Sentetik veride üç terimi doğrudan ölçebiliriz. Deney planını sabit tutup 200 veri kümesi ürettik, her birine 1–12. derece polinomları uydurduk ve 401 noktalı bir ızgarada ortalama modeli ve modelin dağılımını hesapladık. Tasarım matrisi bütün kümelerde aynı olduğu için 200 uydurma tek bir lstsq çağrısıyla yapılabiliyor:

Monte Carlo yanlılık–varyans, vektörleştirilmiş (koddan)
# Tasarım sabit; her sütun yeni partiler ve yeni saçılmayla çekilmiş bir veri kümesi: (88, 200)
Y = (log_omur(x)[:, None] + rng.normal(0.0, TAU, (n_parti, R))[parti]
     + rng.normal(0.0, SIGMA_W, (x.size, R)))
V = np.vander(z(x), d + 1, increasing=True)
W = np.linalg.lstsq(V, Y, rcond=None)[0]              # 200 uydurma tek seferde: (d+1, 200)
F = np.vander(z(x_izgara), d + 1, increasing=True) @ W   # (401, 200) tahmin
yanlilik2.append(np.mean((F.mean(axis=1) - f_izgara) ** 2))
varyans.append(np.mean(F.var(axis=1)))
200 veri kümesinden yanlılık², varyans ve beklenen test hatası (dekad²)
DereceYanlılık²Varyans$\sigma^2$ + yanlılık² + varyansMonte Carlo test MSE
10,08770,00190,12650,1273
20,03200,00280,07170,0722
30,00530,00400,04620,0466
40,00100,00530,04320,0434
60,00050,00870,04610,0465
80,00020,01170,04880,0492
100,00020,01690,05400,0545
120,00050,03310,07050,0708

Son iki sütun yüzde 1'den az farkla örtüşüyor. Ayrışım bir yaklaşıklık değil, bir özdeşliktir; küçük fark Monte Carlo örnekleme hatasıdır. Derece 1'de yanlılık² (0,0877) varyansın (0,0019) yaklaşık 46 katı: model az uyumlu. Derece 12'de tablo tersine dönüyor: yanlılık² 0,0005'e inmiş, varyans 0,0331'e çıkmış. Toplam hata en küçük değerini derece 4'te alıyor: 0,0432 dekad², yani RMSE ≈ 0,208.

Tabloda bir ayrıntı daha var: derece 4'ten sonra yanlılık² neredeyse sıfır ama toplamın büyük kısmı hâlâ $\sigma^2$ = 0,0369. Yeni bir numunenin ömrünü tahmin ederken hatanın asıl kaynağı saçılmadır; model ancak geri kalan küçük payla oynayabilir. Bu pay bir tasarım kararında yine de önemlidir: eğrinin kendisindeki hata, $\sqrt{\text{yanlılık}^2 + \text{varyans}}$, derece 4'te 0,079 dekad, derece 12'de 0,183 dekad.

Kendiniz deneyin

Aşağıdaki denemede [0, 1] aralığında gizli, yumuşak bir eğriden gürültülü eğitim noktaları üretilir; noktalar bağımsızdır, parti etkisi yoktur. Sol grafikte veri ve uydurulan polinom, sağ grafikte 1–15 arası bütün dereceler için eğitim RMSE'si (mavi) ve 200 noktalık doğrulama kümesindeki RMSE (turuncu) logaritmik eksende görünür; seçili derece dikey çizgiyle işaretlidir. Denemedeki “Ridge λ”, 6. ve 7. bölümlerde $\alpha$ dediğimiz cezanın aynısıdır.

  • Derece 15'te Yeni örneklem düğmesine birkaç kez basın: eğri her seferinde başka yerde salınır. Bu varyanstır. Derece 1'de ise eğri hep aynı yanlışı yapar: yanlılık.
  • Eğitim noktası sayısını 20'den 80'e çıkarın. Okuma kutusundaki “doğrulamaya göre en iyi derece” nasıl değişiyor?
  • Derece 15'te Ridge λ'yı 10⁻⁶'dan 1'e doğru artırın. Doğrulama RMSE'si önce düşüp sonra yükseliyor mu? Bu, 6. bölümdeki doğrulama eğrisinin küçük bir örneği.

Bu etkileşimli deneme için tarayıcıda JavaScript açık olmalıdır.

4. Eğitim, doğrulama, test ve k-katlı çapraz doğrulama

Gerçek hayatta 4000 yeni numunemiz yok. Elimizdeki veriyi üç rol arasında paylaştırırız (Ders 01):

  • Eğitim kümesi: parametreleri ($w_j$) öğrenir.
  • Doğrulama kümesi: hiperparametreleri (derece, ceza) seçer.
  • Test kümesi: bütün seçimler bittikten sonra, bir kez, son modelin hatasını raporlar. Test kümesine bakarak bir karar verdiğiniz anda o artık bir doğrulama kümesidir (Alıştırma 4).

Tek bir doğrulama bölmesi küçük veride iki sorun yaratır: sonuç hangi numunelerin doğrulamaya düştüğüne çok bağlıdır ve verinin bir kısmı eğitime hiç katılmaz. k-katlı çapraz doğrulama (k-fold cross-validation) ikisini birden çözer. Veri $K$ kata bölünür; her kat sırayla doğrulama, kalanlar eğitim olur:

$$ \mathrm{CV}_K = \frac{1}{K}\sum_{k=1}^{K} \mathrm{RMSE}_k $$

$\mathrm{RMSE}_k$, $k$. kat dışarıda tutularak eğitilen modelin o kattaki hatasıdır. Her numune tam bir kez doğrulamada kullanılır. $K$ = 5 ya da 10 yaygın seçimlerdir. Çapraz doğrulama yalnızca seçim ve değerlendirme içindir: seçilen hiperparametrelerle son model, geliştirme verisinin tamamıyla yeniden eğitilir.

k-katlı çapraz doğrulama, sıfırdan (koddan)
def capraz_dogrulama(x, y, derece, kat):
    """kat[i]: i. numunenin doğrulamaya ayrıldığı kat. Katların RMSE ortalamasını döndürür."""
    hatalar = []
    for k in np.unique(kat):
        egitim, dogrulama = kat != k, kat == k
        w = polinom_uydur(x[egitim], y[egitim], derece)
        hatalar.append(rmse(polinom_tahmin(w, x[dogrulama]), y[dogrulama]))
    return np.mean(hatalar)


K = 5
kat_rastgele = rng.permutation(np.arange(x.size) % K)    # numuneleri katlara rastgele dağıt
kat_grup = (np.arange(n_parti) % K)[parti]               # partileri katlara dağıt (parti bölünmez)

scikit-learn'de bölme işini bir bölücü (splitter) nesnesi yapar; cross_val_score her kat için modeli eğitir ve skoru döndürür. Model, ölçekleyicileri de içeren bir Pipeline'dır. Böylece ölçekleme her katta yalnız o katın eğitim verisinden öğrenilir:

scikit-learn karşılığı (koddan, kısaltılmış)
model = Pipeline([
    ("olcek_x", MinMaxScaler(feature_range=(-1, 1))),     # z(x) ile aynı iş
    ("poly", PolynomialFeatures(derece, include_bias=False)),
    ("olcek", StandardScaler()),
    ("reg", LinearRegression()),
])
kfold = KFold(n_splits=5, shuffle=True, random_state=42)
gkfold = GroupKFold(n_splits=5)
cross_val_score(model, X, y, cv=kfold, scoring="neg_root_mean_squared_error")
cross_val_score(model, X, y, groups=parti, cv=gkfold, scoring="neg_root_mean_squared_error")

scikit-learn skorları “büyük olan iyi” kuralına göre tanımlar; bu yüzden RMSE eksi işaretle döner. Kendi fonksiyonumuz, partileri sırayla dağıtan GroupKFold(5) ile aynı katları kurar ve aynı sonucu verir: derece 4 için 0,1772 dekad. Aynı fonksiyon, numuneleri rastgele dağıtan kat_rastgele ile 0,1472 veriyor; bu farkın nedenini 5. bölümde göreceğiz.

Tekrarlı k-katlı doğrulama. CV tahmini, verinin katlara nasıl bölündüğüne de bağlıdır. RepeatedKFold(n_splits=5, n_repeats=10) bölmeyi 10 farklı rastgele karıştırmayla yapar; sonuçların ortalaması bu rastlantıyı törpüler. Derece 4 için tekrarlar 0,149 ile 0,159 arasında, ortalama 0,154. Aynı deneyi gruplu bölmeyle, GroupKFold(5, shuffle=True, random_state=s) ile yaptığımızda aralık genişliyor: 0,156–0,188, ortalama 0,176. Nedeni basit: gruplu doğrulamada bağımsız birim sayısı numune sayısı (88) değil, parti sayısıdır (22).

Başka bölme şemaları da var:

  • Birini dışarıda bırak (leave-one-out, LOO): $K = n$. Eğitime neredeyse bütün veri girer, ama $n$ kez eğitim gerekir ve tahmin oynaktır. En küçük karelerde tek uydurmayla hesaplanabilir (Alıştırma 5). LOO da tek tek numune bıraktığı için gruplu veride rastgele KFold'un tuzağına düşer; grup karşılığı LeaveOneGroupOut'tur (Alıştırma 2).
  • Tabakalı (stratified) k-katlı: sınıflandırmada her katta sınıf oranlarını korur (StratifiedKFold). Az görülen bir sınıf, örneğin “hasarlı” etiketi, bazı katlarda hiç bulunmaz olmasın diye kullanılır. Ders 05'te kullanacağız.
  • Zaman serisi bölmesi: geçmişi tahmin etmek için gelecek kullanılamaz. TimeSeriesSplit her katta geçmişle eğitir, hemen ardından gelen dönemle doğrular. Rastgele KFold zaman serisinde geleceği eğitime sızdırır; XGBoost zaman serisi projesinde bu yüzden zaman sırası korunuyor.

5. Gruplu veri: rastgele bölme neden fazla iyimser?

Rastgele KFold bir partinin dört numunesini katlara gelişigüzel dağıtır; çoğu zaman farklı katlara düşerler. Bir numune doğrulamadayken, aynı partiden ve aynı gerilme düzeyinde denenmiş “kardeşleri” çoğu zaman eğitimdedir. Esnek bir model o düzeydeki ortalamayı, yani partinin kaymasını da öğrenir ve doğrulama numunesini adeta tanır. Oysa sorumuz yeni bir partiyle ilgili ve yeni partinin kayması hiçbir yerde görülmedi. GroupKFold bir partinin bütün numunelerini aynı kata koyar ve bu durumu taklit eder. Kodda fark tek satırdır: cv=kfold yerine groups=parti, cv=gkfold.

Aynı veri kümesinde dört hata ölçüsü (RMSE, dekad)
DereceEğitimKFoldGroupKFoldGerçek hata
10,3860,3840,3970,357
20,2700,2770,2840,269
30,1780,1870,1920,207
40,1460,1540,1770,205
60,1420,1500,2030,203
80,1350,1480,2350,207
100,1230,1370,2450,230
120,1230,1481,3010,233

KFold eğrisi neredeyse eğitim eğrisinin bir kopyası. En küçük değeri derece 10'da: 0,137. Bu modelin gerçek hatası 0,230, yani KFold tahmini gerçeğin yüzde 40 altında. GroupKFold'un en küçük değeri ise derece 4'te: 0,177; bu modelin gerçek hatası 0,205.

GroupKFold tahmini de gerçek hatanın altında kaldı. Bunun nedeni elimizdeki 22 partinin kendisi: ortalama sapmalarının standart sapması 0,136, beklenen değer ise 0,162. Bu partiler, partilerin genelinden biraz daha “uslu” çıkmış. Hiçbir doğrulama yöntemi, eldeki partilerin taşıdığından fazla bilgi üretemez.

Tek veri kümesi şanslı ya da şanssız olabilir. Bu yüzden karşılaştırmayı 200 veri kümesinde tekrarladık. KFold en sık 12. ve 11. dereceleri seçiyor; seçtiği modelin CV tahmini ortalama 0,169, gerçek hatası 0,255. GroupKFold en sık 4. ve 3. dereceleri seçiyor; tahmin 0,204, gerçek hata 0,217. KFold yalnızca iyimser değil, yanlış modeli de seçtiriyor.

GroupKFold'un da bir zaafı var: yüksek derecelerde kötümserdir. 200 kümenin ortalamasında derece 12 için GroupKFold 0,898 diyor, gerçek hata 0,263. Her katta 4–5 parti, dolayısıyla 4–5 gerilme düzeyi eğitimden çıkıyor ve yüksek dereceli polinom bu boşluklarda salınıyor. Tam veriyle eğitilen son modelde bu boşluklar yok. Bu kötümserlik seçim için zararsızdır, çünkü kırılgan modeli cezalandırır. Uç düzeylere üçer parti koymamızın bir nedeni de bu: hiçbir katta en düşük ya da en yüksek düzey tamamen dışarıda kalmıyor, böylece katlardaki modeller dış değer (extrapolation) yapmak zorunda kalmıyor.

Mühendislik notu

Mühendislik verisinde gruplar nerede?

Aynı kaynaktan gelen ve bu yüzden birbirine benzeyen ölçümler bir grup oluşturur: aynı döküm partisi ya da levha, aynı deney makinesi ya da deney günü, aynı yapıdan alınan karot numuneleri, aynı binadaki sensörler, aynı santralden gelen beton. Model yeni bir gruba uygulanacaksa doğrulama da grup bazında yapılmalıdır. Test kümesini ayırırken de aynı kural geçerlidir: GroupShuffleSplit grupları bölünmeden ayırır. En katı biçimi her grubu tek başına dışarıda bırakan LeaveOneGroupOut'tur.

6. Öğrenme eğrisi ve doğrulama eğrisi

Öğrenme eğrisi (learning curve), eğitim ve doğrulama hatasını eğitim verisinin miktarına göre çizer ve “daha çok deney yapmak işe yarar mı?” sorusuna cevap arar. learning_curve, her CV katında eğitim kümesinin giderek büyüyen alt kümeleriyle model eğitir. İki uç modeli karşılaştıralım (GroupKFold, 20'den 68 numuneye):

  • Derece 1: eğitim hatası 0,355'ten 0,384'e çıkıyor, doğrulama hatası 0,426'dan 0,396'ya iniyor. İki eğri yüksek bir düzeyde birleşmiş. Bu, yüksek yanlılığın imzasıdır: daha çok numune eklemek bir şey değiştirmez, model esnekleşmelidir.
  • Derece 8: eğitim hatası 0,087'den 0,125'e, doğrulama hatası 1,276'dan 0,236'ya. Aradaki açıklık büyük ama veri arttıkça kapanıyor. Bu, yüksek varyansın imzasıdır: daha çok veri ya da daha sade bir model yardımcı olur.

Eğitim hatasının veri arttıkça arttığına dikkat edin: az sayıda numuneyi ezberlemek kolaydır. Yatay eksen numune sayısı olsa da gruplu veride asıl belirleyici parti sayısıdır (Alıştırma 3).

Doğrulama eğrisi (validation curve) ise tek bir hiperparametreyi tarar. Dereceyi 12'de sabit tutup polinoma bir Ridge cezası ekleyelim:

$$ \min_{w_0,\,\vect w}\ \lVert \vect y - w_0 - \Phi\vect w \rVert^2 + \alpha \lVert \vect w \rVert^2 $$

$\Phi$ standartlaştırılmış polinom özelliklerinin matrisidir; sabit terim $w_0$ cezalandırılmaz. Ceza katsayısı $\alpha$ büyüdükçe katsayılar küçülür ve model sadeleşir. Ayrıntılar Ders 04'te. Sonuç: $\alpha = 10^{-8}$'de doğrulama hatası 1,144 (aşırı uyum), $\alpha = 1$'de 0,191 (en iyi), $\alpha = 10^{3}$'te 0,815 (az uyum). Düzenlileştirme, karmaşıklığı derece gibi kesikli bir ayar yerine sürekli bir düğmeyle kontrol eder.

7. Hiperparametre araması ve iç içe çapraz doğrulama

İki hiperparametreyi birlikte seçmek için GridSearchCV bütün kombinasyonları çapraz doğrulamayla dener. 12 derece ile üç ceza değerinin ($\alpha$ = 10⁻⁴, 1, 100) çarpımı 36 aday eder; her biri 5 katta sınanır. Sonuç: derece 4, $\alpha$ = 1, en iyi CV RMSE 0,174.

Bu 0,174'ü modelin performansı diye raporlamak cazip ama yanlıştır. 36 adayın her birinin CV hatası gürültülü bir tahmindir. En küçüğünü seçtiğimizde şanstan da yararlanırız; kazanan adayın skoru sistematik olarak iyimserdir. Buna seçim yanlılığı (selection bias) denir.

İç içe çapraz doğrulama (nested cross-validation) bütün seçim sürecini tek bir model gibi değerlendirir. Dış döngü veriyi katlara böler. Her dış katın eğitim kısmında bütün ızgara araması (iç döngü) yeniden yapılır ve seçilen model, aramanın hiç görmediği dış katta sınanır:

İç içe çapraz doğrulama (koddan)
izgara = {"poly__degree": list(range(1, 13)), "reg__alpha": [1e-4, 1.0, 100.0]}
for egitim, dogrulama in GroupKFold(5).split(X, y, parti):          # dış döngü: yalnız değerlendirme
    ic = GridSearchCV(model(4, alpha=1.0), izgara, cv=GroupKFold(4), scoring=RMSE_SKOR)
    ic.fit(X[egitim], y[egitim], groups=parti[egitim])                # iç döngü: yalnız seçim
    dis_hatalar.append(rmse(ic.predict(X[dogrulama]), y[dogrulama]))

Dış katların hataları 0,155, 0,187, 0,172, 0,236 ve 0,155; ortalama 0,181. İç aramalar dört katta (derece 4, $\alpha$ = 1), birinde (derece 6, $\alpha$ = 1) seçti; seçim süreci kararlı. Sayıları yan yana koyalım:

  • En iyi iç CV skoru: 0,174 (iyimser)
  • İç içe CV tahmini: 0,181
  • Test kümesi (6 parti): 0,173
  • Gerçek hata (1000 parti): 0,200

Seçim yanlılığı burada küçük (0,174'ten 0,181'e), çünkü adaylar birbirine çok benziyor ve ızgara küçük. Aday sayısı ve modelin esnekliği arttıkça bu fark büyür. Gerçek hataya kalan farkın nedeni yine elimizdeki 22 partinin şanslı olması. Altı partilik test kümesi de bu belirsizliğin dışında değil.

İç içe CV bir model seçmez; seçme yönteminin ne kadar iyi çalıştığını ölçer. Son model, GridSearchCV'nin seçilen ayarlarla geliştirme kümesinin tamamında yeniden eğittiği best_estimator_'dır. Bedeli hesaptır: burada 180 model ızgara araması, 720 model iç içe döngü için eğitildi.

8. Çalıştırılabilir kod

Kod sekiz bölümden oluşur: veri üretimi, sıfırdan polinom ve çapraz doğrulama, derece taraması, Monte Carlo yanlılık–varyans, tekrarlı CV, öğrenme ve doğrulama eğrileri, hiperparametre araması ve grafikler. Çalışma süresi bilgisayarınıza bağlı olarak 20–40 saniyedir; zamanın çoğunu iç içe çapraz doğrulama alır. Kurulum için Ders 01'deki adımları izleyin.

d03_capraz_dogrulama.py372 satır · Pythonİndir
"""Ders 03 — Yanlılık–varyans ve çapraz doğrulama.

Sentetik bir yorulma (S–N, Wöhler) deney programının verisinde polinom derecesini seçiyoruz.
Özellik log10(S_a), hedef log10(N). Veri sentetiktir: diz noktasında yumuşakça kırılan iki eğimli
bir Basquin eğrisi, döküm partisine özgü rastgele bir kayma ve parti içi saçılmayla üretilir.
Gerçek bir deney kaydı değildir; hiçbir malzemeyi, detay sınıfını ya da standart eğriyi temsil etmez.

Çalıştır:  python d03_capraz_dogrulama.py
Gerekenler: numpy, scikit-learn, matplotlib  (Python 3.12+)
Süre:      yaklaşık 20–40 s (iç içe çapraz doğrulama yaklaşık 900 model eğitir)
Çıktılar:  terminale sayılar, aynı klasöre dört PNG grafiği
"""
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.model_selection import (GridSearchCV, GroupKFold, KFold, RepeatedKFold, cross_val_score,
                                     learning_curve, validation_curve)
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler, PolynomialFeatures, StandardScaler
from matplotlib.ticker import FixedLocator, FuncFormatter, NullLocator

# --- Grafik stili (kurs genelinde aynı) ---
RENK = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"]
MUREKKEP, IKINCIL, SOLUK = "#0b0b0b", "#52514e", "#898781"
plt.rcParams.update({
    "figure.facecolor": "white", "axes.facecolor": "white", "savefig.facecolor": "white",
    "axes.edgecolor": "#c3c2b7", "axes.labelcolor": IKINCIL, "axes.titlecolor": MUREKKEP,
    "axes.titlesize": 11, "axes.titleweight": "bold", "axes.labelsize": 10,
    "xtick.color": IKINCIL, "ytick.color": IKINCIL, "font.size": 10,
    "axes.grid": True, "grid.color": "#e1e0d9", "grid.linewidth": 0.6,
    "axes.spines.top": False, "axes.spines.right": False,
    "axes.prop_cycle": plt.cycler(color=RENK), "lines.linewidth": 2, "legend.frameon": False,
})
KLASOR = Path(__file__).resolve().parent

# %% 1. Veri: sentetik S–N deney programı
S_DIZ, LOGN_DIZ = 200.0, 6.0      # MPa ve log10 N: iki asimptotun kesiştiği diz noktası
M1, M2 = 5.0, 25.0                # diz üstü ve altı ters eğim (N ∝ S^−m)
DELTA = 0.012                     # dizin yumuşaklığı (log10 S biriminde)
TAU, SIGMA_W = 0.15, 0.12         # partiler arası ve parti içi saçılma, log10 N (dekad)
LO, HI = np.log10(170.0), np.log10(400.0)   # deney aralığı: 170–400 MPa
SIGMA2 = TAU**2 + SIGMA_W**2      # yeni bir partiden yeni bir numunenin indirgenemez hatası


def log_omur(x):
    """Gizli 'gerçek' eğri: x = log10 S_a → log10 N (yumuşak dizli iki eğimli Basquin)."""
    u = x - np.log10(S_DIZ)
    return LOGN_DIZ - M1 * u + (M2 - M1) * DELTA * np.logaddexp(0.0, -u / DELTA)


def sn_verisi(parti_duzeyi, numune, rng):
    """Her döküm partisi kendi gerilme düzeyinde `numune` adet deneniyor."""
    n_parti = len(parti_duzeyi)
    x = np.repeat(parti_duzeyi, numune)
    parti = np.repeat(np.arange(n_parti), numune)
    kayma = rng.normal(0.0, TAU, n_parti)                     # partiye özgü kayma (parti etkisi)
    y = log_omur(x) + kayma[parti] + rng.normal(0.0, SIGMA_W, x.size)
    return x, y, parti


rng = np.random.default_rng(42)
duzey = np.linspace(LO, HI, 18)                    # log ölçekte eşit aralıklı 18 gerilme düzeyi
# İç düzeylerde birer parti; eğrinin uçlarını sabitlemek için en düşük ve en yüksek düzeyde üçer parti
parti_duzeyi = np.concatenate([np.repeat(duzey[:1], 3), duzey[1:-1], np.repeat(duzey[-1:], 3)])
x, y, parti = sn_verisi(parti_duzeyi, 4, rng)                    # geliştirme kümesi: 22 parti × 4
x_test, y_test, _ = sn_verisi(rng.uniform(LO, HI, 6), 4, rng)      # test: 6 yeni parti
x_ger, y_ger, _ = sn_verisi(rng.uniform(LO, HI, 1000), 4, rng)     # "gerçek hata": 1000 yeni parti
n_parti = parti_duzeyi.size
X, X_test = x[:, None], x_test[:, None]
print("=== 1. Veri ===")
print(f"Geliştirme: {n_parti} parti, {x.size} numune, {duzey.size} gerilme düzeyi "
      f"({10**LO:.0f}–{10**HI:.0f} MPa), ömür {10**y.min():.1e}–{10**y.max():.1e} çevrim")
print(f"Test: 6 yeni parti, {x_test.size} numune | 'Gerçek hata' örneklemi: 1000 parti, {x_ger.size} numune")
print(f"Saçılma: partiler arası {TAU}, parti içi {SIGMA_W} → indirgenemez hata σ = {np.sqrt(SIGMA2):.3f} dekad")
parti_ort = np.array([y[parti == p].mean() - log_omur(x[parti == p][0]) for p in range(n_parti)])
print(f"Bu {n_parti} partinin ortalama sapmalarının std'si: {parti_ort.std(ddof=1):.3f} "
      f"(beklenen {np.sqrt(TAU**2 + SIGMA_W**2 / 4):.3f})")
rmse_gercek_egri = np.sqrt(np.mean((log_omur(x) - y) ** 2))   # gizli eğrinin kendi "eğitim hatası"
print(f"Gizli gerçek eğrinin bu {x.size} numunedeki RMSE'si: {rmse_gercek_egri:.3f} dekad "
      f"(beklenen σ = {np.sqrt(SIGMA2):.3f})")


# %% 2. Sıfırdan: polinom uydurma ve k-katlı çapraz doğrulama
def z(x):
    """log S'yi deney aralığında [−1, 1]'e taşır; yüksek derecede sayısal kararlılık için gerekli."""
    return (2 * x - (LO + HI)) / (HI - LO)


def polinom_uydur(x, y, derece):
    V = np.vander(z(x), derece + 1, increasing=True)         # sütunlar: 1, z, z², …, z^d
    w, *_ = np.linalg.lstsq(V, y, rcond=None)
    return w


def polinom_tahmin(w, x):
    return np.vander(z(x), len(w), increasing=True) @ w


def rmse(a, b):
    return float(np.sqrt(np.mean((a - b) ** 2)))


def capraz_dogrulama(x, y, derece, kat):
    """kat[i]: i. numunenin doğrulamaya ayrıldığı kat. Katların RMSE ortalamasını döndürür."""
    hatalar = []
    for k in np.unique(kat):
        egitim, dogrulama = kat != k, kat == k
        w = polinom_uydur(x[egitim], y[egitim], derece)
        hatalar.append(rmse(polinom_tahmin(w, x[dogrulama]), y[dogrulama]))
    return np.mean(hatalar)


K = 5
kat_rastgele = rng.permutation(np.arange(x.size) % K)    # numuneleri katlara rastgele dağıt
kat_grup = (np.arange(n_parti) % K)[parti]               # partileri katlara dağıt (parti bölünmez)


def model(derece, alpha=None):
    """scikit-learn karşılığı. alpha=None → sıradan en küçük kareler, aksi hâlde Ridge."""
    return Pipeline([
        ("olcek_x", MinMaxScaler(feature_range=(-1, 1))),     # z(x) ile aynı iş
        ("poly", PolynomialFeatures(derece, include_bias=False)),
        ("olcek", StandardScaler()),
        ("reg", LinearRegression() if alpha is None else Ridge(alpha=alpha)),
    ])


RMSE_SKOR = "neg_root_mean_squared_error"     # scikit-learn skorları büyük-iyi; RMSE'nin eksisi
kfold, gkfold = KFold(n_splits=K, shuffle=True, random_state=42), GroupKFold(n_splits=K)
cv_sifirdan = capraz_dogrulama(x, y, 4, kat_grup)
cv_sklearn = -cross_val_score(model(4), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR).mean()
assert np.isclose(cv_sifirdan, cv_sklearn, rtol=1e-8)   # GroupKFold da partileri sırayla dağıtır
kosul_ham = np.linalg.cond(np.vander(x, 13, increasing=True))
kosul_olcekli = np.linalg.cond(np.vander(z(x), 13, increasing=True))
cv_rastgele = capraz_dogrulama(x, y, 4, kat_rastgele)    # aynı fonksiyon, numune bazında rastgele katlar
print("\n=== 2. Sıfırdan uygulamanın sağlaması ===")
print(f"Sıfırdan 5 katlı CV, derece 4: rastgele katlar {cv_rastgele:.4f}; gruplu katlar {cv_sifirdan:.4f} "
      f"= GroupKFold {cv_sklearn:.4f}")
print(f"Vandermonde koşul sayısı (derece 12): ham log S ile {kosul_ham:.1e}, "
      f"[−1, 1] ölçeğinde {kosul_olcekli:.1e}")

# %% 3. Derece taraması: eğitim, KFold, GroupKFold ve "gerçek" hata
dereceler = np.arange(1, 13)
egitim_h, kfold_h, grup_h, gercek_h, uydurmalar = [], [], [], [], {}
for d in dereceler:
    w = polinom_uydur(x, y, d)
    uydurmalar[d] = w
    egitim_h.append(rmse(polinom_tahmin(w, x), y))
    kfold_h.append(-cross_val_score(model(d), X, y, cv=kfold, scoring=RMSE_SKOR).mean())
    grup_h.append(-cross_val_score(model(d), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR).mean())
    gercek_h.append(rmse(polinom_tahmin(w, x_ger), y_ger))
egitim_h, kfold_h, grup_h, gercek_h = map(np.array, (egitim_h, kfold_h, grup_h, gercek_h))
assert np.all(np.diff(egitim_h) <= 1e-12)     # eğitim hatası dereceyle asla artmaz (iç içe modeller)

# %% 4. Yanlılık–varyans: aynı deney planıyla 200 veri kümesi (Monte Carlo)
R = 200
x_izgara = np.linspace(LO, HI, 401)                      # değerlendirme: aralığa düzgün yayılmış gerilmeler
f_izgara = log_omur(x_izgara)
# Tasarım sabit; her sütun yeni partiler ve yeni saçılmayla çekilmiş bir veri kümesi: (88, 200)
Y = (log_omur(x)[:, None] + rng.normal(0.0, TAU, (n_parti, R))[parti]
     + rng.normal(0.0, SIGMA_W, (x.size, R)))
y_yeni = f_izgara[:, None] + rng.normal(0.0, np.sqrt(SIGMA2), (x_izgara.size, R))   # yeni partiler
kat_mc = rng.permutation(np.arange(x.size) % K)          # KFold katları (hız için tüm kümelerde aynı)


def toplu_cv(V, Y, kat):
    """Aynı katlarla 200 veri kümesinin CV hatası; her kat tek bir lstsq ile (sütunlar ayrı kümeler)."""
    h = []
    for k in range(K):
        e, t = kat != k, kat == k
        W = np.linalg.lstsq(V[e], Y[e], rcond=None)[0]
        h.append(np.sqrt(np.mean((V[t] @ W - Y[t]) ** 2, axis=0)))
    return np.mean(h, axis=0)


yanlilik2, varyans, mc_test = [], [], []
mc_kfold, mc_grup, mc_gercek, ornek_egriler = [], [], [], {}
for d in dereceler:
    V = np.vander(z(x), d + 1, increasing=True)
    W = np.linalg.lstsq(V, Y, rcond=None)[0]              # 200 uydurma tek seferde: (d+1, 200)
    F = np.vander(z(x_izgara), d + 1, increasing=True) @ W   # (401, 200) tahmin
    yanlilik2.append(np.mean((F.mean(axis=1) - f_izgara) ** 2))
    varyans.append(np.mean(F.var(axis=1)))
    mc_test.append(np.mean((F - y_yeni) ** 2))
    mc_gercek.append(np.sqrt(SIGMA2 + np.mean((F - f_izgara[:, None]) ** 2, axis=0)))
    mc_kfold.append(toplu_cv(V, Y, kat_mc))
    mc_grup.append(toplu_cv(V, Y, kat_grup))
    if d in (1, 12):
        ornek_egriler[d] = F[:, :15]
yanlilik2, varyans, mc_test = map(np.array, (yanlilik2, varyans, mc_test))
mc_kfold, mc_grup, mc_gercek = map(np.array, (mc_kfold, mc_grup, mc_gercek))   # (12, 200)
toplam = SIGMA2 + yanlilik2 + varyans
assert np.allclose(toplam, mc_test, rtol=0.03)            # ayrışım, Monte Carlo test hatasıyla tutarlı
secim_k, secim_g = mc_kfold.argmin(axis=0), mc_grup.argmin(axis=0)
sutun = np.arange(R)

print("\n=== 3–4. Derece taraması (RMSE, dekad) ve yanlılık–varyans (MSE, dekad², 200 veri kümesi) ===")
print("derece  eğitim  KFold  GroupKFold  gerçek | yanlılık²  varyans  σ²+y²+v  MC test")
for i, d in enumerate(dereceler):
    print(f"{d:6d}  {egitim_h[i]:6.3f}  {kfold_h[i]:5.3f}  {grup_h[i]:10.3f}  {gercek_h[i]:6.3f} | "
          f"{yanlilik2[i]:9.4f}  {varyans[i]:7.4f}  {toplam[i]:7.4f}  {mc_test[i]:7.4f}")
print("--- 200 veri kümesinde KFold ve GroupKFold ---")
for ad, cv, secim in [("KFold     ", mc_kfold, secim_k), ("GroupKFold", mc_grup, secim_g)]:
    sayim = np.bincount(secim + 1, minlength=13)[1:]
    en_sik = np.argsort(sayim)[::-1][:2] + 1
    print(f"{ad}: en sık seçilen dereceler {en_sik[0]} ve {en_sik[1]}; seçilen modelin CV tahmini "
          f"{cv[secim, sutun].mean():.3f}, gerçek hatası {mc_gercek[secim, sutun].mean():.3f}")
print(f"Ortalama eğriler, derece 4 / 12: KFold {mc_kfold[3].mean():.3f} / {mc_kfold[11].mean():.3f}, "
      f"GroupKFold {mc_grup[3].mean():.3f} / {mc_grup[11].mean():.3f}, "
      f"gerçek {mc_gercek[3].mean():.3f} / {mc_gercek[11].mean():.3f}")

# %% 5. Tekrarlı çapraz doğrulama: katlara bölmenin rastgeleliği
rkf = RepeatedKFold(n_splits=5, n_repeats=10, random_state=42)
tekrarli = -cross_val_score(model(4), X, y, scoring=RMSE_SKOR, cv=rkf).reshape(10, 5).mean(axis=1)
grup_tekrar = np.array([-cross_val_score(model(4), X, y, groups=parti, scoring=RMSE_SKOR,
                                         cv=GroupKFold(5, shuffle=True, random_state=s)).mean()
                        for s in range(10)])
print("\n=== 5. Tekrarlı çapraz doğrulama (derece 4, 10 tekrar) ===")
print(f"RepeatedKFold     : tekrarlar {tekrarli.min():.3f}–{tekrarli.max():.3f}, ortalama {tekrarli.mean():.3f}")
print(f"GroupKFold (karış.): tekrarlar {grup_tekrar.min():.3f}–{grup_tekrar.max():.3f}, "
      f"ortalama {grup_tekrar.mean():.3f}")

# %% 6. Öğrenme eğrisi ve doğrulama eğrisi
ogrenme = {}
for d in (1, 8):
    egit, dogr = [], []
    for s in range(3):                     # alt örneklem seçimini üç tekrarla ortala
        boy, e_skor, d_skor = learning_curve(model(d), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR,
                                             train_sizes=np.linspace(0.3, 1.0, 6), shuffle=True, random_state=s)
        egit.append(-e_skor.mean(axis=1))
        dogr.append(-d_skor.mean(axis=1))
    ogrenme[d] = (boy, np.mean(egit, axis=0), np.mean(dogr, axis=0))
alfalar = np.logspace(-8, 3, 12)
e_skor, d_skor = validation_curve(model(12, alpha=1.0), X, y, groups=parti, cv=gkfold, scoring=RMSE_SKOR,
                                  param_name="reg__alpha", param_range=alfalar)
vc_egitim, vc_dogr = -e_skor.mean(axis=1), -d_skor.mean(axis=1)
i_alfa = vc_dogr.argmin()
print("\n=== 6. Öğrenme ve doğrulama eğrileri (GroupKFold) ===")
for d, (boy, eg, dg) in ogrenme.items():
    print(f"Derece {d:2d}: {boy[0]}→{boy[-1]} numune; eğitim {eg[0]:.3f}→{eg[-1]:.3f}, "
          f"doğrulama {dg[0]:.3f}→{dg[-1]:.3f}")
print(f"Doğrulama eğrisi (derece 12): α = 1e-8 → {vc_dogr[0]:.3f}, en iyi α = {alfalar[i_alfa]:.0e} → "
      f"{vc_dogr[i_alfa]:.3f}, α = 1e+3 → {vc_dogr[-1]:.3f}")

# %% 7. Hiperparametre araması ve iç içe çapraz doğrulama
izgara = {"poly__degree": list(range(1, 13)), "reg__alpha": [1e-4, 1.0, 100.0]}
arama = GridSearchCV(model(4, alpha=1.0), izgara, cv=GroupKFold(5), scoring=RMSE_SKOR)
arama.fit(X, y, groups=parti)
en_iyi = arama.best_params_
dis_hatalar, secimler = [], []
for egitim, dogrulama in GroupKFold(5).split(X, y, parti):          # dış döngü: yalnız değerlendirme
    ic = GridSearchCV(model(4, alpha=1.0), izgara, cv=GroupKFold(4), scoring=RMSE_SKOR)
    ic.fit(X[egitim], y[egitim], groups=parti[egitim])                # iç döngü: yalnız seçim
    dis_hatalar.append(rmse(ic.predict(X[dogrulama]), y[dogrulama]))
    secimler.append(f"({ic.best_params_['poly__degree']}, {ic.best_params_['reg__alpha']:g})")
son_model = arama.best_estimator_                                    # tüm geliştirme verisiyle yeniden eğitildi
test_rmse = rmse(son_model.predict(X_test), y_test)
gercek_rmse = rmse(son_model.predict(x_ger[:, None]), y_ger)
print("\n=== 7. Hiperparametre araması ve iç içe CV (GroupKFold) ===")
print(f"GridSearchCV: derece {en_iyi['poly__degree']}, α = {en_iyi['reg__alpha']:g}; "
      f"en iyi CV RMSE = {-arama.best_score_:.3f}")
print(f"İç içe CV (dış 5 × iç 4): katlar {' '.join(f'{h:.3f}' for h in dis_hatalar)} → "
      f"ortalama {np.mean(dis_hatalar):.3f}")
print(f"Dış katlarda seçilen (derece, α): {' '.join(secimler)}")
print(f"Son model: test RMSE (6 parti) = {test_rmse:.3f}, gerçek hata (1000 parti) = {gercek_rmse:.3f}")
assert np.isfinite([test_rmse, gercek_rmse, *dis_hatalar]).all()


# %% 8. Grafikler
def log_y(ax, isaretler):
    """Logaritmik y ekseni, okunaklı sabit işaretlerle (0.2, 0.3, … biçiminde)."""
    ax.set_yscale("log")
    ax.yaxis.set_major_locator(FixedLocator(isaretler))
    ax.yaxis.set_major_formatter(FuncFormatter(lambda v, _: f"{v:g}"))
    ax.yaxis.set_minor_locator(NullLocator())


def sn_ekseni(ax):
    ax.set_xscale("log")
    ax.set_yscale("log")
    ax.set_xlim(160, 420)
    ax.set_ylim(10**4.0, 10**8.6)
    ax.set_xticks([170, 200, 250, 300, 400], labels=["170", "200", "250", "300", "400"])
    ax.minorticks_off()
    ax.set(xlabel="Gerilme genliği $S_a$ (MPa)", ylabel="Kırılmaya kadar çevrim $N$")


S_izgara = 10**x_izgara
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].scatter(10**x, 10**y, s=14, color=SOLUK, alpha=.8, label="Numune (sentetik)")
for d, renk in [(1, RENK[1]), (4, RENK[0]), (12, RENK[2])]:
    ax[0].plot(S_izgara, 10**polinom_tahmin(uydurmalar[d], x_izgara), color=renk, lw=1.8, label=f"Derece {d}")
ax[0].plot(S_izgara, 10**f_izgara, color=MUREKKEP, ls="--", lw=1.2, label="Gizli gerçek eğri")
sn_ekseni(ax[0])
ax[0].set_title("Sentetik S–N verisi ve polinom uydurmaları")
ax[0].legend(loc="upper right", fontsize=9)
ax[1].plot(dereceler, egitim_h, "o-", color=RENK[0], ms=4, label="Eğitim")
ax[1].plot(dereceler, grup_h, "s-", color=RENK[1], ms=4, label="Doğrulama (GroupKFold)")
ax[1].plot(dereceler, gercek_h, color=MUREKKEP, ls="--", lw=1.4, label="Gerçek hata (1000 yeni parti)")
ax[1].axhline(np.sqrt(SIGMA2), color=SOLUK, ls=":", lw=1.4, label="İndirgenemez hata σ")
log_y(ax[1], [0.12, 0.15, 0.2, 0.3, 0.5, 1.0])
ax[1].set(xlabel="Polinom derecesi", ylabel="RMSE (dekad, log₁₀ N)", title="Az uyum ve aşırı uyum")
ax[1].set_xticks(dereceler)
ax[1].legend(loc="upper center", fontsize=9)
fig.savefig(KLASOR / "d03_capraz_dogrulama_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for d, renk in [(1, RENK[1]), (12, RENK[2])]:
    egriler = ornek_egriler[d]
    ax[0].plot(S_izgara, 10**egriler, color=renk, lw=0.7, alpha=.45)
    ax[0].plot([], [], color=renk, lw=1.5, label=f"Derece {d}: 15 farklı veri kümesi")
ax[0].plot(S_izgara, 10**f_izgara, color=MUREKKEP, ls="--", lw=1.4, label="Gizli gerçek eğri")
sn_ekseni(ax[0])
ax[0].set_title("Aynı plan, farklı veri kümeleri")
ax[0].legend(loc="upper right", fontsize=9)
ax[1].plot(dereceler, toplam, "o-", color=RENK[0], ms=4, label="σ² + yanlılık² + varyans")
ax[1].plot(dereceler, mc_test, "x", color=MUREKKEP, ms=7, mew=1.5, label="Monte Carlo test MSE")
ax[1].plot(dereceler, yanlilik2, "s-", color=RENK[1], ms=4, label="Yanlılık²")
ax[1].plot(dereceler, varyans, "^-", color=RENK[2], ms=4, label="Varyans")
ax[1].axhline(SIGMA2, color=SOLUK, ls=":", lw=1.4, label="σ² (indirgenemez)")
ax[1].set_yscale("log")
ax[1].set(xlabel="Polinom derecesi", ylabel="MSE (dekad²)", title="Yanlılık–varyans ayrışımı (200 küme)")
ax[1].set_xticks(dereceler)
ax[1].legend(loc="lower right", bbox_to_anchor=(1.0, 0.24), fontsize=8.5)
fig.savefig(KLASOR / "d03_capraz_dogrulama_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].plot(dereceler, mc_kfold.mean(axis=1), "^-", color=RENK[2], ms=4, label="KFold tahmini")
ax[0].plot(dereceler, mc_grup.mean(axis=1), "s-", color=RENK[1], ms=4, label="GroupKFold tahmini")
ax[0].plot(dereceler, mc_gercek.mean(axis=1), color=MUREKKEP, ls="--", lw=1.4, label="Gerçek hata")
log_y(ax[0], [0.15, 0.2, 0.3, 0.5, 0.8])
ax[0].set(xlabel="Polinom derecesi", ylabel="RMSE (dekad), 200 küme ortalaması",
          title="Hangi doğrulama gerçeği izliyor?")
ax[0].set_xticks(dereceler)
ax[0].legend(loc="upper center", fontsize=9)
genislik = 0.4
ax[1].bar(dereceler - genislik / 2, np.bincount(secim_g + 1, minlength=13)[1:], genislik, color=RENK[1],
          label="GroupKFold")
ax[1].bar(dereceler + genislik / 2, np.bincount(secim_k + 1, minlength=13)[1:], genislik, color=RENK[2],
          label="KFold")
ax[1].set(xlabel="Seçilen polinom derecesi", ylabel="Veri kümesi sayısı (200 içinden)",
          title="Seçilen derecenin dağılımı")
ax[1].set_xticks(dereceler)
ax[1].legend(loc="upper center", fontsize=9)
fig.savefig(KLASOR / "d03_capraz_dogrulama_3.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for d, renk in [(1, RENK[1]), (8, RENK[0])]:
    boy, eg, dg = ogrenme[d]
    ax[0].plot(boy, eg, "o-", color=renk, ms=4, label=f"Derece {d}, eğitim")
    ax[0].plot(boy, dg, "s--", color=renk, ms=4, label=f"Derece {d}, doğrulama")
log_y(ax[0], [0.1, 0.15, 0.2, 0.3, 0.5, 1.0])
ax[0].set(xlabel="Eğitimdeki numune sayısı", ylabel="RMSE (dekad)", title="Öğrenme eğrileri (GroupKFold)")
ax[0].legend(loc="upper right", fontsize=9)
ax[1].plot(alfalar, vc_egitim, "o-", color=RENK[0], ms=4, label="Eğitim")
ax[1].plot(alfalar, vc_dogr, "s-", color=RENK[1], ms=4, label="Doğrulama (GroupKFold)")
ax[1].plot(alfalar[i_alfa], vc_dogr[i_alfa], marker="*", ms=13, color=MUREKKEP, ls="none",
           label=f"En iyi α = {alfalar[i_alfa]:g}")
ax[1].set_xscale("log")
log_y(ax[1], [0.1, 0.15, 0.2, 0.3, 0.5, 1.0])
ax[1].set(xlabel="Ridge cezası α", ylabel="RMSE (dekad)", title="Doğrulama eğrisi: derece 12 + Ridge")
ax[1].legend(loc="upper center", fontsize=9)
fig.savefig(KLASOR / "d03_capraz_dogrulama_4.png", dpi=160)
plt.close(fig)
print("Grafikler kaydedildi: d03_capraz_dogrulama_1.png, _2.png, _3.png, _4.png")

Terminal çıktısıpython d03_capraz_dogrulama.py
=== 1. Veri ===
Geliştirme: 22 parti, 88 numune, 18 gerilme düzeyi (170–400 MPa), ömür 1.5e+04–1.4e+08 çevrim
Test: 6 yeni parti, 24 numune | 'Gerçek hata' örneklemi: 1000 parti, 4000 numune
Saçılma: partiler arası 0.15, parti içi 0.12 → indirgenemez hata σ = 0.192 dekad
Bu 22 partinin ortalama sapmalarının std'si: 0.136 (beklenen 0.162)
Gizli gerçek eğrinin bu 88 numunedeki RMSE'si: 0.155 dekad (beklenen σ = 0.192)

=== 2. Sıfırdan uygulamanın sağlaması ===
Sıfırdan 5 katlı CV, derece 4: rastgele katlar 0.1472; gruplu katlar 0.1772 = GroupKFold 0.1772
Vandermonde koşul sayısı (derece 12): ham log S ile 2.5e+19, [−1, 1] ölçeğinde 4.1e+04

=== 3–4. Derece taraması (RMSE, dekad) ve yanlılık–varyans (MSE, dekad², 200 veri kümesi) ===
derece  eğitim  KFold  GroupKFold  gerçek | yanlılık²  varyans  σ²+y²+v  MC test
     1   0.386  0.384       0.397   0.357 |    0.0877   0.0019   0.1265   0.1273
     2   0.270  0.277       0.284   0.269 |    0.0320   0.0028   0.0717   0.0722
     3   0.178  0.187       0.192   0.207 |    0.0053   0.0040   0.0462   0.0466
     4   0.146  0.154       0.177   0.205 |    0.0010   0.0053   0.0432   0.0434
     5   0.146  0.155       0.184   0.205 |    0.0009   0.0069   0.0448   0.0451
     6   0.142  0.150       0.203   0.203 |    0.0005   0.0087   0.0461   0.0465
     7   0.140  0.148       0.207   0.203 |    0.0002   0.0103   0.0474   0.0478
     8   0.135  0.148       0.235   0.207 |    0.0002   0.0117   0.0488   0.0492
     9   0.128  0.143       0.248   0.217 |    0.0002   0.0137   0.0507   0.0511
    10   0.123  0.137       0.245   0.230 |    0.0002   0.0169   0.0540   0.0545
    11   0.123  0.141       0.677   0.233 |    0.0002   0.0220   0.0591   0.0595
    12   0.123  0.148       1.301   0.233 |    0.0005   0.0331   0.0705   0.0708
--- 200 veri kümesinde KFold ve GroupKFold ---
KFold     : en sık seçilen dereceler 12 ve 11; seçilen modelin CV tahmini 0.169, gerçek hatası 0.255
GroupKFold: en sık seçilen dereceler 4 ve 3; seçilen modelin CV tahmini 0.204, gerçek hatası 0.217
Ortalama eğriler, derece 4 / 12: KFold 0.190 / 0.171, GroupKFold 0.212 / 0.898, gerçek 0.208 / 0.263

=== 5. Tekrarlı çapraz doğrulama (derece 4, 10 tekrar) ===
RepeatedKFold     : tekrarlar 0.149–0.159, ortalama 0.154
GroupKFold (karış.): tekrarlar 0.156–0.188, ortalama 0.176

=== 6. Öğrenme ve doğrulama eğrileri (GroupKFold) ===
Derece  1: 20→68 numune; eğitim 0.355→0.384, doğrulama 0.426→0.396
Derece  8: 20→68 numune; eğitim 0.087→0.125, doğrulama 1.276→0.236
Doğrulama eğrisi (derece 12): α = 1e-8 → 1.144, en iyi α = 1e+00 → 0.191, α = 1e+3 → 0.815

=== 7. Hiperparametre araması ve iç içe CV (GroupKFold) ===
GridSearchCV: derece 4, α = 1; en iyi CV RMSE = 0.174
İç içe CV (dış 5 × iç 4): katlar 0.155 0.187 0.172 0.236 0.155 → ortalama 0.181
Dış katlarda seçilen (derece, α): (4, 1) (4, 1) (4, 1) (6, 1) (4, 1)
Son model: test RMSE (6 parti) = 0.173, gerçek hata (1000 parti) = 0.200
Grafikler kaydedildi: d03_capraz_dogrulama_1.png, _2.png, _3.png, _4.png

9. Sonuçları yorumlayın

Solda log-log eksenlerde gerilme genliğine karşı kırılma çevrim sayısı: gri numune noktaları, kesikli gerçek eğri ve derece 1, 4, 12 polinomlar. Sağda polinom derecesine karşı eğitim, gruplu doğrulama ve gerçek RMSE eğrileri
Sol: sentetik S–N verisi (22 parti, 88 numune), gizli gerçek eğri (kesikli) ve üç polinom. Derece 1 diz noktasını kaçırıyor, derece 12 uçlarda salınıyor. Sağ: eğitim hatası dereceyle hep azalıyor; gruplu doğrulama ve gerçek hata önce azalıp sonra artıyor. Noktalı çizgi indirgenemez hata ($\sigma$ = 0,192 dekad).

Soldaki grafik, Wöhler diyagramının eksenleri yer değiştirmiş hâlidir: model, ömrü gerilmenin fonksiyonu olarak öğreniyor. Derece 1 doğrusu en düşük gerilmelerde ömrü küçük, diz civarında ise büyük tahmin ediyor. Derece 4 gerçek eğriyi izliyor. Derece 12 veriye daha yakın geçiyor ama 170 MPa civarında, iki gerilme düzeyi arasında gerçek eğrinin üstüne fırlıyor. Bu çıkıntının arkasında veri yok; yalnızca polinomun esnekliği var.

Sağdaki grafikte eğitim eğrisi (mavi) dereceyle sürekli iniyor ve indirgenemez hata çizgisinin altında kalıyor. Bu tek başına aşırı uyumun kanıtı değil; gizli gerçek eğri de bu numunelerde 0,155'lik bir eğitim hatası verir. Belirleyici olan, eğitim hatası inerken gruplu doğrulamanın (turuncu) ve gerçek hatanın yükselmeye başlaması. İkisi de U biçimli; gruplu doğrulama en küçük değerini derece 4'te alıyor.

Solda aynı deney planından üretilmiş 15 veri kümesine uydurulmuş birbirine yakın derece 1 doğruları ve birbirinden çok farklı salınan derece 12 eğrileri; sağda dereceye karşı yanlılık kare, varyans, toplam ve Monte Carlo test hatası, logaritmik eksende
Sol: aynı deney planından üretilmiş 15 farklı veri kümesine uydurulan derece 1 (turuncu) ve derece 12 (yeşil) polinomları. Sağ: 200 veri kümesinden yanlılık², varyans ve toplamları. Çarpılar Monte Carlo test hatası; toplam eğrisiyle örtüşüyor.

Soldaki grafik yanlılık ve varyansı gözle görülür kılıyor. Derece 1 doğruları birbirine çok yakın, yani varyans küçük; ama hepsi diz noktasını aynı biçimde kaçırıyor, yani yanlılık büyük. Derece 12 eğrilerinin ortalaması gerçek eğriyle çakışıyor, yani yanlılık küçük; ama her veri kümesinde başka yerde salınıyorlar, özellikle uçlarda. Sağdaki grafikte yanlılık² ile varyans ters yönlerde ilerliyor. Toplamın en düşük olduğu yer, ikisinin dengelendiği orta derecedir.

Solda 200 veri kümesi ortalamasında dereceye karşı KFold tahmini, GroupKFold tahmini ve gerçek hata; KFold sürekli azalıyor, GroupKFold U biçimli. Sağda her yöntemin seçtiği derecelerin çubuk grafiği: GroupKFold 3 ve 4'te, KFold 11 ve 12'de yoğunlaşıyor
Sol: 200 veri kümesinin ortalaması. KFold tahmini dereceyle azalmayı sürdürüyor ve gerçek hatanın altında kalıyor; GroupKFold orta derecelerde gerçek hataya yakın, yüksek derecelerde kötümser. Sağ: her veri kümesinde en küçük CV hatasını veren derece.

Bu grafik dersin ana mesajıdır. KFold eğrisi (yeşil) aşırı uyumu hiç görmüyor: derece arttıkça daha da iyimserleşiyor ve 200 kümenin çoğunda 11. ya da 12. dereceyi seçiyor. GroupKFold (turuncu) ise derece 4 civarında gerçek hatayı yakından izliyor ve seçimlerini 3–4. derecelerde topluyor. Hangi doğrulamanın doğru olduğu bir istatistik sorusu değil, bir mühendislik sorusudur: modeli nerede kullanacaksınız?

Solda eğitim numunesi sayısına karşı derece 1 ve derece 8 için eğitim ve doğrulama hata eğrileri; sağda Ridge ceza katsayısına karşı derece 12 polinomun eğitim ve doğrulama hatası, en iyi değer yıldızla işaretli
Sol: öğrenme eğrileri. Derece 1'de iki eğri yüksek bir düzeyde birleşiyor; derece 8'de aradaki büyük açıklık veri arttıkça kapanıyor. Sağ: derece 12 polinomda Ridge cezasına göre doğrulama eğrisi; en iyi $\alpha$ = 1.

Öğrenme eğrileri iki farklı reçete yazıyor. Derece 1 için daha çok deney israftır; model değişmelidir. Derece 8 için ise daha çok veri yardımcı olur ama aynı etkiyi düzenlileştirmeyle bugünkü veriden de alabiliriz. Sağdaki doğrulama eğrisi tam bunu gösteriyor: 12. derece polinom, doğru cezayla 0,191'e iniyor.

10. Sık yapılan hatalar

  • Gruplu veride rastgele bölmek. Aynı partiden, aynı numuneden, aynı yapıdan gelen ölçümler hem eğitimde hem doğrulamada olursa tahmin iyimser çıkar ve aşırı esnek model seçilir. Bu dersteki fark: 0,137'ye karşı gerçek 0,230.
  • Test kümesiyle seçim yapmak. Test hatasına bakarak derece seçerseniz test hatası artık bir doğrulama hatasıdır ve iyimserdir (Alıştırma 4).
  • Ön işlemeyi çapraz doğrulamanın dışında yapmak. Ölçekleyiciyi, özellik seçimini ya da eksik değer doldurmayı bütün veriye uyguladıktan sonra CV yaparsanız doğrulama katlarının bilgisi eğitime sızar. Bütün adımları bir Pipeline'a koyun; cross_val_score ve GridSearchCV pipeline'ı her katta yeniden eğitir.
  • best_score_'u son performans diye raporlamak. Seçimin iyimserliğini içerir. İç içe CV ya da hiç dokunulmamış bir test kümesi kullanın.
  • CV tahminlerinin belirsizliğini unutmak. Gruplu tahmin, karıştırmaya göre 0,156 ile 0,188 arasında oynadı. Bu oynamadan küçük farklarla iki model arasında karar vermeyin.
  • Verinin olmadığı yerde modele güvenmek. Derece 12 polinom, iki gerilme düzeyi arasında hiçbir veriye dayanmayan bir çıkıntı yaptı. Hiçbir doğrulama, verinin olmadığı yerdeki davranışı tam olarak ölçemez; aralık dışında ise hiç ölçemez.

11. Alıştırmalar

Alıştırma 1KolayParti etkisi olmasaydı

Betikte TAU, SIGMA_W = 0.0, 0.192 yapın (toplam saçılma aynı kalsın, parti etkisi kalksın) ve çalıştırın. Çıktının 3–4. bölümündeki “200 veri kümesinde KFold ve GroupKFold” satırlarında iki yöntem arasındaki fark ne oluyor? Neden?

Çözümü göster

Fark neredeyse kayboluyor. KFold en sık 4. ve 7. dereceleri seçiyor; seçilen modelin CV tahmini 0,197, gerçek hatası 0,203. GroupKFold en sık 4. ve 6. dereceleri seçiyor; tahmin 0,197, gerçek hata 0,202. Derece 4'te ortalama eğriler: KFold 0,199, GroupKFold 0,201, gerçek hata 0,199.

Numuneler artık birbirinden bağımsız. Bir numunenin kardeşlerini eğitimde görmek, ona dair bir şey söylemiyor. Gruplu doğrulama polinom yüzünden değil, verinin grup yapısı yüzünden gerekliydi. GroupKFold'un yüksek derecedeki kötümserliği ise sürüyor (derece 12'de 0,557'ye karşı gerçek 0,219); çünkü katlardaki gerilme düzeyi boşlukları hâlâ orada.

Alıştırma 2KolayHer parti ayrı bir kat

GroupKFold(5) yerine LeaveOneGroupOut() kullanarak 1–12. dereceler için çapraz doğrulama hatasını hesaplayın. Hangi derece seçilir? Tahmin, GroupKFold'unkinden neden farklı?

Çözümü göster
from sklearn.model_selection import LeaveOneGroupOut
logo = [-cross_val_score(model(d), X, y, groups=parti, cv=LeaveOneGroupOut(),
                         scoring=RMSE_SKOR).mean() for d in dereceler]

En küçük değer yine derece 4'te: 0,161 (GroupKFold(5): 0,177, gerçek hata: 0,205). Her katta 22 partiden 21'i eğitimde kaldığı için boşluklar küçük ve tahmin daha az kötümser; derece 12'de 0,744 (GroupKFold: 1,301). Bedeli, her derece için 22 kez eğitim ve tek partilik katlardan gelen daha oynak bir tahmindir. İki yöntem de aynı dereceyi seçiyor.

Alıştırma 3OrtaDaha çok numune mi, daha çok parti mi?

Numune sayısını iki katına çıkarmanın iki yolunu deneyin: (a) her partiden 8 numune (sn_verisi(parti_duzeyi, 8, rng)), (b) her düzeyde iki kat parti (parti_duzeyi'yi np.repeat(..., 2) ile çoğaltın). İkisinde de 176 numune olur. Derece 4 için eğrinin kendisindeki hatayı, $\sqrt{\text{yanlılık}^2 + \text{varyans}}$, tablodan hesaplayıp karşılaştırın.

Çözümü göster

Derece 4 için yanlılık² üç durumda da 0,0010. Varyans ise asıl planda 0,0053, (a)'da 0,0050, (b)'de 0,0025. Eğrinin hatası sırasıyla 0,079, 0,077 ve 0,059 dekad. Numuneleri ikiye katlamak neredeyse hiçbir şey kazandırmıyor; partileri ikiye katlamak varyansı yarıya indiriyor.

Nedeni, bir gerilme düzeyindeki ortalamanın gürültüsü. $h$ parti ve partide $s$ numune varsa bu gürültünün varyansı $\tau^2/h + \sigma_w^2/(hs)$ olur. Asıl planda $0{,}0225 + 0{,}0036 = 0{,}0261$; (a)'da $0{,}0225 + 0{,}0018 = 0{,}0243$ (yüzde 7 az), (b)'de $0{,}01125 + 0{,}0018 = 0{,}0131$ (yüzde 50 az). Parti kayması aynı partinin numuneleri arasında ortalamayla yok olmaz. Yeni bir numunenin toplam hatası ise üç durumda da yakın: $\sqrt{0{,}0432}$, $\sqrt{0{,}0428}$ ve $\sqrt{0{,}0404}$, yani 0,208, 0,207 ve 0,201. Baskın olan saçılmadır. Deney planlarken ders: eğrinin kendisini daha iyi bilmek istiyorsanız tekrar sayısından çok parti sayısını artırın.

Alıştırma 4OrtaTest kümesiyle derece seçmek

Kodun 3. hücresinde (# %% 3) oluşturulan uydurmalar sözlüğündeki polinomların (en küçük kareler, derece 1–12) test kümesi RMSE'sini hesaplayın ve en küçük test hatasını veren dereceyi seçin. Seçtiğiniz modelin test hatası ile gerçek hatasını karşılaştırın.

Çözümü göster
test_h = [rmse(polinom_tahmin(uydurmalar[d], x_test), y_test) for d in dereceler]

Test hatası en küçük derece 2'de: 0,171. Ama derece 2'nin gerçek hatası 0,269; GroupKFold'un seçtiği derece 4'ün ise 0,205 (test hatası 0,182). Altı partilik test kümesi hem küçük hem şans eseri derece 2'ye uygun düşmüş. Seçim için kullanılınca test hatası iyimser bir doğrulama hatasına dönüşüyor: 0,171'e karşı 0,269. Test kümesi seçimden sonra, bir kez kullanılır.

Alıştırma 5ZorBirini dışarıda bırakmanın kısayolu

En küçük karelerde $\vect w = (V^\top V)^{-1}V^\top \vect y$ ve şapka matrisi $H = V(V^\top V)^{-1}V^\top$'dir. $i$. numune dışarıda bırakılarak eğitilen modelin o numunedeki hatasının $e_{(i)} = e_i/(1 - h_{ii})$ olduğunu gösterin ($e_i$ tam veriyle bulunan artık, $h_{ii}$ şapka matrisinin köşegeni). Sonra derece 4 için 88 ayrı uydurmayla bu formülü sayısal olarak karşılaştırın ve LOO RMSE'sini, $\sqrt{\tfrac1n\sum_i e_{(i)}^2}$, GroupKFold ile kıyaslayın.

Çözümü göster

$A = V^\top V$, $\vect b = V^\top \vect y$ ve $i$. satır $\vect v$ olsun; $h = \vect v^\top A^{-1}\vect v$. Satırı çıkarınca $A \to A - \vect v\vect v^\top$ ve $\vect b \to \vect b - \vect v y_i$ olur. Sherman–Morrison özdeşliği:

$$ (A - \vect v\vect v^\top)^{-1} = A^{-1} + \frac{A^{-1}\vect v\vect v^\top A^{-1}}{1 - h} $$

Bunu kullanıp $\hat y_i = \vect v^\top A^{-1}\vect b$ yazarsak, dışarıda bırakılan modelin tahmini:

$$ \begin{aligned} \vect v^\top \vect w_{(i)} &= \hat y_i - h\,y_i + \frac{h\,(\hat y_i - h\,y_i)}{1 - h} \\ &= \frac{\hat y_i - h\,y_i}{1 - h} \end{aligned} $$

Dolayısıyla $y_i - \vect v^\top \vect w_{(i)} = (y_i - \hat y_i)/(1 - h)$.

V = np.vander(z(x), 5, increasing=True)
H = V @ np.linalg.solve(V.T @ V, V.T)
e = y - V @ polinom_uydur(x, y, 4)
e_loo = e / (1 - np.diag(H))

88 ayrı uydurmayla bulunan hatalar formülle en fazla $1{,}3\times10^{-14}$ farklı: aynı sayılar. LOO RMSE 0,1544; $h_{ii}$ değerleri 0,041 ile 0,075 arasında ve toplamları 5, yani parametre sayısı. LOO, GroupKFold'un 0,177'sinden ve gerçek hatanın 0,205'inden belirgin biçimde küçük; KFold'un 0,154'üyle neredeyse aynı. Tek numune bıraktığı için o numunenin üç kardeşi hep eğitimde kalır. Kısayol hız kazandırır ama gruplu veride yanlış soruyu çok hızlı cevaplar.

Özet

Özet
  • Eğitim hatası karmaşıklıkla hep azalır; görülmemiş verideki hata ise önce azalır, sonra artar. Doğru karmaşıklık doğrulamayla seçilir.
  • Beklenen hata = indirgenemez hata + yanlılık² + varyans. Az uyumlu modelde yanlılık, aşırı uyumlu modelde varyans baskındır.
  • k-katlı çapraz doğrulama küçük veriyi verimli kullanır. Bölme şeması ise sorunuza uymalıdır: gruplu veride GroupKFold, zaman serisinde TimeSeriesSplit.
  • Rastgele bölme, gruplu veride hem iyimser bir hata verir hem de aşırı esnek modeli seçtirir.
  • En iyi CV skoru seçim yüzünden iyimserdir; dürüst bir sayı için iç içe CV ya da hiç dokunulmamış bir test kümesi kullanın.

Sonraki derste karmaşıklığı kontrol etmenin ikinci yolunu, düzenlileştirmeyi göreceğiz: Ridge ve Lasso cezaları, ölçeklemenin önemi ve beton dayanımı verisinde su/bağlayıcı oranı gibi anlamlı özelliklerin gücü.

Kaynaklar

  • T. Hastie, R. Tibshirani, J. Friedman — The Elements of Statistical Learning, 2. baskı, Bölüm 7 (model değerlendirme ve seçimi; yanlılık–varyans, çapraz doğrulama).
  • C. M. Bishop — Pattern Recognition and Machine Learning, Bölüm 3.2 (yanlılık–varyans ayrışımı).
  • G. C. Cawley, N. L. C. Talbot (2010) — On over-fitting in model selection and subsequent selection bias in performance evaluation, Journal of Machine Learning Research 11, 2079–2107.
  • scikit-learn — Cross-validation ve Tuning the hyper-parameters of an estimator belgeleri.