Yapay Zeka Uygulamaları · 6. Hafta

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.

“Tek bir ağaç size neden böyle karar verdiğini anlatır. Yüz ağaç ise daha doğru karar verir. Bu hafta bu ikisi arasındaki alışverişi öğreniyoruz — ve ikisine de aynı anda ihtiyaç duyduğunuzda ne yapılacağını.”
🌳Okunabilir modelKararını cümleyle yazan tek algoritma
✂️BudamaEzberi kesen tek ayar
🌲OrmanYüz kırılgan modelden sağlam bir model
🏆KaggleDört model, tek tablo, dürüst karşılaştırma
01 · Büyük resim

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.

🎯
Derse başlarken: canlı yarışma — 10 soru Sorular 1–5. haftalardan, bugünün konusundan değil: aşırı öğrenme, görmediği veride ölçmek, ölçekleme, dengesiz veri, sızıntı, taban çizgisi. Hepsi bugünkü konuya açılıyor. Canlı Yarışma uygulamasında hazır örnek: Yapay Zeka — 6. Hafta · Açılış.
Yarışmayı aç
Sinir ağı

“Çı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.

KNN

“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.

Karar ağacı

“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.

Haftanın birinci cümlesi: karar ağacı, kararını kendi yazan modeldir. Bu yüzden bankacılıkta, sigortada ve sağlıkta hâlâ ilk tercih — oralarda doğru cevap kadar savunulabilir cevap da gerekir.

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ı.

Bu hafta · 1. yarı
Tek ağaç Nasıl soru seçer, nerede durur, raporu nasıl okunur. Okunabilir ama kırılgan.
Bu hafta · 2. yarı
Topluluk Torbalama, random forest, boosting. Daha doğru ama tek cümleyle açıklanamaz.
Bu hafta · 3. yarı
Kaggle Dört modeli aynı veride, aynı ölçüyle yarıştırıp sonucu dürüstçe raporlamak.
Bu hafta ne yapıyoruz, ne yapmıyoruz?
✔ 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.
02 · Temel kavram

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.

sıcaklık ≤ 0,50 ?
Evet — makine soğuk
titreşim ≤ 0,50 ?
Evet — soğuk ve sakin
SAĞLAM normal çalışma
Hayır — soğuk ama çok titriyor
ARIZA rulman sıkışması
Hayır — makine sıcak
titreşim ≤ 0,50 ?
Evet — sıcak ama sakin
ARIZA yağ bitmiş, sürtünme ısıtıyor
Hayır — sıcak ve titriyor
SAĞLAM tam yük altında normal

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.

Dikkat: bu kural tek soruyla yakalanamaz. “Sıcaklık yüksek mi?” sorusunun cevabı tek başına hiçbir şey söylemiyor — çünkü sıcak makinelerin yarısı arızalı, yarısı sağlam. Aynısı titreşim için de geçerli. Bilgi, iki sorunun birlikteliğinde. Karar ağacının “ağaç” olmasının sebebi tam olarak bu.

Üç kelime: kök, dal, yaprak

Kök

İ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.

Dal

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.

Yaprak

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.

Yaprak saf değil, çoğunluktur. Bir yaprakta 58 örnek varsa ve 53'ü sağlamsa, ağaç o yaprağa gelen herkese “sağlam” der — beşini yanlış bilerek. 5. haftadan hatırlayın: bu yaprak aynı zamanda bir olasılık üretir (53/58 = 0,91) ve isterseniz eşiği 0,5'ten kaydırabilirsiniz.

Ağacın bilmediği şeyler

Ağaç bunu yapmazNeden ö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.
03 · Mekanizma

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 — bir kutunun karışıklığı
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.

