Karar Ağaçları ve Topluluk Yöntemleri
Geçen hafta bir modeli ölçmeyi öğrendik. Bu hafta ölçtüğümüz sayıyı yükseltmenin en pratik yoluna bakıyoruz. Yolun başı şaşırtıcı derecede basit: üst üste sorulan evet/hayır soruları. Sonu ise bugün tablo verisinde yarışmaların çoğunu kazanan yöntem — yüzlerce ağacın birlikte karar vermesi.
Kararını cümleyle yazabilen tek model
Bir banka kredi başvurunuzu reddetti. “Neden?” diye sordunuz. Üç farklı modelden üç farklı cevap gelebilir — ve aradaki fark bu haftanın konusu.
“Çıktı 0,31 geldi.”
Ağın içinde yüz binlerce ağırlık var. Hangisinin ne kadar katkı verdiğini söylemek ayrı bir araştırma konusu. Cevap doğru olabilir ama gerekçe yok.
“Size benzeyen 5 kişi reddedildi.”
1. haftada görmüştük. Gerekçe var ama genel bir kural yok: her başvuru için yeniden komşu aranır, yazıya dökülebilecek bir politika çıkmaz.
“Geliriniz 18.000 altında ve kredi geçmişiniz 2 yıldan kısa.”
Kararı üç cümleyle açıklanabilir. Kâğıda dökülebilir, müşteriye söylenebilir, hukuk birimi okuyabilir, yanlışsa hangi kuralın yanlış olduğu gösterilebilir.
Peki neden her yerde ağaç kullanmıyoruz? Çünkü tek bir ağaç kırılgandır: veriyi biraz değiştirin, ağaç baştan aşağı farklı çıkar. 7. bölümde bunu gözünüzle göreceksiniz. Çözüm, ağacı iyileştirmek değil — çok sayıda ağaç kurup oylama yapmak. İşte bu haftanın ikinci yarısı.
✔ Yapıyoruz: ağacın karar mekanizmasını elle çözmek, aşırı öğrenmeyi kaydıraçla görmek, topluluk mantığını kurmak, Kaggle'da dört modeli ölçüp karşılaştırmak.
✘ Yapmıyoruz: sinir ağları (7. hafta), regresyon ağaçlarının matematiği (9. haftada tahmin konusuna geldiğimizde), XGBoost'un iç matematiği — kütüphanenin yaptığını anlamak yeterli.
5. haftanın kontrol listesi bu hafta da geçerli: her yeni model için aynı soruları soracağız. Yeni bir algoritma öğrenmek, değerlendirme disiplininden muaf olmak demek değil.
Ağaç bir soru dizisidir
Tanımı tek satırda: karar ağacı, cevabı bulana kadar üst üste sorulan evet/hayır sorularıdır. Her soru veriyi ikiye böler; bölme bitince elde kalan kutuya bir etiket yazılır.
Aşağıdaki ağaç bir fabrikada makinenin arızalı olup olmadığını iki ölçümle tahmin ediyor: titreşim ve sıcaklık. Ağacı yukarıdan aşağıya okuyun; her satır bir soru, her renkli kutu bir cevap.
Bu ağacın anlattığı kural, tek bir cümleyle söylenemez. Söylenebilecek olan şudur: iki ölçümden yalnızca biri yüksekse makine arızalıdır. İkisi birden düşükse makine rölantide, ikisi birden yüksekse tam yükte — ikisi de normal.
Üç kelime: kök, dal, yaprak
İlk soru
Bütün veriyi gören tek soru. Ağacın en önemli sorusudur, çünkü en kalabalık kümeyi bölüyor. Kökteki soru değişirse altındaki her şey değişir.
Ara soru
Yalnızca kendisine düşen alt kümeyi görür. “Soğuk makineler” dalındaki soru, sıcak makineler hakkında hiçbir şey bilmez — bu yüzden her dal farklı bir eşik seçebilir.
Cevap
Artık soru sorulmayan kutu. İçindeki örneklerin çoğunluğunun etiketi yazılır. “%91 temiz” demek: o yaprakta 100 örnekten 91'i aynı sınıftan.
Ağacın bilmediği şeyler
| Ağaç bunu yapmaz | Neden önemli? |
|---|---|
| Eğik çizgi çizmez | Her soru tek bir sütuna bakar: sıcaklık ≤ 0,5. “Sıcaklık + titreşim > 1” gibi bir soru soramaz. Eğik bir sınırı merdiven basamaklarıyla taklit etmek zorundadır — ve bu yüzden gereksiz derin olur. |
| Ölçekleme istemez | 2. haftada öğrendiğimiz normalizasyon ağaç için gereksizdir. “Maaş ≤ 18.000” sorusu, maaş 0–1 arasına sıkıştırılsa da aynı sıralamayı verir. KNN için şart olan şey burada boşa emek. |
| Eksik veriden hoşlanmaz | scikit-learn'ün klasik ağacı NaN göremez; doldurmak size düşer. (HistGradientBoosting görebilir — 12. bölümde.) |
| Veri dışına çıkmaz | Eğitimde en yüksek maaş 40.000 ise, 400.000 maaşlı birine de aynı yaprağın cevabını verir. Ağaç ara değer bulur, uzağa tahmin yürütmez. |
Ağaç soruyu nasıl seçer?
Bir sütun ve bir eşik seçmek gerekiyor. Aday sayısı yüzlerce. Ağaç bunların arasından birini nasıl seçiyor? Cevap tek bir ölçüde: bölmeden sonra iki tarafın ne kadar tek-renk olduğu.
Bu ölçünün adı safsızlık (impurity). En yaygın hâli Gini ve formülü ürkütücü değil: bir kutudaki örneklerden rastgele ikisini çektiğinizde farklı sınıftan olma olasılığıdır.
Gini = 1 − p₁² − p₂² Hepsi aynı sınıf (10 geçti, 0 kaldı) → 1 − 1² − 0² = 0,000 ← tam temiz Tam yarı yarıya (5 geçti, 5 kaldı) → 1 − 0,5² − 0,5² = 0,500 ← en kötü hâl Çoğunluk var (8 geçti, 2 kaldı) → 1 − 0,8² − 0,2² = 0,320
İki sınıflı bir problemde Gini 0 ile 0,5 arasında gezer. 0 “bu kutu tek renk”, 0,5 “bu kutu tamamen karışık” demek. Ağacın tek işi şu: safsızlığı en çok düşüren soruyu bulmak.
26 öğrenci var. Yeşil noktalar geçenler, kırmızılar kalanlar; yatay eksen haftalık çalışma saati. Kaydıracı oynatarak “çalışma ≤ ?” sorusunun eşiğini değiştirin ve kazanç kutusunu izleyin. En yüksek kazancı bulduğunuzu düşündüğünüzde düğmeye basıp algoritmanın seçimiyle karşılaştırın.
Gini mi, entropi mi?
scikit-learn'de criterion ayarı iki değer alır: "gini" ve "entropy". İkisi de aynı soruyu sorar — “bu kutu ne kadar karışık?” — ve sonuçları neredeyse her zaman aynı ağacı verir. Entropi logaritma kullandığı için biraz yavaştır. Pratik tavsiye: varsayılanı (gini) değiştirmeyin; buradan kazanç çıkmaz. Kazanç, bir sonraki bölümün konusunda.
Ağaç nerede durmalı?
Kimse ağaca “dur” demezse ne olur? Durur — ama her yaprakta tek bir örnek kalınca. O noktada eğitim verisindeki doğruluğu %100'dür ve hiçbir şey öğrenmemiştir.
Bunu geçen hafta aşırı öğrenme adıyla gördük. Karar ağacında aşırı öğrenme soyut bir tehlike değil, çizilebilir bir şekil: ağaç derinleştikçe sınır, tek tek noktaların etrafını saran ince şeritlere dönüşür.
Fabrikadan 260 ölçüm. Yatay eksen titreşim, dikey eksen sıcaklık; koyu kırmızı noktalar arızalı makineler. Zemin rengi ağacın o bölgedeki kararı. Kaydıracı 1'den başlatıp yavaşça 12'ye çekin ve iki sayıyı birlikte izleyin — birinin ne zaman yükselmeye devam ettiğini, diğerinin ne zaman döndüğünü göreceksiniz.
Zemin: ağacın kararı · noktalar: eğitim verisi (■ sağlam · ■ arıza)
Üç hâl, üç teşhis
Eksik öğrenme
Tek bir çizgi. Bu veride %50 — yazı turadan farksız. Ağaç kuralı kavrayamıyor çünkü kural iki sorunun birlikteliğinde. Belirti: iki skor da düşük ve birbirine eşit.
Dengeli
Dört köşe doğru boyanmış, sınır veriyi üreten kuralın şeklinde. Eğitim ve sınav skoru birbirine yakın. Belirti: iki skor yüksek ve aradaki fark küçük.
Aşırı öğrenme
Eğitimde %100, görmediği veride çok daha az. Sınırda tek noktaları saran adacıklar var — bunlar kural değil, gürültünün ezberi. Belirti: skorlar arasında uçurum.
Labdaki “yaprakta en az kaç örnek” kaydıracını da oynatın: derinliği 12'de bırakıp bu sayıyı 1'den 15'e çekerseniz uçurumun nasıl kapandığını görürsünüz. İki ayar aynı işi iki farklı yerden yapıyor — bir sonraki bölümün konusu bu.
Budama: ağacı sınırlayan beş ayar
Ağaç kendi kendine durmaz, siz durdurursunuz. scikit-learn'de bunu yapan beş ayar var ve hepsi aynı şeyi söyler: “bir yaprakta tek örnek bırakma.”
| Ayar | Pratik başlangıç | Ne yapar, ne zaman işe yarar? |
|---|---|---|
| max_depth | 3 – 6 | Üst üste en fazla kaç soru sorulabileceğini sınırlar. En anlaşılır ayar. Okunabilirlik istiyorsanız 3–4'ün üstüne çıkmayın: derinlik 6'da 64 yaprak olabilir, kimse onu okumaz. |
| min_samples_leaf | 5 – 20 | Bir yaprakta en az kaç örnek kalmak zorunda. En etkili ayar. Tek örneklik yaprakları doğrudan yasakladığı için ezberi kökünden keser; derinliği serbest bıraksanız bile iş görür. |
| min_samples_split | 10 – 40 | Bir düğümün bölünebilmesi için en az kaç örnek içermesi gerektiği. Yaprak sınırına benzer, ama kararı bölmeden önce verir. |
| max_leaf_nodes | 8 – 32 | Toplam yaprak sayısına üst sınır. Derinlik yerine karmaşıklığı doğrudan sınırlamak istediğinizde kullanışlı: ağaç kazancı en yüksek dalları öncelikler. |
| ccp_alpha | 0,0 – 0,02 | Gerçek budama. Ağaç önce büyür, sonra “bu dalın getirdiği kazanç masrafına değiyor mu?” diye sorulup zayıf dallar kesilir. Diğerleri büyümeyi önceden durdurur; bu sonradan keser. |
“Ağaç bir yerde durmalı” fikrinin iki okunuşu
Pre-pruning
max_depth, min_samples_leaf, max_leaf_nodes. Hızlı, çünkü ağaç hiç büyümüyor. Riski: “şimdi kötü, iki adım sonra harika” olan dalı hiç görmeden kesersiniz — 3. bölümdeki aç gözlülük problemi.
Post-pruning
ccp_alpha. Ağaç sonuna kadar büyür, sonra kesilir. Daha iyi karar verir, çünkü dalın gerçek getirisini görmüştür. Riski: büyük veride büyümenin maliyeti.
from sklearn.tree import DecisionTreeClassifier
# Ezberlemeye hazir agac: hicbir sinir yok
serbest = DecisionTreeClassifier(random_state=42)
# Derste kullanacagimiz baslangic noktasi
makul = DecisionTreeClassifier(
max_depth=4, # en fazla 4 soru ust uste
min_samples_leaf=10, # her yaprakta en az 10 ornek
random_state=42 # ayni veriyle ayni agac cikar
)Öznitelik önemi — ve onu okumanın tuzağı
Ağaç size bedava bir rapor verir: hangi sütun ne kadar işe yaradı? Bu rapor çok faydalıdır ve çok sık yanlış okunur. Bu bölümün tamamı o yanlış okumayı önlemek üzerine.
Hesap basit: her bölmenin sağladığı safsızlık düşüşü, o bölmeye düşen örnek sayısıyla ağırlıklanır ve kullanılan sütunun hesabına yazılır. Sonunda toplam 1'e normalize edilir. scikit-learn'deki feature_importances_ tam olarak bu sayıdır.
onem[sutun] = Σ (o dugumdeki ornek orani) × (o dugumun safsizlik dususu)
dugumler
o sutunla bolunmus olanlar
Yani: "bu sutun, agacin bolme isine ne kadar katki yapti?"
Yani DEGIL: "bu sutun gercekten nedensel olarak etkili mi?"Aynı fabrika verisine iki anlamsız sütun ekledik: kayıt no (her ölçüm için üretilmiş benzersiz bir sayı) ve vardiya (zar atılarak seçilmiş 1/2/3). İkisi de arıza hakkında sıfır bilgi taşıyor. Şimdi aynı veriyle iki ağaç kuruyoruz ve her ikisinin önem raporuna bakıyoruz.
Pembe çubuklar, veride hiçbir karşılığı olmayan sütunlar.
Önem listesini okurken dört kural
Tek ağaç kırılgandır
Şimdi haftanın ikinci yarısına geçişi sağlayan deneyi yapıyoruz. Soru şu: aynı fabrikadan ölçümleri yeniden alsak, ağaç aynı mı çıkar?
Veriyi yeniden toplamak yerine, elimizdeki 260 ölçümden yerine koyarak yine 260 ölçüm çekiyoruz. Yani: torbadan bir ölçüm çek, yaz, torbaya geri at, tekrar çek. Sonuçta bazı ölçümler iki üç kez gelir, bazıları hiç gelmez — ama veri aynı fabrikadandır. Bu işlemin adı bootstrap.
Aşağıdaki dört ağacın ayarları birebir aynı (derinlik 6, yaprak ≥ 4) ve dördü de aynı fabrikanın verisini gördü. Tek fark: her biri farklı bir bootstrap örneklemiyle eğitildi. Önce kökteki soruya, sonra sınırların şekline bakın.
İki yoldan hangisi?
Ağacı daha iyi yap
Daha iyi bir bölme ölçüsü, daha akıllı bir arama, daha iyi budama... Hepsi denendi. Kazanç küçük, çünkü problem ölçüde değil yapıda: tek bir kök kararına bağlı kalmakta.
Çok ağaç kur, oylat
Tek ağacı düzeltmekten vazgeçin. Kırılganlığı kabul edip çoğaltın: yüz farklı bootstrap örneklemiyle yüz ağaç kurun, her biri farklı yerlerde yanılsın, sonra oylayın. Hatalar birbirini götürür.
Torbalama: kalabalık oylar
Yöntemin adı bagging — “bootstrap aggregating”, yani yerine koyarak örnekle, sonra topla. Üç satırda özetlenir ve şaşırtıcı derecede iyi çalışır.
Kaydıraç kaç ağacın oy vereceğini belirliyor. 1'den başlayıp yavaşça 60'a çekin. İki şeye dikkat: zemindeki gri geçiş bölgesi (ağaçların anlaşamadığı yerler) ve sağdaki skor. Alttaki kutu, tek ağacın yanıldığı bir sınav örneğinde ağaçların tek tek nasıl oy verdiğini gösteriyor.
Zemin: oyların oranı — grinin koyuluğu kararsızlığı gösterir
Üç gözlem, üç ders
Random Forest: bir ek kural, büyük fark
Torbalamanın bir zayıflığı var: ağaçlar birbirine çok benziyor. Random Forest bunu tek bir ek kuralla çözer — ve bu yüzden torbalamanın özel hâli değil, kendi başına bir yöntemdir.
Düşünün: veride çok güçlü bir sütun var (örneğin Titanic'te cinsiyet). Her bootstrap örnekleminde o sütun en yüksek kazancı verir, dolayısıyla yüz ağacın yüzü de aynı soruyla başlar. Ağaçlar farklı veriden eğitildi ama kök kararları aynı — yani hataları da benzer yerlerde. Oylamanın işe yaraması için gereken bağımsızlık kaybolmuştur.
Sonuç ilk bakışta tuhaftır: ağaçların tek tek skoru düşer — çünkü her birini en iyi sorudan mahrum bıraktık. Ama topluluğun skoru yükselir, çünkü ağaçlar artık birbirine benzemiyor. Lab 5'teki kutuyu işaretlediğinizde tam olarak bunu görürsünüz: tek ağaçta daha kötü, kalabalıkta daha iyi.
scikit-learn'de hangi ayar ne yapar?
| Ayar | Pratik değer | Açıklama |
|---|---|---|
| n_estimators | 300 – 500 | Ağaç sayısı. Arttırmak skoru bozmaz; yalnızca süreyi uzatır. Ayar değil bütçe. |
| max_features | "sqrt" | Her bölmede denenen sütun sayısı. Ormanı orman yapan ayar. None yazarsanız düz torbalama yapmış olursunuz. |
| min_samples_leaf | 1 – 5 | Ormanda tek ağaçtan daha gevşek bırakılır: her ağacın biraz ezberlemesi sorun değil, oylama onu temizler. Çok gürültülü veride 5–10'a çıkarın. |
| max_depth | None | Genelde sınırsız bırakılır. Tek ağaçta felaket olan şey, ormanda normaldir. |
| class_weight | "balanced" | Dengesiz veride (5. hafta) azınlık sınıfı ağırlıklandırır. Metrik seçimini düzeltmez — onu siz yapacaksınız. |
| n_jobs | -1 | Bütün çekirdekleri kullan. Ağaçlar birbirinden bağımsız olduğu için paralelleşme neredeyse bedava. |
Boosting: sıradaki ağaç öncekinin hatasını düzeltir
Orman ağaçları aynı anda ve birbirinden habersiz kurar. Boosting tam tersini yapar: ağaçları sırayla kurar ve her yeni ağaca tek bir görev verir — şu ana kadarki toplamın yanıldığı yeri düzelt.
Torbalama / Orman
- Ağaçlar aynı anda kurulabilir.
- Her ağaç verinin tamamını (bootstrap hâlini) görür.
- Ağaçlar derin olur — her biri tek başına güçlü.
- Oylar eşit ağırlıklı.
- Ağaç eklemek zarar vermez.
Boosting
- Ağaçlar sırayla kurulur; 5. ağaç 4'ü beklemek zorunda.
- Her ağaç önceki hataya bakar, veriye değil.
- Ağaçlar sığ olur (derinlik 2–6) — tek başına zayıf.
- Katkılar öğrenme hızıyla küçültülür.
- Ağaç eklemek bir noktadan sonra zarar verir.
Gradient boosting'in mekanizması üç satırda:
tahmin = ortalama # en basit model: herkese ayni sayi
her tur icin:
artik = gercek - tahmin # "nerede, ne kadar yaniliyorum?"
kutuk = artiklara en iyi uyan sig agac
tahmin = tahmin + hiz * kutuk # kucuk bir adim at (hiz: 0,05 - 0,3)Bu kez sınıflandırma değil sayı tahmini yapıyoruz — boosting'in mantığı orada daha çıplak görünüyor. Kesikli gri çizgi gerçek kural, mavi noktalar ölçümler (gürültülü), turuncu merdiven modelin şu anki tahmini. Her noktadan merdivene inen dikey çizgi, o noktadaki artık: bir sonraki ağacın düzeltmeye çalışacağı hata.
Turuncu merdiven: eklenen bütün ağaçların toplamı
Yukarıdaki çubuklar, kalan artıkların büyüklüğü (ortadan sağa: model az tahmin etmiş, sola: fazla).
① Hızı 1,00'a çekip tur sayısını 2–3'te bırakın: model bir hamlede sıçrıyor ama kaba kalıyor.
② Hızı 0,05'e indirip 60 tura çıkın: aynı yere çok daha yumuşak gidiyor. Boosting'in “yavaş öğren, çok adım at” felsefesi bu.
③ Hızı 0,60'ta bırakıp turu 60'a çekin: eğitim hatası düşmeye devam ederken görmediği veride düşüş duruyor — ve iki sayının arası açılıyor. Boosting aşırı öğrenebilir; orman öğrenmez. İkisi arasındaki en önemli pratik fark budur.
Üç isim, aynı fikir
Hangisini kullanacağım?
Dört seçeneğimiz oldu: tek ağaç, torbalama, random forest, boosting. Seçim keyfî değil — problemin ne istediğine bağlı.
| Model | Doğruluk | Okunabilirlik | Hız | Ne zaman seçilir? |
|---|---|---|---|---|
| Tek karar ağacı | Düşük | Çok yüksek | Çok hızlı | Gerekçe şart olduğunda: kredi reddi, sigorta kararı, klinik protokol. Ya da veriyi anlamak için ilk bakış — derinlik 3'te bastırıp okuyun. |
| Torbalama | İyi | Yok | Paralel | Nadiren tek başına. Pratikte hep random forest tercih edilir; torbalama fikri anlamak için önemli. |
| Random Forest | Çok iyi | Yok | Paralel | Varsayılan seçiminiz. Ayar yapmadan iyi sonuç verir, aşırı öğrenmez, OOB skoru bedava gelir. “Önce bunu dene” modeli. |
| Gradient boosting | En iyi | Yok | Sıralı | Son yüzde birleri kovalarken. Ayar hassasiyeti yüksek, aşırı öğrenebilir, doğrulama disiplini şart. Tablo verisinde zirve burada. |
Peki okunabilirlik tamamen gitti mi?
Hayır — ama şekli değişti. Orman tek bir cümle vermez, fakat soru bazında cevap verebilir:
Bu dördünden ilk ikisini 12. bölümde Kaggle'da kodla göreceğiz.
Kaggle: dört model aynı veride yarışıyor
3. haftada Titanic'te ilk karar ağacını kurmuştuk. Şimdi aynı veriye geri dönüyoruz — ama bu kez dört modeli aynı ölçüyle yarıştırıp sonucu tek bir tabloya yazacağız. Bölümün sonunda elinizde çalışan bir notebook ve bir submission.csv olacak.
1. kaggle.com/c/titanic → Join Competition → kuralları kabul et.
2. Code → New Notebook (bu düğmeye yarışma sayfasından basarsanız veri otomatik eklenir).
3. Hızlandırıcı gerekmiyor — ağaçlar CPU'da çalışır, bütün bölüm 1 dakikadan az sürer. İnternet de kapalı kalabilir.
Çıktılar hakkında: aşağıdaki kutulardaki sayılar örnek değerlerdir. Kendi notebook'unuzda son ondalıklar kütüphane sürümüne ve rastgele bölünmeye göre küçük farklar gösterebilir. Bakacağınız şey tek bir sayı değil, sıralama ve eğilim.
Veriyi okuyun ve taban çizgisini yazın
5. haftanın ilk kuralı: taban çizgisi olmadan sayı yoktur. Hiçbir model kurmadan, herkese “öldü” diyen bir tahmin kaç alır? Bu sayıyı tahtaya yazın; bütün hafta ona bakacağız.
import numpy as np
import pandas as pd
train = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv("/kaggle/input/titanic/test.csv")
print("Egitim:", train.shape, " Test:", test.shape)
print("Hayatta kalma orani:", round(train["Survived"].mean(), 4))
print("TABAN CIZGISI (hep 'olmedi' de):", round((train["Survived"] == 0).mean(), 4))
print("\nEksik veri:")
print(train.isna().sum()[lambda s: s > 0])
Egitim: (891, 12) Test: (418, 11) Hayatta kalma orani: 0.3838 TABAN CIZGISI (hep 'olmedi' de): 0.6162 Eksik veri: Age 177 Cabin 687 Embarked 2 dtype: int64
Ağacın anlayacağı hâle getirin — ama ölçeklemeyin
Ağaç sayı ister, o kadar. Ölçekleme yok, standartlaştırma yok — 2. haftada öğrendiğimiz o adımlar burada boşa emek. Yapacağımız üç şey var: metni sayıya çevirmek, eksikleri doldurmak, iki yeni sütun türetmek.
# Doldurma degerleri YALNIZCA egitim verisinden hesaplanir.
# Testin medyanini kullanmak 2. haftanin "veri sizintisi" hatasidir.
YAS_ORTA = train["Age"].median()
UCRET_ORTA = train["Fare"].median()
SUTUNLAR = ["Pclass", "Kadin", "Age", "Fare", "SibSp", "Parch",
"Aile", "Yalniz", "Lman_C", "Lman_Q", "Lman_S"]
def hazirla(df):
d = df.copy()
d["Kadin"] = (d["Sex"] == "female").astype(int) # metin -> 0/1
d["Age"] = d["Age"].fillna(YAS_ORTA)
d["Fare"] = d["Fare"].fillna(UCRET_ORTA)
d["Aile"] = d["SibSp"] + d["Parch"] + 1 # kendisi dahil aile buyuklugu
d["Yalniz"] = (d["Aile"] == 1).astype(int)
liman = pd.get_dummies(d["Embarked"].fillna("S"), prefix="Lman", dtype=int)
d = pd.concat([d, liman], axis=1)
# reindex: testte olmayan bir liman sutunu varsa 0 ile doldurulur,
# fazlasi atilir -> iki tabloda sutun sirasi birebir ayni olur.
return d.reindex(columns=SUTUNLAR, fill_value=0)
X = hazirla(train)
y = train["Survived"]
X_test = hazirla(test)
print(X.shape, X_test.shape)
print(X.head(3))
(891, 11) (418, 11) Pclass Kadin Age Fare SibSp Parch Aile Yalniz Lman_C Lman_Q Lman_S 0 3 0 22.0 7.2500 1 0 2 0 0 0 1 1 1 1 38.0 71.2833 1 0 2 0 1 0 0 2 3 1 26.0 7.9250 0 0 1 1 0 0 1
Pclass'ı neden one-hot yapmadık? Çünkü sıralı: 1 > 2 > 3 bir hiyerarşi. Ağaç Pclass ≤ 2,5 diye sorarak “1. ve 2. sınıf” grubunu tek soruda ayırabilir. Limanda ise böyle bir sıra yok — onu one-hot yaptık.
İlk ağacı kurun ve okuyun
Bu haftanın ayırt edici anı: modeli yazdırıp sesli okumak. Çıktıdaki her satır bir soru; en içteki class: satırları cevaplar.
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, export_text
# Dogrulama ayrimi: modelin hic gormedigi %25
X_eg, X_dog, y_eg, y_dog = train_test_split(
X, y, test_size=0.25, stratify=y, random_state=42)
agac = DecisionTreeClassifier(max_depth=3, min_samples_leaf=10, random_state=42)
agac.fit(X_eg, y_eg)
print("Egitim :", round(agac.score(X_eg, y_eg), 4))
print("Dogrulama :", round(agac.score(X_dog, y_dog), 4))
print()
print(export_text(agac, feature_names=list(X.columns), decimals=1))
Egitim : 0.8323 Dogrulama : 0.8027 |--- Kadin <= 0.5 | |--- Age <= 6.5 | | |--- SibSp <= 2.5 | | | |--- class: 1 | | |--- SibSp > 2.5 | | | |--- class: 0 | |--- Age > 6.5 | | |--- Fare <= 26.3 | | | |--- class: 0 | | |--- Fare > 26.3 | | | |--- class: 0 |--- Kadin > 0.5 | |--- Pclass <= 2.5 | | |--- Age <= 2.5 | | | |--- class: 0 | | |--- Age > 2.5 | | | |--- class: 1 | |--- Pclass > 2.5 | | |--- Fare <= 23.4 | | | |--- class: 1 | | |--- Fare > 23.4 | | | |--- class: 0
İki şeye dikkat edin. ① Sağ alt dal mantıksız görünüyor: 3. sınıf kadınlarda pahalı bilet neden kötü? Çünkü o yaprakta az örnek var ve pahalı bileti olan 3. sınıf kadınlar genelde kalabalık aileler. Bu bir kural değil, ezberin başlangıcı. ② Soldaki iki yaprak da class: 0 veriyor: ağaç orada gereksiz bir soru sormuş; Fare bölmesi safsızlığı düşürdü ama kararı değiştirmedi.
Derinliği tarayın: aşırı öğrenmeyi sayıyla yakalayın
Lab 2'de kaydıraçla gördüğünüz şeyi şimdi gerçek veride tabloya döküyoruz. İki sütunu birlikte okuyun: biri hangi noktada yükselmeye devam ediyor, diğeri hangi noktada dönüyor?
print(f"{'derinlik':>9} | {'egitim':>7} | {'dogrulama':>9} | ucurum")
for d in [1, 2, 3, 4, 5, 6, 8, 10, 12, None]:
m = DecisionTreeClassifier(max_depth=d, random_state=42).fit(X_eg, y_eg)
e, v = m.score(X_eg, y_eg), m.score(X_dog, y_dog)
print(f"{str(d):>9} | {e:>7.4f} | {v:>9.4f} | {e-v:+.4f}")
derinlik | egitim | dogrulama | ucurum
1 | 0.7859 | 0.7892 | -0.0033
2 | 0.7859 | 0.7892 | -0.0033
3 | 0.8338 | 0.8027 | +0.0311
4 | 0.8443 | 0.8206 | +0.0237
5 | 0.8623 | 0.8117 | +0.0506
6 | 0.8803 | 0.8027 | +0.0776
8 | 0.9222 | 0.7892 | +0.1330
10 | 0.9611 | 0.7758 | +0.1853
12 | 0.9806 | 0.7623 | +0.2183
None | 0.9851 | 0.7578 | +0.2273
① Eğitim sütunu hiç dönmüyor — %98,5'e kadar tırmanıyor. Ağaca özgürlük verdikçe eğitim verisini daha iyi ezberler; bu her zaman böyle olur.
② Doğrulama sütunu derinlik 4'te zirve yapıp iniyor. Aradığımız ayar bu.
③ Uçurum sütunu teşhis aracı. 0,02 civarı sağlıklı, 0,10 üstü alarm, 0,20 üstü “bu model ezberliyor”. Raporunuza bu sütunu da yazın.
Ama dikkat: bu tablo tek bir %25'lik bölünmeye bakıyor. Başka bir random_state ile zirve 5'e kayabilir. Bir sonraki adım tam olarak bu sorunu çözüyor.
Çapraz doğrulama: tek bölünmeye güvenmeyin
891 satırın %25'i 223 satır. Bu kadar küçük bir doğrulama kümesinde ±2 puan gürültü normaldir — yani iki modeli 1 puan farkla karşılaştırmak ölçüm hatasının içinde kalır. Çözüm: veriyi beş parçaya bölüp beş kez eğit, beş skorun ortalamasını ve yayılımını raporla.
from sklearn.model_selection import cross_val_score, StratifiedKFold
# StratifiedKFold: her katta hayatta kalma orani korunur (5. hafta: dengesiz veri)
kat = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
def olc(ad, model):
s = cross_val_score(model, X, y, cv=kat, scoring="accuracy", n_jobs=-1)
print(f"{ad:<34} {s.mean():.4f} ± {s.std():.4f} {np.round(s, 4)}")
return s.mean(), s.std()
olc("Agac, derinlik 4, yaprak 10", DecisionTreeClassifier(max_depth=4, min_samples_leaf=10, random_state=42))
olc("Agac, sinirsiz (ezberleyen)", DecisionTreeClassifier(random_state=42));
Agac, derinlik 4, yaprak 10 0.8148 ± 0.0105 [0.8156 0.7978 0.8258 0.809 0.8258] Agac, sinirsiz (ezberleyen) 0.7766 ± 0.0206 [0.7542 0.7809 0.7978 0.7753 0.7747]
Kural: iki modelin ortalamaları arasındaki fark, yayılımlarından küçükse o fark yoktur. “0,8148 > 0,8102, demek ki daha iyi” cümlesi ± 0,01 varken anlamsızdır.
Random Forest'ı ekleyin ve OOB skorunu bedava alın
Tek satır model kurulumu. Dikkat edin: min_samples_leaf tek ağaçtakinden daha gevşek — ormanda her ağacın biraz ezberlemesi sorun değil.
from sklearn.ensemble import RandomForestClassifier
orman = RandomForestClassifier(
n_estimators=400, # agac sayisi: ayar degil, butce
max_features="sqrt", # ORMANI ORMAN YAPAN AYAR (bolum 09)
min_samples_leaf=2,
random_state=42,
n_jobs=-1,
oob_score=True # test seti ayirmadan dürüst skor
)
orman.fit(X, y)
print("OOB skoru (bedava):", round(orman.oob_score_, 4))
olc("Random Forest (400 agac)", RandomForestClassifier(
n_estimators=400, max_features="sqrt", min_samples_leaf=2,
random_state=42, n_jobs=-1));
# Ayni orman, rastgele sutun kurali KAPALI -> duz torbalama
olc("Duz torbalama (max_features=None)", RandomForestClassifier(
n_estimators=400, max_features=None, min_samples_leaf=2,
random_state=42, n_jobs=-1));
OOB skoru (bedava): 0.8328 Random Forest (400 agac) 0.8260 ± 0.0183 [0.8045 0.8146 0.8483 0.8146 0.848 ] Duz torbalama (max_features=None) 0.8137 ± 0.0206 [0.7933 0.7978 0.8371 0.8034 0.8371]
① Orman tek ağacı geçti: 0,8148 → 0,8260. Hiçbir ağaç daha iyi değil; yalnızca hataları birbirini götürdü.
② Rastgele sütun kuralı işe yarıyor: aynı 400 ağaç, max_features=None ile 0,8137'ye düşüyor. 9. bölümde anlattığımız şey burada ölçülebildi — ormanı orman yapan tek satır bu.
OOB skoru (0,8328), çapraz doğrulamaya (0,8260) yakın ve hiçbir veri ayırmadan elde edildi. Veriniz küçükse bu çok değerli: 891 satırdan 223'ünü sınava ayırmak yerine hepsiyle eğitip yine dürüst bir sayı alıyorsunuz.
Boosting'i ekleyin
10. bölümdeki döngünün kütüphane karşılığı. Üç ayarı birlikte okuyun: düşük hız, çok tur, erken durdurma. Üçü birbirine bağlı.
from sklearn.ensemble import HistGradientBoostingClassifier
hgb = HistGradientBoostingClassifier(
learning_rate=0.06, # yavas ogren
max_iter=500, # cok adim at
max_leaf_nodes=15, # agaclar SIG olsun (boosting boyle sever)
min_samples_leaf=15,
early_stopping=True, # dogrulama skoru iyilesmeyi birakinca dur
validation_fraction=0.15,
n_iter_no_change=30,
random_state=42
)
hgb.fit(X, y)
print("Erken durdurma kac agacta durdu:", hgb.n_iter_)
olc("HistGradientBoosting", HistGradientBoostingClassifier(
learning_rate=0.06, max_iter=500, max_leaf_nodes=15, min_samples_leaf=15,
early_stopping=True, validation_fraction=0.15, n_iter_no_change=30,
random_state=42));
# Erken durdurma KAPALI, 500 agac zorla: boosting asiri ogrenebilir
olc("HGB, 500 agac, erken durdurma yok", HistGradientBoostingClassifier(
learning_rate=0.06, max_iter=500, max_leaf_nodes=15, min_samples_leaf=15,
early_stopping=False, random_state=42));
Erken durdurma kac agacta durdu: 83 HistGradientBoosting 0.8305 ± 0.0163 [0.8156 0.8258 0.8539 0.8146 0.8427] HGB, 500 agac, erken durdurma yok 0.8137 ± 0.0239 [0.7877 0.8146 0.8427 0.8034 0.8202]
Orman ile boosting arasındaki pratik farkı tek cümleye indirelim: ormanda n_estimators'ı arttırmak hiçbir zaman zarar vermez; boosting'te max_iter'ı arttırmak bir noktadan sonra zarar verir. Bu yüzden boosting'te erken durdurma pazarlık konusu değildir.
Dördünü tek tabloya yazın
Raporunuzun kalbi bu tablo. Dört model, aynı veri, aynı katlar, aynı metrik. Tek sayı değil — ortalama ± yayılım, ve taban çizgisi en üstte.
from sklearn.dummy import DummyClassifier
modeller = {
"0 · Taban cizgisi (hep cogunluk)": DummyClassifier(strategy="most_frequent"),
"1 · Karar agaci (d=4, yaprak=10)": DecisionTreeClassifier(max_depth=4, min_samples_leaf=10, random_state=42),
"2 · Karar agaci (sinirsiz)": DecisionTreeClassifier(random_state=42),
"3 · Random Forest (400)": RandomForestClassifier(n_estimators=400, max_features="sqrt",
min_samples_leaf=2, random_state=42, n_jobs=-1),
"4 · HistGradientBoosting": HistGradientBoostingClassifier(
learning_rate=0.06, max_iter=500, max_leaf_nodes=15,
min_samples_leaf=15, early_stopping=True,
validation_fraction=0.15, n_iter_no_change=30, random_state=42),
}
satirlar = []
for ad, m in modeller.items():
s = cross_val_score(m, X, y, cv=kat, scoring="accuracy", n_jobs=-1)
satirlar.append({"model": ad, "ortalama": round(s.mean(), 4),
"yayilim": round(s.std(), 4), "en_kotu_kat": round(s.min(), 4)})
tablo = pd.DataFrame(satirlar).sort_values("ortalama", ascending=False)
print(tablo.to_string(index=False))
model ortalama yayilim en_kotu_kat
4 · HistGradientBoosting 0.8305 0.0163 0.8146
3 · Random Forest (400) 0.8260 0.0183 0.8045
1 · Karar agaci (d=4, yaprak=10) 0.8148 0.0105 0.7978
2 · Karar agaci (sinirsiz) 0.7766 0.0206 0.7542
0 · Taban cizgisi (hep cogunluk) 0.6162 0.0003 0.6158
Buna rağmen budanmış ağaç ile budanmamış ağaç arasındaki 4 puan gerçek — yayılımın dört katı. Yani bu veride kazandıran şey egzotik bir model değil, ezberi kesmek. Haftanın en pratik dersi bu.
Öznitelik önemi — ve PassengerId tuzağını canlı görün
Lab 3'teki tuzağı şimdi gerçek veride kuruyoruz. Titanic'te hazır bir “kayıt numarası” var: PassengerId. Hayatta kalmakla ilgisi tanımı gereği sıfır — yolcular sırayla numaralanmış. Bakalım model ne diyecek.
from sklearn.inspection import permutation_importance
X_tuzak = X.copy()
X_tuzak["PassengerId"] = train["PassengerId"] # BILGI TASIMAYAN SUTUN
derin = DecisionTreeClassifier(random_state=42).fit(X_tuzak, y)
print("Budanmamis agac — Gini onemi:")
print(pd.Series(derin.feature_importances_, index=X_tuzak.columns)
.sort_values(ascending=False).round(4).head(6).to_string())
budali = DecisionTreeClassifier(max_depth=4, min_samples_leaf=10,
random_state=42).fit(X_tuzak, y)
print("\nBudanmis agac — Gini onemi:")
print(pd.Series(budali.feature_importances_, index=X_tuzak.columns)
.sort_values(ascending=False).round(4).head(6).to_string())
Budanmamis agac — Gini onemi: Kadin 0.2976 Fare 0.2111 Age 0.1875 PassengerId 0.1402 Pclass 0.0608 SibSp 0.0388 Budanmis agac — Gini onemi: Kadin 0.5908 Pclass 0.1733 Fare 0.1101 Aile 0.0689 Age 0.0569 PassengerId 0.0000
Budama tuzağı sıfırladı ve liste okunabilir hâle geldi: cinsiyet, sınıf, bilet ücreti. Üstelik bu liste Titanic hakkında bildiğimiz tarihle uyuşuyor — “kadınlar ve çocuklar önce”.
Permütasyon önemi: daha güvenilir ikinci görüş
Gini önemi eğitim verisine bakar, dolayısıyla ezberden etkilenir. Permütasyon önemi başka bir soru sorar: bu sütunu bozarsam, modelin görmediği veride skoru ne kadar düşer?
orman_t = RandomForestClassifier(n_estimators=400, max_features="sqrt",
min_samples_leaf=2, random_state=42, n_jobs=-1)
X_eg2, X_dog2, y_eg2, y_dog2 = train_test_split(
X_tuzak, y, test_size=0.25, stratify=y, random_state=42)
orman_t.fit(X_eg2, y_eg2)
p = permutation_importance(orman_t, X_dog2, y_dog2,
n_repeats=30, random_state=42, n_jobs=-1)
print("Permutasyon onemi (gormedigi veride skor dususu):")
print(pd.Series(p.importances_mean, index=X_tuzak.columns)
.sort_values(ascending=False).round(4).to_string())
Permutasyon onemi (gormedigi veride skor dususu): Kadin 0.1079 Fare 0.0287 Pclass 0.0198 Age 0.0163 Aile 0.0063 SibSp 0.0030 Lman_S 0.0012 Yalniz 0.0009 Lman_C 0.0004 Lman_Q -0.0001 Parch -0.0013 PassengerId -0.0031
Kural: bir sütunu silip silmeme kararı verirken Gini önemine değil, permütasyon önemine bakın. Gini “bölmeye yaradı mı?” sorusunun, permütasyon “tahmine yarıyor mu?” sorusunun cevabıdır. Rapora yazacağınız cümle ikincisinden çıkar.
5. haftanın gözüyle bakın: matris, kesinlik, duyarlılık
Doğruluk tek başına yalan söyler — geçen haftanın tamamı buydu. En iyi modelimizi şimdi o gözle okuyoruz.
from sklearn.metrics import confusion_matrix, classification_report
en_iyi = HistGradientBoostingClassifier(
learning_rate=0.06, max_iter=500, max_leaf_nodes=15, min_samples_leaf=15,
early_stopping=True, validation_fraction=0.15, n_iter_no_change=30, random_state=42)
en_iyi.fit(X_eg, y_eg)
tahmin = en_iyi.predict(X_dog)
km = confusion_matrix(y_dog, tahmin)
print("Karmasiklik matrisi (ham sayi):")
print(pd.DataFrame(km,
index=["gercek: olmedi", "gercek: kurtuldu"],
columns=["tahmin: olmedi", "tahmin: kurtuldu"]).to_string())
print()
print(classification_report(y_dog, tahmin, target_names=["olmedi", "kurtuldu"], digits=3))
Karmasiklik matrisi (ham sayi):
tahmin: olmedi tahmin: kurtuldu
gercek: olmedi 121 17
gercek: kurtuldu 23 62
precision recall f1-score support
olmedi 0.840 0.877 0.858 138
kurtuldu 0.785 0.729 0.756 85
accuracy 0.821 223
macro avg 0.813 0.803 0.807 223
weighted avg 0.819 0.821 0.819 223
Rapora yazılacak cümle: “%82,1 doğruluk” değil, şu: “Doğruluk 0,821; kurtulanlar için duyarlılık 0,729 ve kesinlik 0,785. Taban çizgisi 0,616.” Üç sayı ve bir referans — bir sayı değil.
Teslim dosyasını üretin
Son adım: bütün eğitim verisiyle yeniden eğitip (doğrulama ayrımı artık gerekmiyor, ayarları seçtik) test setini tahmin etmek.
# Ayarlar secildi -> simdi 891 satirin TAMAMIYLA egit
en_iyi.fit(X, y)
tahmin_test = en_iyi.predict(X_test)
teslim = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": tahmin_test.astype(int)
})
teslim.to_csv("/kaggle/working/submission.csv", index=False)
print(teslim.shape) # (418, 2) olmali
print(teslim["Survived"].value_counts()) # makul bir dagilim mi?
print(teslim.head())
(418, 2) Survived 0 271 1 147 Name: count, dtype: int64 PassengerId Survived 0 892 0 1 893 0 2 894 0 3 895 0 4 896 1
① Satır sayısı 418 mi? Değilse bir yerde satır düşürdünüz.
② Dağılım makul mu? Eğitimde hayatta kalma oranı %38,4; tahminlerde 147/418 = %35,2. Yakın. Eğer %5 ya da %80 çıkarsa modelde bir şey ters — tahmin etmeden önce bu oranı mutlaka bakın.
Sağ panelden Submit → Kaggle size public leaderboard skorunu verir. Bu skor yerel çapraz doğrulamanızdan farklı çıkacak ve bunun sebebi bir sonraki bölümde.
Çapraz doğrulama, ayar arama ve leaderboard'un yalanı
Kaggle'a gönderdiniz ve skor 0,7799 geldi. Oysa yerel ölçümünüz 0,8305'ti. Model mi bozuk? Hayır — iki sayı aynı şeyi ölçmüyor.
| Sayı | Neyi ölçer? Neden farklı? |
|---|---|
| Çapraz doğrulama ortalaması 0,8305 ± 0,0163 |
891 satırın beş farklı bölünmesindeki ortalama. En güvenilir sayınız, çünkü bütün veriyi hem eğitimde hem sınavda kullanıyor ve yayılımı da veriyor. |
| Public leaderboard skoru 0,7799 |
Test setinin yalnızca %50'sinde (≈209 satır) ölçülür. 209 satırda tek bir yanlış tahmin 0,48 puan oynatır — yani leaderboard'daki ilk iki ondalık gürültüdür. Üstelik eğitim ve test setleri aynı dağılımdan gelse de farklı örneklemler. |
| Private leaderboard skoru yarışma bitince açılır |
Test setinin diğer %50'si. Asıl sıralama bu. Public skoruna göre ayar yapanlar burada düşer — çünkü public skor da bir doğrulama kümesidir ve ona bakarak model seçmek o kümeye aşırı öğrenmektir. |
Ayarları aramak: tek tek denemeyin, ızgara kurun
12. bölümde derinliği elle taradık. İki ayarı birlikte aramak gerekince bu iş elle yapılmaz — GridSearchCV bütün kombinasyonları çapraz doğrulamayla dener ve en iyisini seçer.
Izgara aramasıyla en iyi ağacı bulun
from sklearn.model_selection import GridSearchCV
izgara = {
"max_depth": [3, 4, 5, 6, 8, None],
"min_samples_leaf": [1, 5, 10, 20],
}
# 6 x 4 = 24 kombinasyon, her biri 5 katla egitiliyor -> 120 agac
ara = GridSearchCV(
DecisionTreeClassifier(random_state=42),
izgara, cv=kat, scoring="accuracy", n_jobs=-1, return_train_score=True
)
ara.fit(X, y)
print("En iyi ayar :", ara.best_params_)
print("En iyi skor :", round(ara.best_score_, 4))
sonuc = pd.DataFrame(ara.cv_results_)[
["param_max_depth", "param_min_samples_leaf",
"mean_train_score", "mean_test_score", "std_test_score"]
].sort_values("mean_test_score", ascending=False)
print(sonuc.head(6).round(4).to_string(index=False))
En iyi ayar : {'max_depth': 4, 'min_samples_leaf': 5}
En iyi skor : 0.8215
param_max_depth param_min_samples_leaf mean_train_score mean_test_score std_test_score
4 5 0.8372 0.8215 0.0144
4 10 0.8338 0.8148 0.0105
5 5 0.8514 0.8126 0.0188
3 5 0.8203 0.8114 0.0122
6 10 0.8465 0.8103 0.0155
None 1 0.9851 0.7766 0.0206
Izgarayı büyütmenin bedeli: 24 kombinasyon × 5 kat = 120 eğitim. Üçüncü bir ayar eklerseniz 500'e çıkar. Ağaçta sorun değil ama boosting'te dakikalar sürer — o yüzden RandomizedSearchCV (rastgele bir kısmını dene) ya da erken durdurma tercih edilir.
Son kontrol: modeliniz gerçekten öğrendi mi?
5. haftanın kuralı: düşünmeyen modeli geçemiyorsanız model yok demektir. Bir de şu testi yapın — etiketleri karıştırıp aynı modeli eğitin. Skor taban çizgisine inmeli. İnmiyorsa bir yerde sızıntı var.
from sklearn.utils import shuffle
y_karisik = shuffle(y.values, random_state=0) # etiketler rastgele dagitildi
s_gercek = cross_val_score(ara.best_estimator_, X, y, cv=kat, n_jobs=-1)
s_karisik = cross_val_score(ara.best_estimator_, X, y_karisik, cv=kat, n_jobs=-1)
print("Gercek etiketlerle :", round(s_gercek.mean(), 4))
print("Karisik etiketlerle:", round(s_karisik.mean(), 4))
print("Taban cizgisi :", round((y == 0).mean(), 4))
Gercek etiketlerle : 0.8215 Karisik etiketlerle: 0.5882 Taban cizgisi : 0.6162
Bu haftaya özel yedi tuzak
Her biri gerçek projelerde görülmüş hatalar. Belirti, sebep ve çözüm sırasıyla.
| Belirti | Sebep | Çözüm |
|---|---|---|
| Eğitimde %100, testte %75 | Ağaç budanmamış. Her yaprakta tek örnek kalmış. | min_samples_leaf en az 5–10, max_depth 4–6. Tek satırla düzelir ve bu veride en büyük kazanç buradan gelir. |
| Kodu iki kez çalıştırdım, iki farklı ağaç | random_state verilmemiş; eşit kazançlı sorular arasında seçim rastgele. | Her modele random_state=42. Raporlanabilirlik için şart. |
| Önem listesinde kimlik / tarih sütunu üstte | Benzersiz sütunlar bölmek için çok fırsat verir; Gini önemi bunu “fayda” sanar. | O sütunları veriden at. Budama uygula. Karar verirken permütasyon önemine bak (12. bölüm, hücre 10). |
| Boosting eklediğim her ağaçta kötüleşiyor | Öğrenme hızı yüksek ve erken durdurma kapalı. Boosting aşırı öğrenebilir. | learning_rate=0.05–0.1, early_stopping=True. Hızı yarıya indirdiğinizde tur sayısını iki katına çıkarın. |
| Orman kurdum ama skor tek ağaçla aynı | max_features=None kalmış: ağaçlar birbirine çok benziyor, oylamanın kazancı yok. | max_features="sqrt". 12. bölümde bu tek ayarın 1,2 puan getirdiğini ölçtük. |
| Yerel skor iyi, Kaggle skoru düşük | Ya doldurma değerleri test verisinden hesaplanmış (sızıntı), ya leaderboard skoruna bakılarak ayar seçilmiş. | Medyan/mod gibi değerleri yalnızca eğitimden hesapla. Ayarı çapraz doğrulamayla seç, leaderboard'a nadiren bak. |
| Model “hep çoğunluk” diyor | Sınıflar dengesiz (5. hafta) ve ağaç kolay puanı seçmiş. | class_weight="balanced", metrik olarak doğruluk yerine azınlık sınıfın duyarlılığı, gerekirse eşiği kaydırmak. |
Ödev: dört model, bir tablo, bir karar
İki parça var. A şıkkı herkes için zorunlu, B şıkkı kendi probleminizle devam etmek isteyenler için — ama ikisi de aynı tabloyu istiyor.
Titanic: karşılaştırma tablosunu kendiniz üretin
12. bölümün notebook'unu indirip Kaggle'a aktarın (ya da kodları kendiniz yazın) ve aşağıdaki altı şeyi tek bir notebook'ta teslim edin:
- Taban çizgisi ve beş modelin çapraz doğrulama tablosu (ortalama ve yayılım — yayılımsız tablo kabul edilmiyor).
- Derinlik taraması tablosu ve tek cümlelik yorumu: “uçurum hangi derinlikte 0,10'u geçti?”
- En iyi modelin karmaşıklık matrisi (ham sayı) ve iki sınıf için ayrı ayrı kesinlik/duyarlılık.
- Öznitelik önemi ile permütasyon önemi listelerini yan yana. İkisinin ayrıldığı en az bir sütunu işaretleyip nedenini yazın.
- Etiket karıştırma testi (hücre 14) ve sonucu.
- submission.csv ve Kaggle'ın verdiği public skor. Yerel skorunuzla farkını yazın ve neden farklı olduğunu açıklayın.
En az bir yeni öznitelik türetin (örneğin Cabin boş mu değil mi, ya da Name içindeki unvan: Mr/Mrs/Miss/Master). Tablonuzda o öznitelikle ve onsuz skorlar birlikte görünsün.
Kendi veri setinizde aynı disiplini uygulayın
3. haftada Kaggle'da kendi probleminizi seçmiştiniz. Aynı veriye dönün ve A şıkkındaki altı maddeyi orada tekrarlayın. Şartlar:
- Tablo verisi olsun (satır-sütun). Görüntü veri setleri 4. haftanın konusuydu.
- En az 500 satır ve en az 5 sütun bulunsun.
- Sınıflandırma problemi olsun; sınıf dengesini raporun başında yazın.
- Veri setinin lisansını ve bağlantısını notebook'un ilk hücresine yazın (3. hafta kuralı).
- Tek sayı raporlamak. “%83 aldım” cümlesi tek başına sıfır puan: taban çizgisi ve yayılım olmadan o sayı hiçbir şey anlatmaz.
- Modeli övmek, farkı ölçmemek. “Random forest daha iyi çıktı” demek yeterli değil — farkın yayılımdan büyük olup olmadığını yazın. Değilse “fark ölçülemedi” demek doğru cevaptır.
- Gerekçesiz ayar. max_depth=7 yazdıysanız neden 7 olduğunu bir cümleyle söyleyin. “Denedim, iyi çıktı” kabul — ama hangi tabloda iyi çıktığını gösterin.
Kod yazmanın ötesi: notebook'un en sonuna tek paragraf yazın — “bu veride kazandıran şey model değişikliği mi, ayar değişikliği mi, öznitelik türetmek mi oldu?” Bu paragraf, bütün ödevin en çok puan getiren kısmı.
Özet, kontrol listesi ve ders sonu testi
Bu haftanın zihinsel modeli
Ağaç tabanlı bir model teslim ederken kontrol listesi
Gelecek hafta
Yapay sinir ağları. Bu hafta tablo verisinde zirveyi gördük: ağaç toplulukları. Gelecek hafta tamamen farklı bir fikre geçiyoruz — veriyi bölmek yerine ağırlıkları yavaş yavaş ayarlamak. 4. haftada CNN'i kullanmıştık ama içini açmamıştık; nöron, katman, ağırlık ve eğitim döngüsünü oradan devralıp kuracağız.
Bu haftanın iki fikri orada da karşımıza çıkacak: aşırı öğrenme (sinir ağında daha şiddetli) ve öğrenme hızı (boosting'teki ile aynı rol). Lab 6'daki “yavaş öğren, çok adım at” sezgisini aklınızda tutun.