Her sütun için bütün olası eşikleri sırayla dener. Eşik adayı, sıralanmış iki komşu değerin orta noktasıdır — 300 farklı maaş varsa 299 aday.
Her aday için veriyi ikiye böler ve iki tarafın Gini'sini hesaplar.
İkisini ağırlıklı ortalar: 90 kişilik dalın Gini'si, 10 kişilik dalın Gini'sinden dokuz kat daha çok sayar.
Kazancı yazar: kazanç = bölmeden önceki Gini − bölmeden sonraki ağırlıklı Gini. En yüksek kazancı veren soru kazanır.
Aynı işi iki dalda baştan yapar. Kök bittiğinde iki alt küme kalır; her birine bu dört adım yeniden uygulanır. Algoritmanın tamamı budur.
Ağaç ileriyi görmez. Her bölmede yalnızca o anki en iyi soruyu seçer; “şimdi kötü görünen ama iki adım sonra harika olacak” bir soruyu bulamaz. Buna aç gözlü (greedy) davranış denir ve karar ağaçlarının en büyük zayıflığıdır — 7. bölümdeki kırılganlığın da asıl sebebi.
Lab 1Bölme noktasını sen seç

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.

geçti kaldı seçtiğiniz eşik
Gözünüzden kaçmasın: en iyi eşik, iki sınıfın tam ortası değil. Algoritma “güzel duran” yeri değil, ağırlıklı safsızlığı en çok düşüren yeri seçer — ve kalabalık taraf ağır bastığı için seçim genelde azınlığın bulunduğu bölgeye kayar.

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.

04 · Haftanın merkez fikri

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.

Lab 2Derinlik kaydıracı: ezberi izle

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)


        
Sağdaki metin gerçek ağacın kendisidir. Ekranda gördüğünüz sınırı çizen kurallar, aşağıdaki kutuda satır satır yazılı. Hiçbir modelde bunu yapamazsınız — okunabilirlik dediğimiz şey tam olarak bu kutu.

Üç hâl, üç teşhis

Derinlik 1

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.

Derinlik 4

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.

Derinlik 10+

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.

Sınav skorunun düşmesi şaşırtıcı olmalı. Ağaca daha fazla özgürlük verdik ve daha kötü oldu. Bunun sebebi şu: eğitim verisindeki her nokta iki şey taşır — kural ve gürültü. Derinleşen ağaç ikisini ayırt edemez; ikisini birden öğrenir. Gürültü yeni veride tekrarlanmadığı için o ezber boşa gider.

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.

05 · Pratik

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.”

AyarPratik 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.
Hangisiyle başlanır? İkisi yeter: max_depth ve min_samples_leaf. Üçüncü bir ayar eklemek, 13. bölümde göreceğimiz arama uzayını gereksiz büyütür ve kazanç genelde ölçüm gürültüsünün içinde kaybolur.

“Ağaç bir yerde durmalı” fikrinin iki okunuşu

Önden durdurma

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.

Sonradan budama

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.

Pratikte nasıl görünür
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
)
random_state ağaçta neden gerekli? Ağaç deterministik görünür, ama iki soru aynı kazancı verdiğinde aralarından birini seçmek gerekir ve bu seçim rastgeledir. Değeri sabitlemezseniz aynı kodu iki kez çalıştırıp iki farklı ağaç görebilirsiniz — derste bu bir karışıklık, raporda bir güvenilirlik sorunu.
06 · Ağacın raporu

Ö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.

Önem neyi ölçer?
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?"
Lab 3Kayıt numarası neden “önemli” çıkıyor?

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

Önem nedensellik değildir. “Hastaneye yatış süresi” ölüm tahmininde en önemli sütun çıkabilir — ama uzun yatış ölüme sebep olmuyor; ikisi de aynı nedenin sonucu. Önem listesi birlikte değişenleri gösterir, sebebi değil.
Çok değerli sütunlar şişer. Benzersiz ya da çok çeşitli sütunlar (kimlik, bilet numarası, tarih damgası, serbest metin) bölmek için çok fırsat sunduğundan önem toplar. Labda gördüğünüz tuzak budur.
Birbirine benzeyen sütunlar önemi paylaşır. Veride hem “boy (cm)” hem “boy (inç)” varsa, ağaç ikisinden birini seçer ve diğerinin önemi sıfır görünür. “Bu sütun gereksiz” diye silmek, yanlış sonuç.
Budanmamış ağacın önem listesi okunmaz. Labda gördünüz: aynı veri, aynı algoritma, farklı budama → farklı rapor. Önce modeli düzeltin, sonra raporuna bakın.
Daha güvenilir alternatif: permütasyon önemi. Fikri çok sade — bir sütunun değerlerini satırlar arasında karıştırın (o sütunu bozun) ve modelin görmediği veride skorunun ne kadar düştüğünü ölçün. Düşmüyorsa o sütun gerçekten gereksizdir. Bu ölçü eğitim verisinin ezberinden etkilenmez; 12. bölümde Kaggle'da ikisini yan yana koyacağız.
07 · Kırılma noktası

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.

Lab 4Dört ağaç, aynı veri

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.

Niye bu kadar oynak? Çünkü ağaç aç gözlü: kökteki kararı yalnızca o anki en iyi kazanca göre verir. İki soru neredeyse eşit kazanç veriyorsa, birkaç örneğin yer değiştirmesi sıralamayı çevirir — ve kök değişince altındaki bütün ağaç değişir. Hata küçük, sonuç büyük.
Bu, doğruluk sorunu değil — kararlılık sorunu. Dört ağacın skorları birbirine yakın olabilir. Ama müşteriye “geliriniz 18.000 altında olduğu için reddedildiniz” dediğiniz hafta, veriniz %5 değiştiğinde gerekçe “kredi geçmişiniz kısa” olursa anlattığınız hikâye çöker.

İki yoldan hangisi?

Yol 1 · işlemeyen

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.

Yol 2 · işleyen

Ç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.

Haftanın ikinci cümlesi: topluluk yöntemlerinin kazancı daha iyi modellerden değil, hataları birbirinden bağımsız modellerden gelir. Bu yüzden kırılgan bir model (karar ağacı) topluluk için iyi bir hammaddedir — kararlı bir model (doğrusal regresyon) ise pek işe yaramaz: yüz tanesi de aynı cevabı verir.
08 · Topluluk · 1

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.

N kez bootstrap örneklemi çek. Her biri aynı boyutta, ama içeriği farklı.
Her örnekleme bir ağaç kur. Ağaçlar birbirinden habersiz; istenirse hepsi aynı anda, paralel kurulabilir.
Tahmin isterken hepsine sor. Sınıflandırmada çoğunluk oyu, sayı tahmininde ortalama. Bitti.
Lab 5Kaç ağaç yeter?

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

Kazanç erken gelir 1 → 10 ağaç arası büyük bir atlama, 20 → 60 arası neredeyse yatay. Bu yüzden pratikte 100–500 ağaç kullanılır: fazlası zarar vermez, ama faydası da yoktur.
Topluluk aşırı öğrenmez Ağaç eklemek skoru bozmaz — sadece hızı düşürür. Bu, boosting'in tam tersidir (10. bölüm). Topluluğun büyüklüğü bir ayar değil, bir bütçe kararıdır.
Oylamanın bedeli okunabilirlik Artık 60 ağaç var. “Neden reddedildim?” sorusuna 60 farklı cümle çıkıyor. Kazandığımız doğruluğun karşılığında kaybettiğimiz şey gerekçedir.
Bedava ölçüm: OOB skoru. Her bootstrap örneklemi, verinin ortalama %37'sini hiç içermez (matematiği: büyük n için 1/e). Bir ağaç, kendi örnekleminde bulunmayan örnekler üzerinde sınava girebilir. Bütün ağaçlar için bunu yapıp birleştirirseniz ayrı bir test seti ayırmadan dürüst bir skor elde edersiniz. scikit-learn'de oob_score=True. Veriniz azsa altın değerinde.
09 · Topluluk · 2

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.

Random Forest'ın ek kuralı: her bölmede bütün sütunlar değil, rastgele seçilmiş bir kısmı denenir. Sınıflandırmada tipik olarak √(sütun sayısı) kadar. Böylece güçlü sütun bazı bölmelerde hiç masada olmaz ve ağaç başka bir yoldan ilerlemek zorunda kalır.

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.

Haftanın üçüncü cümlesi: topluluk kurarken her bir üyeyi zayıflatan bir müdahale topluluğu güçlendirebilir. Çünkü ölçtüğümüz şey tek üyenin başarısı değil, üyelerin hatalarının birbirine benzememesi.

scikit-learn'de hangi ayar ne yapar?

AyarPratik değerAçıklama
n_estimators300 – 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_leaf1 – 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_depthNone 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.
Sık sorulan soru: “Orman aşırı öğrenmez diyoruz, o zaman neden min_samples_leaf var?” Çünkü aşırı öğrenmez cümlesi “ağaç sayısı artınca skor bozulmaz” demek — “her ayar serbest” demek değil. Çok gürültülü veride ağaçlar aynı gürültüyü ezberlerse oylama onu düzeltmez, pekiştirir.
10 · Topluluk · 3

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

paralel · bağımsız · eşit oy
  • 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.
Amacı: kırılganlığı (varyansı) azaltmak. Tek ağacın savrulmasını ortalamayla bastırır.

Boosting

sıralı · bağımlı · küçük adımlar
  • 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.
Amacı: eksikliği (yanlılığı) azaltmak. Yavaş yavaş kuralın şeklini kurar.

Gradient boosting'in mekanizması üç satırda:

Boosting döngüsü
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)
Lab 6Artıkların kısalışını izle

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).

Üç deney yapın:
① 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

AdaBoost (1995) İlk çalışan boosting. Hataya bakmak yerine yanlış bilinen örneklerin ağırlığını arttırır. Fikrin ilk ispatı; bugün pratikte az kullanılır.
Gradient Boosting Labdaki yöntem: her tur artıklara bir ağaç uydurulur. Genel çerçeve — kayıp fonksiyonunu değiştirip sınıflandırmaya da regresyona da uygulanır.
XGBoost / LightGBM / HistGB Aynı fikrin hızlı ve düzenlileştirilmiş hâlleri: histogram tabanlı bölme, eksik veriyi yönetme, erken durdurma. Kaggle tablo yarışmalarının standardı. scikit-learn içindeki karşılığı HistGradientBoostingClassifier.
Boosting'in iki ayarı birbirine bağlıdır. Öğrenme hızını yarıya indirirseniz, aynı yere varmak için yaklaşık iki kat ağaç gerekir. Bu yüzden hız ve ağaç sayısı ayrı ayrı aranmaz: hız sabitlenir (0,05–0,1), ağaç sayısı ise erken durdurma ile bulunur — doğrulama skoru iyileşmeyi bıraktığında durulur.
11 · Karar

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İyiYokParalel Nadiren tek başına. Pratikte hep random forest tercih edilir; torbalama fikri anlamak için önemli.
Random ForestÇok iyiYokParalel Varsayılan seçiminiz. Ayar yapmadan iyi sonuç verir, aşırı öğrenmez, OOB skoru bedava gelir. “Önce bunu dene” modeli.
Gradient boostingEn iyiYokSıralı Son yüzde birleri kovalarken. Ayar hassasiyeti yüksek, aşırı öğrenebilir, doğrulama disiplini şart. Tablo verisinde zirve burada.
Tablo verisinde ağaçlar hâlâ kazanıyor. Satır-sütun hâlinde, sütunları farklı birimlerde (yaş, maaş, şehir, ürün kategorisi) olan verilerde ağaç toplulukları sinir ağlarını genellikle geçer. Sinir ağının üstün olduğu yerler görüntü, ses ve metin — yani komşuluk ya da sıra bilgisi taşıyan veriler. 4. haftada CNN'i görüntüde kullandık; bu hafta tabloda ağacı kullanıyoruz. Model seçimi veri türüyle başlar.

Peki okunabilirlik tamamen gitti mi?

Hayır — ama şekli değişti. Orman tek bir cümle vermez, fakat soru bazında cevap verebilir:

Öznitelik önemi “Genel olarak hangi sütunlar işe yarıyor?” Ormanda ağaçların önemleri ortalanır, tek ağaçtan daha kararlı çıkar.
Permütasyon önemi “Bu sütunu bozarsam skor düşer mi?” Modelden bağımsız, görmediği veride ölçülür. 6. bölümün tuzaklarına karşı en iyi savunma.
Kısmi bağımlılık “Yaş arttıkça tahmin nasıl değişiyor?” Tek sütunu süpürüp ortalama tahmini çizer — ilişkinin yönünü gösterir.
Vekil ağaç Ormanın tahminlerini etiket kabul edip üzerine derinlik-3 bir ağaç kurmak. Ormanın yaptığının kaba ama okunabilir bir özeti.

Bu dördünden ilk ikisini 12. bölümde Kaggle'da kodla göreceğiz.

12 · Uygulama

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.

Derse başlamadan üç ayar:
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.
📓
Bu bölümün bütün kodları hazır notebook'ta İndirip Kaggle'da Code → New Notebook → File → Import Notebook ile açın. Titanic yarışmasına katıldıktan sonra tek tuşla baştan sona çalışır ve submission.csv üretir.
Notebook'u indir

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.

hücre 1
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])
Çıktı
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
%61,62 bedava geliyor. Bu sayının altında kalan hiçbir model rapora yazılmaz. Sonraki adımlarda göreceğiniz %80'lerin anlamı da buradan okunur: taban çizgisinin 18 puan üstü.

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.

hücre 2
# 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))
Çıktı
(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
Cabin sütununu neden almadık? 891 satırın 687'si boş. Doldurmak uydurmak olur, atmak bilgi kaybı — ama %77 eksik bir sütundan çıkarılacak kural güvenilmez. (İsteyen “kabin bilgisi var mı yok mu?” diye tek bir 0/1 sütun türetebilir; ödevde deneyebilirsiniz.)

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.

hücre 3
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))
Çıktı
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
Bu ağacı Türkçeye çevirin: “Kadınsan ve 1.–2. sınıftaysan kurtuldun. Kadınsan ve 3. sınıftaysan, bileti pahalı değilse kurtuldun — pahalıysa kurtulmadın. Erkeksen, 6 yaşından küçük ve kalabalık bir ailede değilsen kurtuldun; aksi hâlde kurtulmadın.”

İ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?

hücre 4
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}")
Çıktı
 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
Tablo üç şeyi birden anlatıyor:
① 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.

hücre 5
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));
Çıktı
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]
± işaretinden sonraki sayı raporun en önemli parçasıdır. Budanmış ağacın yayılımı 0,0105; budanmamışın 0,0206 — iki katı. Ezberleyen model yalnızca daha kötü değil, aynı zamanda daha oynak: hangi veriyi gördüğüne göre skoru zıplıyor. 7. bölümdeki kırılganlık, sayı hâlinde işte bu.

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.

hücre 6
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));
Çıktı
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]
İki şey kanıtlandı:
① 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ı.

hücre 7
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));
Çıktı
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]
Son satır haftanın en önemli ölçümü. Aynı model, tek fark ağaç sayısının zorla 500'de tutulması: skor 0,8305'ten 0,8137'ye düştü ve yayılım büyüdü. Lab 6'da üçüncü deneyde gördüğünüz şey bu.

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.

hücre 8
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))
Çıktı
                           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
Tabloyu okumanın doğru yolu: en üstteki üç model (0,8305 / 0,8260 / 0,8148) arasındaki farklar yayılımların mertebesinde. Yani “boosting kazandı” demek yerine şunu demek gerekir: “üçü de taban çizgisini 20 puan geçti; aralarındaki fark bu veri boyutunda ölçülemiyor.”

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.

hücre 9
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())
Çıktı
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
Budanmamış ağaç, anlamsız bir sütuna önemin %14'ünü verdi — Pclass'tan iki kat fazla. Sebebi 6. bölümdeki tuzağın aynısı: benzersiz bir sütunla ağaç her yolcuyu tek başına kutuya koyabiliyor ve eğitim verisinde safsızlığı sıfıra indirebiliyor.

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?

hücre 10
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())
Çıktı
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
PassengerId en altta ve değeri negatif. Negatif olması şu demek: o sütunu bozmak modeli biraz iyileştirdi — yani sütun yalnızca gereksiz değil, zararlı. Gini önemi onu 4. sıraya koymuşken permütasyon önemi son sıraya attı.

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.

hücre 11
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))
Çıktı
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
Doğruluk %82,1 ama iki sınıf aynı değil. “Kurtuldu” sınıfının duyarlılığı 0,729: gerçekten kurtulan 85 kişinin 23'ünü kaçırdık. “Ölmedi” sınıfında ise 0,877. Model azınlık sınıfta daha kötü — 5. haftanın beklediği tablo.

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.

hücre 12
# 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())
Çıktı
(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
Teslim etmeden önce iki kontrol:
① 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.
13 · Dürüst ölçüm

Ç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.
Haftanın en pahalı hatası: “leaderboard skoru düştü, ayarı geri alalım” diyerek public skora bakarak model seçmek. Bunu 20 kez yaparsanız, public skorun en yükseğini veren ayarı bulursunuz — ve o ayar public kümeye uyarlanmış olur. Yarışma bitince private skorda sıralamanın altına düşersiniz. Kural: ayarı yerel çapraz doğrulamayla seçin, leaderboard'u yalnızca bir kontrol olarak kullanın.

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

hücre 13
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))
Çıktı
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
return_train_score=True yazmayı alışkanlık yapın. Son satıra bakın: eğitim 0,9851, sınav 0,7766. Bu satır size “bu ayar ezberliyor” diye bağırıyor. Yalnızca mean_test_score'a bakarsanız hangi ayarın neden kaybettiğini anlamazsınız, sadece kaybettiğini bilirsiniz.

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.

hücre 14
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))
Çıktı
Gercek etiketlerle : 0.8215
Karisik etiketlerle: 0.5882
Taban cizgisi      : 0.6162
Karışık etiketlerle skor taban çizgisinin bile altına indi (0,5882). Bu iyi haber: model veride gerçek bir örüntü bulmuş, uydurmamış. Eğer karışık etiketlerle 0,75 gibi bir sayı gelseydi, modelin bir şekilde cevabı “görüyor” olduğunu anlardık — sızıntı. Bu testi her projenizde yapın; iki satır ve hayat kurtarır.
14 · Tuzaklar

Bu haftaya özel yedi tuzak

Her biri gerçek projelerde görülmüş hatalar. Belirti, sebep ve çözüm sırasıyla.

BelirtiSebepÇö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.
Bir tuzak daha, tabloya sığmayan: kategorik sütunları LabelEncoder ile sayıya çevirmek. “İstanbul=0, Ankara=1, İzmir=2” yazdığınızda ağaç şehir ≤ 0,5 diye sorabilir ve uydurulmuş bir sıraya göre bölme yapar. Sırası olmayan sütunlar için one-hot (pd.get_dummies) ya da scikit-learn'ün OrdinalEncoder'ını ağaç-dostu modellerle (HistGradientBoosting, categorical_features) kullanın.
15 · Ödev

Ö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.

A şıkkı · zorunlu

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.

B şıkkı · isteğe bağlı

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ı).
Değerlendirmede en çok puan kaybettiren üç şey:
  • 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ı.

16 · Kapanış

Özet, kontrol listesi ve ders sonu testi

Bu haftanın zihinsel modeli

Ağaç bir soru dizisidir. Her soru tek bir sütuna bakar, veriyi ikiye böler; safsızlığı en çok düşüren soru seçilir. Algoritmanın tamamı bu.
Ağaç kendi kendine durmaz. Sınırlamazsanız her yaprakta tek örnek kalır ve eğitim doğruluğu %100 olur — hiçbir şey öğrenmemiş hâlde.
En etkili tek ayar min_samples_leaf. Titanic'te budanmamış ağaçtan budanmışa geçiş 4 puan getirdi; model değiştirmek 1,5 puan.
Önem listesi “bölmeye yaradı” der, “etkili” demez. Benzersiz sütunlar şişer, benzer sütunlar önemi paylaşır. Karar verirken permütasyon önemine bakın.
Tek ağaç kırılgandır. Verinin %5'i değişince kökteki soru bile değişebilir. Çözüm ağacı düzeltmek değil, çoğaltmak.
Topluluğun kazancı bağımsızlıktan gelir. Üyeleri zayıflatan bir müdahale (rastgele sütun) topluluğu güçlendirebilir — çünkü ölçtüğümüz şey hataların birbirine benzememesi.
Orman paralel ve affedici, boosting sıralı ve hassas. Ormanda ağaç eklemek zarar vermez; boosting'te bir noktadan sonra verir. Erken durdurma pazarlık konusu değil.
İki modelin farkı yayılımdan küçükse o fark yoktur. Tek bölünmeye değil çapraz doğrulamaya, tek sayıya değil ortalama ± yayılıma bakın.

Ağaç tabanlı bir model teslim ederken kontrol listesi

📝
Ders sonu testi — 10 soru Bu haftanın on altı bölümünü tarayan çoktan seçmeli test. Ders Sonu Testi uygulamasında hazır örnek olarak duruyor: Yapay Zeka — 6. Hafta.
Testi aç

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.