Makine Öğrenmesi / Orta / Ders 07

Ders 07 · Orta · ~55 dk

Karar ağaçları

Deprem yönetmeliğindeki zemin sınıfı tablosunu veriden geri bulan bir ağaçla başlayacağız; sonra bir regresyon ağacını sıfırdan yazıp katmanlı bir zemin profiline uyduracak, budamayı ve ağaçların eğitim aralığının dışında neden düzleştiğini göreceğiz.

Bu derste öğrenecekleriniz

  • Gini safsızlığını, entropiyi ve bilgi kazancını hesaplamak
  • Açgözlü özyinelemeli bölmeyle bir regresyon ağacını NumPy ile sıfırdan yazmak
  • Okunabilir kuralları export_text ile çıkarıp yorumlamak
  • Maliyet–karmaşıklık budamasını çapraz doğrulamayla ayarlamak
  • Safsızlık öneminin yanlılığını, ağaçların kararsızlığını ve dış değer sorununu açıklamak
Seviye
Orta
Süre
~55 dk
Kütüphaneler
NumPy, scikit-learn, Matplotlib

1. Problem: zemin sınıfını kurallarla belirlemek

Türkiye Bina Deprem Yönetmeliği (TBDY 2018), deprem tasarımında kullanılan yerel zemin sınıflarını Tablo 16.1'de tanımlar. Sınıf, temel olarak üst 30 metrenin ortalama kayma dalgası hızına, $(V_S)_{30}$'a göre belirlenir; tabloda zemin sınıfları için SPT darbe sayısı $(N_{60})_{30}$ ve drenajsız kayma dayanımı $(c_u)_{30}$ sınırları da verilir. Aşağıdaki özet, sayısal sınırları gösteriyor (zemin tanımları kısaltılmıştır):

Yerel zemin sınıfları ve sayısal sınırları (TBDY 2018, Tablo 16.1'den özet)
SınıfZemin (kısaca)(VS)30 (m/s)(N60)30(cu)30 (kPa)
ZASağlam, sert kaya> 1500——
ZBAz ayrışmış, orta sağlam kaya760–1500——
ZCÇok sıkı kum ve çakıl, sert kil; ayrışmış zayıf kaya360–760> 50> 250
ZDOrta sıkı–sıkı kum ve çakıl, çok katı kil180–36015–5070–250
ZEGevşek kum ve çakıl, yumuşak–katı kil< 180< 15< 70

Tablonun bir de ZF sınıfı vardır: sahaya özel araştırma gerektiren zeminler. Bu sınıf eşiklerle tanımlanmadığı için örneğimizin dışında. $(V_S)_{30}$, kalınlığı $h_i$ ve hızı $V_{S,i}$ olan katmanlardan şöyle hesaplanır:

$$ (V_S)_{30} = \frac{30}{\sum_i h_i / V_{S,i}} $$

Bu basit bir ortalama değildir: payda, dalganın 30 metreyi katetme süresidir. $(V_S)_{30}$, aynı sürede 30 metreyi geçen tek düzgün tabakanın hızıdır.

Tablonun kendisi bir karar ağacıdır: sırayla sorulan eşik soruları ve her sorunun sonunda bir sınıf. Bu derste soruyu ters çeviriyoruz: elimizde yalnızca etiketli profiller olsaydı, bir algoritma bu kuralları veriden bulabilir miydi? Bunu sınamak için 600 sentetik profil ürettik. $(V_S)_{30}$, 100–2000 m/s aralığında logaritmik olarak düzgün dağılımlı; sınıf etiketleri yalnızca tablodaki $(V_S)_{30}$ eşiklerinden geliyor. $N_{60}$ ve $c_u$ ise $(V_S)_{30}$'a uydurma bağıntılarla ve yüzde 25 mertebesinde lognormal gürültüyle bağlı:

$$ (N_{60})_{30} = 15\,\Big(\frac{(V_S)_{30}}{180}\Big)^{1{,}737} $$ $$ (c_u)_{30} = 70\,\Big(\frac{(V_S)_{30}}{180}\Big)^{1{,}837}\ \text{kPa} $$

Üsler, tablodaki sınırları birbirine bağlayacak biçimde seçildi: 180 m/s'ye 15 darbe ve 70 kPa, 360 m/s'ye 50 darbe ve 250 kPa karşılık geliyor. $(N_{60})_{30}$ 100 darbede (refü), $(c_u)_{30}$ 600 kPa'da kesildi. Bundan sonra kısaca $N_{60}$ ve $c_u$ yazacağız. Sınıf sayıları ZA 53, ZB 136, ZC 160, ZD 121, ZE 130; verinin yüzde 70'i eğitime, yüzde 30'u teste ayrıldı.

Mühendislik notu

Bu örnek ne iddia etmiyor?

Yerel zemin sınıfını yönetmelik tablosu ve sahaya özel inceleme belirler; bir makine öğrenmesi modeli değil. $N_{60}$ ve $c_u$ ile $(V_S)_{30}$ arasındaki bağıntılarımız uydurmadır; gerçek korelasyonlar çok daha saçılımlıdır ve zemin türüne göre değişir. Gerçek bir profilde kumlu tabakalarda SPT, killi tabakalarda $c_u$ ölçülür; biz sadelik için her profile ikisini de verdik. Örneğin tek amacı, ağacın okunabilir kuralları veriden geri bulabildiğini göstermek.

2. Ağaç nasıl karar verir?

Bir karar ağacı, tepedeki kök düğümden başlayıp aşağı doğru sorular sorar. Her iç düğüm tek bir özellik hakkında “$x_j \le t$ mi?” diye sorar; cevap evetse örnek sola, hayırsa sağa gider. Sorular bittiğinde örnek bir yaprağa ulaşır ve tahmin oradan okunur:

  • Sınıflandırmada yaprağın tahmini, o yapraktaki eğitim örneklerinin çoğunluk sınıfıdır. Sınıf oranları da olasılık tahmini olarak kullanılır (predict_proba).
  • Regresyonda yaprağın tahmini, o yapraktaki hedef değerlerin ortalamasıdır.

Geometrik olarak ağaç, özellik uzayını eksenlere paralel dikdörtgenlere böler ve her dikdörtgene sabit bir tahmin atar (Şekil 2, sol). Önceki dersteki yöntemlerden iki önemli farkı vardır. Uzaklık hesaplamadığı için özelliklerin ölçeğiyle ilgilenmez; ölçekleme gerekmez. Ve kökten yaprağa her yol bir kuraldır: “$(V_S)_{30} > 179{,}2$ ve $(V_S)_{30} \le 361{,}5$ ise ZD” gibi. Bir mühendis bu kuralı okuyup sorgulayabilir.

3. Bölünmeyi seçmek: safsızlık ölçütleri

Her düğümde hangi özelliğin hangi eşikle bölüneceğine karar vermek için bir ölçüt gerekir. Fikir şudur: iyi bir bölünme, çocuk düğümleri olabildiğince “saf” yapar; yani her çocukta tek bir sınıf baskın olur. Bir düğümdeki sınıf oranları $p_k$ ise iki yaygın safsızlık (impurity) ölçüsü şunlardır:

$$ G = 1 - \sum_{k=1}^{K} p_k^2 $$ $$ H = -\sum_{k=1}^{K} p_k \log_2 p_k $$

$G$, Gini safsızlığıdır: düğümden rastgele seçilen bir örneğe, düğümün sınıf dağılımına göre rastgele bir etiket verilirse yanlış etiket verme olasılığıdır. $H$ ise entropidir (bit cinsinden belirsizlik). İkisi de saf bir düğümde sıfırdır ve sınıflar eşit dağıldığında en büyük değerini alır. Bir bölünmenin değeri, ebeveyn düğümün safsızlığından çocukların örnek sayısıyla ağırlıklandırılmış safsızlığının çıkarılmasıyla ölçülür:

$$ \begin{aligned} \Delta I = I(D) &- \frac{n_L}{n}\,I(D_L) \\ &- \frac{n_R}{n}\,I(D_R) \end{aligned} $$

$I$ yerine entropi konunca bu büyüklüğe bilgi kazancı (information gain) denir. ID3 algoritması bilgi kazancını, C4.5 bunun normalleştirilmiş biçimi olan kazanç oranını (gain ratio), CART ve scikit-learn'ün varsayılanı ise Gini'yi kullanır. Pratikte ikisi çoğu zaman çok benzer ağaçlar verir (Alıştırma 3).

Regresyonda sınıf oranı yoktur; safsızlığın yerini düğümdeki hedeflerin ortalamasından sapmaların kareler toplamı (SSE) alır:

$$ \mathrm{SSE}(D) = \sum_{i \in D} \big(y_i - \bar y_D\big)^2 $$

Yaprağın tahmini ortalama $\bar y_D$ olduğu için SSE, o yaprağın eğitim hatasının ta kendisidir. En iyi bölünme, iki çocuğun SSE toplamını en küçük yapandır.

Sezgi

Neden doğrudan hata oranı değil?

Bölünmeyi “yanlış sınıflandırma oranı” ile seçmek ilk akla gelendir, ama kötü çalışır. Birçok bölünme çoğunluk sınıfını değiştirmediği için hata oranını hiç azaltmaz; oysa çocuklardan birini daha saf yapmış olabilir ve sonraki bölünmelere zemin hazırlar. Gini ve entropi, sınıf oranlarının düzgün ve içbükey fonksiyonlarıdır; saflığa doğru atılan her adımı ödüllendirirler.

4. Açgözlü bölme ve durma kuralları

Bütün olası ağaçlar arasından en iyisini bulmak hesaplama açısından çok zordur (NP-tam). Bu yüzden ağaçlar açgözlü (greedy) ve özyinelemeli olarak büyütülür: her düğümde yalnızca o anki en iyi bölünme aranır, sonra iki çocuk için aynı işlem tekrarlanır. Bir düğümde en iyi bölünmeyi bulmak için her özellik sıralanır, ardışık iki farklı değerin ortası aday eşik olarak denenir ve en büyük $\Delta I$'yı veren (özellik, eşik) çifti seçilir.

Büyüme şu durumlardan biri olunca durur: düğüm saftır, ya da kullanıcının koyduğu bir sınıra ulaşılmıştır. scikit-learn'deki başlıca sınırlar max_depth (en büyük derinlik), min_samples_split (bölünecek düğümdeki en az örnek), min_samples_leaf (yapraktaki en az örnek), max_leaf_nodes ve min_impurity_decrease'dir. Hiçbir sınır konmazsa ağaç her yaprak saf olana kadar büyür ve eğitim verisini ezberler. Bu tür sınırlara ön budama denir; ağaç büyüdükten sonra yapılan budamayı 8. bölümde göreceğiz.

5. Sıfırdan regresyon ağacı

Algoritmayı çıplak hâliyle görmek için tek özellikli bir regresyon ağacını NumPy ile yazdık. Örnek bir zemin profili: 30 metre derinliğe kadar her 0,5 m'de ölçülmüş 60 kayma dalgası hızı. Gerçek profil dört katmanlıdır; katman sınırları 4, 11 ve 19 m'de, her katmanın içinde hız derinlikle hafifçe artıyor. Ölçümlere standart sapması 20 m/s olan gürültü eklendi. Bir regresyon ağacının derinliğe göre bölünmesi, burada doğrudan katman sınırı aramak demektir.

Derinlik sınırlı regresyon ağacı, sıfırdan (koddan)
def agac_kur(x, y, derinlik, en_cok):
    if derinlik == en_cok or len(y) < 2 or np.all(y == y[0]):
        return {"deger": y.mean()}
    sira = np.argsort(x, kind="stable")
    xs, ys = x[sira], y[sira]
    S, Q, m = np.cumsum(ys), np.cumsum(ys ** 2), len(ys)
    nl = np.arange(1, m)                                   # soldaki örnek sayısı
    sse = (Q[:-1] - S[:-1] ** 2 / nl) + ((Q[-1] - Q[:-1]) - (S[-1] - S[:-1]) ** 2 / (m - nl))
    sse[xs[1:] <= xs[:-1]] = np.inf                        # eşit x değerlerinin arası bölünemez
    if not np.isfinite(sse).any():                         # bütün x'ler aynı: bölünecek yer yok
        return {"deger": y.mean()}
    i = int(np.argmin(sse))
    esik = (xs[i] + xs[i + 1]) / 2                         # iki komşu değerin ortası
    sol = x <= esik
    return {"esik": esik, "sol": agac_kur(x[sol], y[sol], derinlik + 1, en_cok),
            "sag": agac_kur(x[~sol], y[~sol], derinlik + 1, en_cok)}

Fonksiyonun püf noktası, bütün aday eşikleri tek geçişte değerlendirmesidir. Bir kümenin kareler toplamı $\mathrm{SSE} = \sum y^2 - (\sum y)^2/n$ biçiminde yazılabilir. Sıralanmış verinin birikimli toplamları (np.cumsum) her olası sol küme için $\sum y$ ve $\sum y^2$'yi hazır verir; sağ küme de toplamdan farkla bulunur. Böylece $m$ örnekli bir düğümde bütün eşikler, sıralama dışında $O(m)$ işlemle taranır. scikit-learn de aynı yolu izler.

Sonuçta sıfırdan yazdığımız ağaç, aynı derinlikteki DecisionTreeRegressor ile aynı tahminleri veriyor. Derinlik 1, 2, 3 ve 8 için iki ağacın 3.001 noktalık bir ızgaradaki tahminleri arasındaki en büyük fark $1{,}1\times10^{-13}$ m/s, yani yuvarlama düzeyinde.

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

Kod beş bölümden oluşur: (1) zemin sınıfı ağacı; (2) $(V_S)_{30}$ olmadan budama, önem ve kararsızlık deneyleri; (3) sıfırdan regresyon ağacı; (4) kiriş sehiminde dış değer deneyi; (5) grafikler. Kurulum için Ders 01'deki adımları izleyin.

d07_karar_agaclari.py271 satır · Pythonİndir
"""Ders 07 — Karar ağaçları.

Üç sentetik örnek kullanıyoruz:
1. Zemin sınıfı: (Vs)30, (N60)30 ve (cu)30'dan TBDY 2018 yerel zemin sınıfları (ZA–ZE).
   Etiketler yalnız (Vs)30 eşiklerinden gelir (180, 360, 760, 1500 m/s); N60 ve cu, Vs30'a
   gürültülü ve uydurma bağıntılarla bağlıdır (gerçek bir korelasyon değildir). Ağacın
   tablodaki eşikleri geri bulup bulmadığına bakıyoruz.
2. Regresyon: katmanlı bir zemin profilinde kayma dalgası hızı–derinlik ölçümleri (sentetik).
   Derinlik sınırlı regresyon ağacını NumPy ile sıfırdan kurup scikit-learn ile karşılaştırıyoruz.
3. Dış değer: basit kirişin orta açıklık sehimi δ = 5qL⁴/(384EI); eğitim açıklığı 2–6 m,
   tahmin 9 m'ye kadar.

Çalıştır:  python d07_karar_agaclari.py
Gerekenler: numpy, scikit-learn, matplotlib  (Python 3.12+)
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from matplotlib.lines import Line2D
from matplotlib.ticker import NullFormatter
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor, export_text

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

# %% 1. Zemin sınıfı ağacı: Vs30, N60 ve cu
rng = np.random.default_rng(42)
n = 600
vs30 = np.exp(rng.uniform(np.log(100), np.log(2000), n))                   # m/s, log-düzgün
# Uydurma bağıntılar, tablodaki sınırları birbirine bağlar:
# Vs30 = 180 ↔ N60 = 15 ↔ cu = 70 kPa ve Vs30 = 360 ↔ N60 = 50 ↔ cu = 250 kPa
n60 = np.minimum(15 * (vs30 / 180) ** 1.737 * rng.lognormal(0, 0.25, n), 100)   # 100 = refü
cu = np.minimum(70 * (vs30 / 180) ** 1.837 * rng.lognormal(0, 0.25, n), 600)    # kPa, üst sınır
sinif = np.select([vs30 > 1500, vs30 > 760, vs30 > 360, vs30 > 180], ["ZA", "ZB", "ZC", "ZD"], "ZE")
X1 = np.column_stack([vs30, n60, cu])
X1_eg, X1_te, s1_eg, s1_te = train_test_split(X1, sinif, test_size=0.3, random_state=42, stratify=sinif)
agac1 = DecisionTreeClassifier(max_depth=4, random_state=42).fit(X1_eg, s1_eg)
esikler1 = np.sort(agac1.tree_.threshold[agac1.tree_.feature == 0])
print("=== 1. Zemin sınıfı ağacı (600 profil: " + ", ".join(f"{s} {np.sum(sinif == s)}" for s in
                                                       ["ZA", "ZB", "ZC", "ZD", "ZE"]) + ") ===")
print(f"Ağaç (derinlik ≤ 4): {agac1.get_n_leaves()} yaprak, eğitim {agac1.score(X1_eg, s1_eg):.3f}, "
      f"test {agac1.score(X1_te, s1_te):.3f}")
print(export_text(agac1, feature_names=["Vs30", "N60", "cu"], decimals=1).rstrip())
print("Öğrenilen Vs30 eşikleri: " + " / ".join(f"{e:.1f}" for e in esikler1)
      + " m/s (tablo: 180 / 360 / 760 / 1500)")
print("Özellik önemleri: " + ", ".join(f"{a} {v:.3f}" for a, v in zip(["Vs30", "N60", "cu"],
                                                                     agac1.feature_importances_)))

# %% 2. Vs30 ölçülmemişse: yalnız N60 ve cu ile zemin sınıfları (ZC, ZD, ZE)
zemin = vs30 < 760                                         # kaya sınıflarında SPT ve cu anlamlı değil
gurultu = rng.uniform(0, 1, n)                             # sınıfla hiç ilgisi olmayan bir sütun
X2 = np.column_stack([n60, cu, gurultu])[zemin]
s2 = sinif[zemin]
X2_eg, X2_te, s2_eg, s2_te = train_test_split(X2, s2, test_size=0.3, random_state=42, stratify=s2)
tam = DecisionTreeClassifier(random_state=42).fit(X2_eg, s2_eg)
yol = tam.cost_complexity_pruning_path(X2_eg, s2_eg)
alfalar = yol.ccp_alphas[:-1]                              # sonuncusu yalnız kökten oluşan ağaç
kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
cv_alfa = np.array([cross_val_score(DecisionTreeClassifier(random_state=42, ccp_alpha=a), X2_eg, s2_eg,
                                    cv=kfold).mean() for a in alfalar])
eg_alfa = np.array([DecisionTreeClassifier(random_state=42, ccp_alpha=a).fit(X2_eg, s2_eg).score(X2_eg, s2_eg)
                    for a in alfalar])
alfa_iyi = alfalar[np.isclose(cv_alfa, cv_alfa.max())].max()   # eşitlikte daha sade ağaç
budanmis = DecisionTreeClassifier(random_state=42, ccp_alpha=alfa_iyi).fit(X2_eg, s2_eg)
ad2 = ["N60", "cu", "gürültü"]
print(f"\n=== 2. Vs30 yoksa: N60, cu ve bir gürültü sütunu ({zemin.sum()} zemin profili, ZC–ZE) ===")
print(f"Budamasız  : {tam.get_n_leaves()} yaprak, derinlik {tam.get_depth()}, "
      f"eğitim {tam.score(X2_eg, s2_eg):.3f}, test {tam.score(X2_te, s2_te):.3f}")
print(f"Budanmış   : ccp_alpha = {alfa_iyi:.4f} (5 katlı CV {cv_alfa.max():.3f}), "
      f"{budanmis.get_n_leaves()} yaprak, eğitim {budanmis.score(X2_eg, s2_eg):.3f}, "
      f"test {budanmis.score(X2_te, s2_te):.3f}")
onem = zip(ad2, tam.feature_importances_, budanmis.feature_importances_)
print("Önem (budamasız → budanmış): " + ", ".join(f"{a} {v1:.3f} → {v2:.3f}" for a, v1, v2 in onem))
for j, (a, tablo) in enumerate([("N60", "15 / 50 darbe"), ("cu", "70 / 250 kPa")]):
    e_j = np.sort(budanmis.tree_.threshold[budanmis.tree_.feature == j])
    print(f"Budanmış ağaçta {a} eşikleri: " + ", ".join(f"{e:.1f}" for e in e_j) + f" (tablo: {tablo})")
olcek = StandardScaler().fit(X2_eg)
olcekli = DecisionTreeClassifier(random_state=42, ccp_alpha=alfa_iyi).fit(olcek.transform(X2_eg), s2_eg)
ayni = np.sum(olcekli.predict(olcek.transform(X2_te)) == budanmis.predict(X2_te))
print(f"Standartlaştırılmış özelliklerle aynı tahmin: {ayni}/{len(s2_te)} (ölçek ağacı etkilemez)")
kokler, tahminler = [], []
for b in range(5):                                         # aynı veriden 5 bootstrap örneklemi
    i = rng.integers(0, len(s2_eg), len(s2_eg))
    ag = DecisionTreeClassifier(random_state=42).fit(X2_eg[i], s2_eg[i])
    kokler.append(f"{ad2[ag.tree_.feature[0]]} ≤ {ag.tree_.threshold[0]:.1f}")
    tahminler.append(ag.predict(X2_te))
tahminler = np.array(tahminler)
degisen = np.mean([len(set(tahminler[:, j])) > 1 for j in range(tahminler.shape[1])])
print("5 bootstrap ağacının kök bölünmesi: " + "; ".join(kokler))
print(f"Tahmini en az bir ağaçta farklı çıkan test profili: %{100 * degisen:.0f}")


# %% 3. Sıfırdan regresyon ağacı: katmanlı zeminde Vs–derinlik profili
def vs_gercek(z):
    """Dört katmanlı sentetik profil (m/s); sınırlar 4, 11 ve 19 m, katman içinde hafif artış."""
    return np.select([z < 4, z < 11, z < 19], [150 + 5 * z, 240 + 4 * (z - 4), 340 + 3 * (z - 11)],
                     520 + 2 * (z - 19))


z = np.arange(0.5, 30.01, 0.5)                             # ölçüm derinlikleri (m)
v = vs_gercek(z) + rng.normal(0, 20, z.size)               # ölçülen Vs, gürültü σ = 20 m/s


def agac_kur(x, y, derinlik, en_cok):
    """Kare hatalar toplamını (SSE) en çok azaltan eşikle böler; derinlik sınırına ya da saf düğüme
    ulaşana kadar özyinelemeli devam eder."""
    if derinlik == en_cok or len(y) < 2 or np.all(y == y[0]):
        return {"deger": y.mean()}
    sira = np.argsort(x, kind="stable")
    xs, ys = x[sira], y[sira]
    S, Q, m = np.cumsum(ys), np.cumsum(ys ** 2), len(ys)
    nl = np.arange(1, m)                                   # soldaki örnek sayısı
    sse = (Q[:-1] - S[:-1] ** 2 / nl) + ((Q[-1] - Q[:-1]) - (S[-1] - S[:-1]) ** 2 / (m - nl))
    sse[xs[1:] <= xs[:-1]] = np.inf                        # eşit x değerlerinin arası bölünemez
    if not np.isfinite(sse).any():                         # bütün x'ler aynı: bölünecek yer yok
        return {"deger": y.mean()}
    i = int(np.argmin(sse))
    esik = (xs[i] + xs[i + 1]) / 2                         # iki komşu değerin ortası
    sol = x <= esik
    return {"esik": esik, "sol": agac_kur(x[sol], y[sol], derinlik + 1, en_cok),
            "sag": agac_kur(x[~sol], y[~sol], derinlik + 1, en_cok)}


def agac_tahmin(dugum, x):
    if "deger" in dugum:
        return np.full(x.shape, dugum["deger"])
    sol = x <= dugum["esik"]
    sonuc = np.empty(x.shape)
    sonuc[sol] = agac_tahmin(dugum["sol"], x[sol])
    sonuc[~sol] = agac_tahmin(dugum["sag"], x[~sol])
    return sonuc


def esikler(dugum):
    return [] if "deger" in dugum else [dugum["esik"]] + esikler(dugum["sol"]) + esikler(dugum["sag"])


zz = np.linspace(0, 30, 3001)                              # karşılaştırma ve çizim ızgarası
zf = np.linspace(0, 30, 300_001)
vs30_gercek = 30 / np.trapezoid(1 / vs_gercek(zf), zf)     # (Vs)30 = 30 / Σ(hᵢ/Vᵢ)
print(f"\n=== 3. Sıfırdan regresyon ağacı (Vs–derinlik, 60 ölçüm; gerçek Vs30 = {vs30_gercek:.1f} m/s) ===")
print("derinlik  yaprak  RMSE ölçüm  RMSE gerçek  sklearn farkı   Vs30 (m/s)")
agaclar = {}
for D in (1, 2, 3, 8):
    a = agac_kur(z, v, 0, D)
    agaclar[D] = a
    skl = DecisionTreeRegressor(max_depth=D).fit(z.reshape(-1, 1), v)
    fark = np.abs(agac_tahmin(a, zz) - skl.predict(zz.reshape(-1, 1))).max()
    rmse_olcum = np.sqrt(np.mean((agac_tahmin(a, z) - v) ** 2))
    rmse_gercek = np.sqrt(np.mean((agac_tahmin(a, zz) - vs_gercek(zz)) ** 2))
    vs30_agac = 30 / np.trapezoid(1 / agac_tahmin(a, zf), zf)
    print(f"{D:5d}   {len(esikler(a)) + 1:6d}   {rmse_olcum:8.1f}   {rmse_gercek:9.1f}      {fark:.1e}   "
          f"{vs30_agac:8.1f}")
    assert fark < 1e-9
print("Derinlik 3 eşikleri: " + ", ".join(f"{e:.2f}" for e in sorted(esikler(agaclar[3])))
      + f" m (kök {agaclar[3]['esik']:.2f}; gerçek: 4, 11, 19 m)")

# %% 4. Dış değer: kiriş sehiminde ağaç, eğitim aralığının dışında sabit kalır
q, E, I = 10.0, 210_000.0, 8356e4                          # N/mm, MPa, mm⁴ (IPE 300, güçlü eksen)


def sehim(L):
    """Basit mesnetli, düzgün yayılı yüklü kirişte orta açıklık sehimi (mm); L metre."""
    return 5 * q * (L * 1000) ** 4 / (384 * E * I)


L_eg = rng.uniform(2, 6, 200)
d_eg = sehim(L_eg)
agac_L = DecisionTreeRegressor(max_depth=6, random_state=42).fit(L_eg.reshape(-1, 1), d_eg)
dogru_L4 = LinearRegression().fit((L_eg ** 4).reshape(-1, 1), d_eg)    # fiziği bilen özellik: L⁴
print("\n=== 4. Dış değer: kiriş sehimi (eğitim açıklığı 2–6 m, ağaç derinliği 6) ===")
print(" L (m)   analitik (mm)   ağaç (mm)   L⁴ ile doğrusal (mm)")
for L in (4.0, 6.0, 7.5, 9.0):
    d_agac, d_L4 = agac_L.predict([[L]])[0], dogru_L4.predict([[L ** 4]])[0]
    print(f"{L:5.1f}    {sehim(L):10.2f}    {d_agac:9.2f}    {d_L4:10.2f}")
print(f"Ağacın 6 m'nin ötesindeki tahmini sabit: {agac_L.predict([[6.5]])[0]:.2f} mm "
      f"(9 m'de hata %{100 * (agac_L.predict([[9.0]])[0] / sehim(9.0) - 1):.0f})")

# %% 5. Grafikler
# Şekil 1: regresyon ağacının derinliği ve Vs–derinlik profili
fig, ax = plt.subplots(2, 2, figsize=(10, 7.5), layout="constrained", sharex=True, sharey=True)
for a, D in zip(ax.ravel(), (1, 2, 3, 8)):
    a.scatter(v, z, s=14, color=SOLUK, label="Ölçüm (sentetik)")
    a.plot(vs_gercek(zz), zz, color=MUREKKEP, ls="--", lw=1.4, label="Gerçek profil")
    a.plot(agac_tahmin(agaclar[D], zz), zz, color=RENK[0], label="Regresyon ağacı")
    a.set_title(f"Derinlik {D}: {len(esikler(agaclar[D])) + 1} yaprak")
ax[0, 0].invert_yaxis()
for a in ax[1]:
    a.set_xlabel("Kayma dalgası hızı Vs (m/s)")
for a in ax[:, 0]:
    a.set_ylabel("Derinlik z (m)")
ax[0, 0].legend(loc="lower left", fontsize=9)
fig.savefig(KLASOR / "d07_karar_agaclari_1.png", dpi=160)
plt.close(fig)

# Şekil 2: budanmış ağacın bölgeleri (N60–cu) ve budama yolu
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
siniflar = ["ZC", "ZD", "ZE"]
NN, CC = np.meshgrid(np.geomspace(3, 100, 250), np.geomspace(15, 600, 250))
bolge = budanmis.predict(np.column_stack([NN.ravel(), CC.ravel(), np.full(NN.size, 0.5)]))
kod = np.searchsorted(siniflar, bolge).reshape(NN.shape)
ax[0].contourf(NN, CC, kod, levels=[-0.5, 0.5, 1.5, 2.5], cmap=ListedColormap(RENK[:3]), alpha=0.15)
isaret = {"ZC": "s", "ZD": "o", "ZE": "^"}
for k, s in enumerate(siniflar):
    m = s2_eg == s
    ax[0].scatter(X2_eg[m, 0], X2_eg[m, 1], s=14, marker=isaret[s], facecolors="none", edgecolors=RENK[k],
                  lw=0.9, label=f"{s} (eğitim)")
for e in (15, 50):
    ax[0].axvline(e, color=MUREKKEP, ls="--", lw=1.1)
for e in (70, 250):
    ax[0].axhline(e, color=MUREKKEP, ls="--", lw=1.1)
ax[0].set(xscale="log", yscale="log", xlim=(3, 100), ylim=(15, 600), xlabel="N60 (darbe/30 cm)",
          ylabel="cu (kPa)", title=f"Budanmış ağaç ({budanmis.get_n_leaves()} yaprak), tablo sınırları")
ax[0].set_xticks([3, 5, 10, 20, 50, 100], labels=["3", "5", "10", "20", "50", "100"])
ax[0].set_yticks([20, 50, 100, 200, 500], labels=["20", "50", "100", "200", "500"])
ax[0].xaxis.set_minor_formatter(NullFormatter())
ax[0].yaxis.set_minor_formatter(NullFormatter())
tut = ax[0].get_legend_handles_labels()[0] + [Line2D([], [], color=MUREKKEP, ls="--", lw=1.1)]
ax[0].legend(handles=tut, labels=[f"{s} (eğitim)" for s in siniflar] + ["Tablodaki sınırlar"],
             loc="upper left", fontsize=8, frameon=True, framealpha=0.9, edgecolor="white")
ax[1].semilogx(alfalar[1:], eg_alfa[1:], "-o", ms=3, color=RENK[0], drawstyle="steps-post",
               label="Eğitim doğruluğu")
ax[1].semilogx(alfalar[1:], cv_alfa[1:], "-o", ms=3, color=RENK[1], drawstyle="steps-post",
               label="5 katlı CV doğruluğu")
ax[1].axvline(alfa_iyi, color=MUREKKEP, ls="--", lw=1.2, label=f"Seçilen ccp_alpha = {alfa_iyi:.4f}")
ax[1].set(xlabel="ccp_alpha (log ölçek)", ylabel="Doğruluk", title="Maliyet–karmaşıklık budaması")
ax[1].legend(loc=(0.30, 0.06), fontsize=8)
fig.savefig(KLASOR / "d07_karar_agaclari_2.png", dpi=160)
plt.close(fig)

# Şekil 3: dış değer sorunu
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
LL = np.linspace(1.5, 9.5, 400)
for a in ax:
    a.axvspan(2, 6, color=SOLUK, alpha=0.12, lw=0)
ax[0].scatter(L_eg, d_eg, s=10, color=SOLUK, label="Eğitim verisi (2–6 m)")
ax[0].plot(LL, sehim(LL), color=MUREKKEP, ls="--", lw=1.4, label="Analitik: 5qL⁴/(384EI)")
ax[0].plot(LL, agac_L.predict(LL.reshape(-1, 1)), color=RENK[0], label="Regresyon ağacı (derinlik 6)")
ax[0].plot(LL, dogru_L4.predict((LL ** 4).reshape(-1, 1)), color=RENK[1], ls=":",
           label="L⁴ ile doğrusal model")
ax[0].set(xlabel="Açıklık L (m)", ylabel="Orta açıklık sehimi δ (mm)",
          title="Eğitim aralığının dışında ağaç düzleşir")
ax[0].legend(loc="upper left", fontsize=8)
hata = 100 * (agac_L.predict(LL.reshape(-1, 1)) / sehim(LL) - 1)
ax[1].plot(LL, hata, color=RENK[0], label="Regresyon ağacı")
ax[1].axhline(0, color=MUREKKEP, lw=1)
ax[1].set(xlabel="Açıklık L (m)", ylabel="Bağıl hata (%)", ylim=(-100, 40),
          title="Ağacın bağıl hatası")
ax[1].legend(loc="lower left", fontsize=8)
fig.savefig(KLASOR / "d07_karar_agaclari_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d07_karar_agaclari_1.png, _2.png, _3.png")

Terminal çıktısıpython d07_karar_agaclari.py
=== 1. Zemin sınıfı ağacı (600 profil: ZA 53, ZB 136, ZC 160, ZD 121, ZE 130) ===
Ağaç (derinlik ≤ 4): 5 yaprak, eğitim 1.000, test 0.994
|--- Vs30 <= 179.2
|   |--- class: ZE
|--- Vs30 >  179.2
|   |--- Vs30 <= 758.8
|   |   |--- Vs30 <= 361.5
|   |   |   |--- class: ZD
|   |   |--- Vs30 >  361.5
|   |   |   |--- class: ZC
|   |--- Vs30 >  758.8
|   |   |--- Vs30 <= 1507.5
|   |   |   |--- class: ZB
|   |   |--- Vs30 >  1507.5
|   |   |   |--- class: ZA
Öğrenilen Vs30 eşikleri: 179.2 / 361.5 / 758.8 / 1507.5 m/s (tablo: 180 / 360 / 760 / 1500)
Özellik önemleri: Vs30 1.000, N60 0.000, cu 0.000

=== 2. Vs30 yoksa: N60, cu ve bir gürültü sütunu (411 zemin profili, ZC–ZE) ===
Budamasız  : 23 yaprak, derinlik 9, eğitim 1.000, test 0.887
Budanmış   : ccp_alpha = 0.0050 (5 katlı CV 0.937), 6 yaprak, eğitim 0.962, test 0.911
Önem (budamasız → budanmış): N60 0.112 → 0.087, cu 0.851 → 0.913, gürültü 0.038 → 0.000
Budanmış ağaçta N60 eşikleri: 9.4, 20.7, 54.2 (tablo: 15 / 50 darbe)
Budanmış ağaçta cu eşikleri: 75.9, 264.6 (tablo: 70 / 250 kPa)
Standartlaştırılmış özelliklerle aynı tahmin: 124/124 (ölçek ağacı etkilemez)
5 bootstrap ağacının kök bölünmesi: N60 ≤ 54.2; cu ≤ 244.0; N60 ≤ 48.3; cu ≤ 264.6; cu ≤ 265.8
Tahmini en az bir ağaçta farklı çıkan test profili: %12

=== 3. Sıfırdan regresyon ağacı (Vs–derinlik, 60 ölçüm; gerçek Vs30 = 312.3 m/s) ===
derinlik  yaprak  RMSE ölçüm  RMSE gerçek  sklearn farkı   Vs30 (m/s)
    1        2       61.0        60.7      1.1e-13      340.0
    2        4       29.6        32.4      1.1e-13      324.8
    3        8       16.9        19.7      2.8e-14      317.1
    8       55        3.9        25.7      0.0e+00      315.1
Derinlik 3 eşikleri: 3.75, 10.75, 11.25, 18.75, 21.25, 22.75, 23.75 m (kök 18.75; gerçek: 4, 11, 19 m)

=== 4. Dış değer: kiriş sehimi (eğitim açıklığı 2–6 m, ağaç derinliği 6) ===
 L (m)   analitik (mm)   ağaç (mm)   L⁴ ile doğrusal (mm)
  4.0          1.90         1.91          1.90
  6.0          9.62         9.60          9.62
  7.5         23.48         9.60         23.48
  9.0         48.68         9.60         48.68
Ağacın 6 m'nin ötesindeki tahmini sabit: 9.60 mm (9 m'de hata %-80)

Grafikler kaydedildi: d07_karar_agaclari_1.png, _2.png, _3.png

7. Ağaç tablodaki kuralları buluyor mu?

Derinliği en fazla 4 olan ağaç, çıktıdaki kural listesini üretti (export_text). Okuması kolaydır: kökte “$(V_S)_{30} \le 179{,}2$ mi?” sorusu ZE'yi ayırıyor; sonra 758,8 m/s zeminleri kayadan, 361,5 m/s ZD'yi ZC'den, 1507,5 m/s de ZB'yi ZA'dan ayırıyor. Ağaç 5 yaprakla, yani sınıf başına tek yaprakla durdu; eğitim doğruluğu 1,000, test doğruluğu 0,994.

Ağacın öğrendiği (VS)30 eşikleri ve tablodaki değerler
SınırTablo (m/s)Ağaç (m/s)
ZE | ZD180179,2
ZD | ZC360361,5
ZC | ZB760758,8
ZB | ZA15001507,5

Eşikler tablodakilere yüzde 1'den daha yakın. Tam olarak 180 çıkmamaları bir hata değil: ağaç eşiği, sınırın iki yanındaki en yakın iki eğitim profilinin tam ortasına koyar. Bu iki profil birbirinden ne kadar uzaksa eşik o kadar belirsizdir. Test kümesinde yanlış sınıflanan tek profil de öğrenilen eşikle gerçek eşik arasındaki bu dar aralığa düşen bir profildir; etiketler yalnızca $(V_S)_{30}$'a bağlı olduğu için başka bir hata kaynağı yoktur. Özellik önemleri $(V_S)_{30}$ için 1,000, $N_{60}$ ve $c_u$ için 0,000: ağaç gürültülü kopyalara hiç başvurmadı, çünkü etiketi tek başına ve kusursuz belirleyen özelliği buldu.

$(V_S)_{30}$ ölçülmemişse

Daha ilginç soru, ağacın yalnızca $N_{60}$ ve $c_u$ ile ne yapacağı. Kaya sınıflarında SPT ve $c_u$ anlamlı olmadığı için bu deneyi $(V_S)_{30} < 760$ m/s olan 411 zemin profiliyle (ZC, ZD, ZE) yaptık. Özelliklere bir de sınıfla hiçbir ilgisi olmayan, düzgün dağılımlı bir “gürültü” sütunu ekledik. Etiketler hâlâ $(V_S)_{30}$'dan geliyor; model onu görmüyor.

Solda logaritmik N60–cu düzleminde ZC (kare), ZD (daire) ve ZE (üçgen) eğitim profilleri, budanmış ağacın açık renkli dikdörtgen sınıf bölgeleri ve tablodaki N60 = 15, 50 ile cu = 70, 250 sınırlarını gösteren kesikli çizgiler; ağacın sınırları tablo sınırlarına yakın. Sağda logaritmik ccp_alpha ekseninde eğitim doğruluğu (soldan sağa azalan) ve 5 katlı çapraz doğrulama doğruluğu (0,005 civarında en yüksek), seçilen değer kesikli çizgiyle işaretli.
Sol: budanmış ağacın eksenlere paralel sınıf bölgeleri ve tablodaki sınırlar (kesikli). Sağ: budama yolu boyunca eğitim ve 5 katlı çapraz doğrulama doğruluğu; seçilen $\alpha$ = 0,0050.

Budanmış ağacın eşikleri $c_u$ için 75,9 ve 264,6 kPa (tablo: 70 ve 250), $N_{60}$ için 9,4; 20,7 ve 54,2 darbe (tablo: 15 ve 50). Ağaç, tablodaki sınırların yakınında bölüyor; ama bazı eşikler tabloda karşılığı olmayan “ara” sorulardır. Örneğin $N_{60} \le 20{,}7$, $c_u$ ile birlikte ZE–ZD sınırını iki özellikten birden çizmeye çalışıyor. İki özelliğin ikisi de gürültülü olduğu için, ikisine birden bakan bir kural tek başına bakan bir kuraldan daha iyi sonuç verir; ağaç bunu ancak merdiven biçimli dikdörtgenlerle yapabilir (Şekil 2, sol). Test doğruluğu 0,911; $(V_S)_{30}$'u gören ağacın 0,994'ünden belirgin biçimde düşük. Bu, ölçülen büyüklüğün kalitesinin modelin karmaşıklığından daha önemli olduğunu hatırlatır.

8. Budama: maliyet–karmaşıklık

Hiçbir sınır konmadan büyütülen ağaç 23 yaprağa ve 9 derinliğe ulaştı: eğitim doğruluğu 1,000, test doğruluğu 0,887. Her gürültülü profil için ayrı bir dikdörtgen açmış, yani ezberlemiştir. Çare, büyüttükten sonra geri kesmektir. Maliyet–karmaşıklık budaması (cost-complexity pruning), ağacın hatasına yaprak sayısıyla orantılı bir ceza ekler:

$$ R_\alpha(T) = R(T) + \alpha\,|T| $$

Burada $R(T)$ yaprakların toplam (örnek sayısıyla ağırlıklı) safsızlığı, $|T|$ yaprak sayısıdır. $\alpha = 0$ iken tam ağaç en iyisidir; $\alpha$ büyüdükçe, getirdiği safsızlık azalması yaprak başına $\alpha$'dan küçük kalan dallar sırayla kesilir (“en zayıf halka” budaması). Böylece $\alpha$ arttıkça küçülen, iç içe geçmiş bir ağaç dizisi elde edilir. scikit-learn bu diziyi cost_complexity_pruning_path ile verir; biz her $\alpha$ için 5 katlı çapraz doğrulama doğruluğunu hesapladık.

Şekil 2'nin sağ paneli tanıdık bir tablo çiziyor: $\alpha$ büyüdükçe eğitim doğruluğu tek yönde azalıyor, çapraz doğrulama doğruluğu ise önce artıp sonra düşüyor. En yüksek çapraz doğrulama doğruluğu (0,937) $\alpha = 0{,}0050$'de; eşit sonuç veren değerler arasında en büyük $\alpha$'yı, yani en sade ağacı seçtik. Budanmış ağaç 6 yapraklı; eğitim doğruluğu 0,962'ye indi ama test doğruluğu 0,887'den 0,911'e çıktı. Daha az yapraklı bir ağaç hem daha iyi genelleşiyor hem de okunabilir kalıyor.

9. Derinlik, katmanlar ve dış değer

Dört panelde kayma dalgası hızı–derinlik grafiği (derinlik aşağı doğru artıyor): gri ölçüm noktaları, kesikli dört katmanlı gerçek profil ve mavi basamaklı regresyon ağacı. Derinlik 1'de tek bölünme yaklaşık 19 m'de; derinlik 2'de dört basamak; derinlik 3'te katman sınırları 3,75, 10,75 ve 18,75 m'de yakalanmış; derinlik 8'de ağaç tek tek ölçümleri izleyen 55 basamaklı bir zikzak.
Regresyon ağacının derinliği ve zemin profili. Derinlik 3, dört katmanı ve sınırlarını yakalıyor; derinlik 8 her ölçümün gürültüsünü izliyor. Sentetik veri, gürültünün standart sapması 20 m/s.
Derinliğe göre regresyon ağacı (60 ölçüm)
DerinlikYaprakRMSE, ölçüme (m/s)RMSE, gerçek profile (m/s)(VS)30 (m/s)
1261,060,7340,0
2429,632,4324,8
3816,919,7317,1
8553,925,7315,1

Kök bölünmesi, yani derinlik 1'deki tek bölünme, 18,75 m'de: en büyük hız sıçraması olan 19 m sınırı, ölçüm derinlikleri 18,5 ve 19,0 m'nin ortasında bulunuyor. Açgözlü algoritma kökü derinlik sınırından bağımsız seçtiği için bu bölünme bütün ağaçlarda aynıdır. Derinlik 3 ağacının eşikleri 3,75; 10,75; 11,25; 18,75; 21,25; 22,75 ve 23,75 m. Üç gerçek sınır (4, 11 ve 19 m) yarım metre ölçüm aralığının izin verdiği kesinlikle yakalanıyor; geri kalan eşikler katman içindeki hız artışını ve gürültüyü basamaklarla taklit ediyor.

Tablonun iki RMSE sütunu aşırı uyumu açıkça gösteriyor. Ölçüme göre hata derinlikle hep azalıyor: derinlik 8'de 3,9 m/s, çünkü 60 ölçüm için 55 yaprak var. Gerçek profile göre hata ise derinlik 3'te en küçük (19,7 m/s) ve derinlik 8'de yeniden 25,7 m/s'ye çıkıyor. Gürültüyü ezberlemek, gerçek profilden uzaklaşmak demektir.

Mühendislik notu

Ağaç neden $(V_S)_{30}$'u büyük tahmin ediyor?

Gerçek profilin $(V_S)_{30}$ değeri 312,3 m/s. Sığ ağaçlar bunu belirgin biçimde aşıyor (derinlik 1'de 340,0 m/s). Sebep, yaprağın tahmininin hızların aritmetik ortalaması olmasıdır; $(V_S)_{30}$ ise seyahat süresine dayanan harmonik bir ortalamadır ve aritmetik ortalama her zaman harmonik ortalamadan büyük ya da ona eşittir. Bir yaprak hızları farklı katmanları birleştirdiğinde fark büyür. İlginç olan, aşırı uyan derinlik-8 ağacının $(V_S)_{30}$'u daha iyi vermesidir (315,1 m/s): integral bir büyüklükte noktasal gürültüler birbirini götürür. Profilin şekli bozulsa da toplam seyahat süresi korunur.

Ağaçlar eğitim aralığının dışına çıkamaz

Son deney ağaçların yapısal bir sınırını gösteriyor. Basit mesnetli, düzgün yayılı yüklü bir kirişin orta açıklık sehimi $\delta = 5qL^4/(384EI)$'dır. $q$ = 10 kN/m ve IPE 300 kesitiyle ($I$ = 8356 cm⁴, $E$ = 210 GPa) 2–6 m açıklıklardan 200 örnek ürettik ve derinliği 6 olan bir regresyon ağacı eğittik. Karşılaştırma için bir de fiziği bilen bir model kurduk: özelliği $L^4$ olan doğrusal regresyon.

Solda açıklık–sehim grafiği: gri eğitim noktaları 2–6 m'de, kesikli analitik eğri 9,5 m'de 60 mm'ye çıkıyor; turuncu noktalı L⁴ modeli analitik eğriyle çakışıyor; mavi regresyon ağacı 6 m'den sonra yaklaşık 9,6 mm'de yatay kalıyor. Sağda ağacın bağıl hatası: eğitim aralığında küçük salınımlar, 6 m'den sonra hızla azalarak 9 m'de yaklaşık yüzde −80.
Sol: eğitim aralığında (gri bant) ağaç analitik eğriyi iyi izliyor; 6 m'den sonra son yaprağın değerinde sabit kalıyor. $L^4$ özellikli doğrusal model ise her yerde doğru. Sağ: ağacın bağıl hatası.

Eğitim aralığının içinde ağaç iyi: 4 m'de 1,90 mm'ye karşı 1,91 mm, 6 m'de 9,62 mm'ye karşı 9,60 mm. Aralığın dışında ise tahmin 9,60 mm'de donuyor: 7,5 m'de analitik değer 23,48 mm, 9 m'de 48,68 mm; ağacın 9 m'deki hatası yüzde −80. Sebep yapısaldır: bir ağacın tahmini her zaman bir yaprağın, yani eğitim hedeflerinden bazılarının ortalamasıdır. Eğitimde görülen en büyük sehimin üstüne asla çıkamaz. $L^4$ özellikli doğrusal model ise doğru fonksiyon biçimini bildiği için 9 m'de de 48,68 mm veriyor.

Eğitim aralığının içindeki bağıl hata salınımları da öğreticidir: ağaç mutlak hatayı (SSE) küçültür; sehimin çok küçük olduğu kısa açıklıklarda aynı mutlak hata büyük bir bağıl hataya dönüşür. Proje 3'te kiriş sehimi için vekil model kurarken aynı soruyu sorun: model hangi açıklık aralığında eğitildi ve nerede kullanılacak? Dağılım dışı girdileri tanımayı Ders 17'de ele alacağız.

10. Önem, ölçek ve kararsızlık

Safsızlığa dayalı önem ve yanlılığı

scikit-learn'ün feature_importances_ değeri, bir özelliğin ağaçtaki bütün bölünmelerde sağladığı (örnek sayısıyla ağırlıklı) safsızlık azalmalarının toplamıdır; toplamı 1 olacak biçimde normalleştirilir. Hesabı ucuzdur ama yanlıdır. Budamasız ağaçta sınıfla hiçbir ilgisi olmayan gürültü sütunu 0,038 önem aldı: çok sayıda farklı değeri olan sürekli bir özellik, derin düğümlerde birkaç örneği “şans eseri” ayıran bir eşik her zaman bulur. Budamadan sonra bu dallar kesildi ve gürültünün önemi 0,000'a indi; $c_u$'nun önemi 0,851'den 0,913'e çıktı. Önem değerleri eğitim verisinde ölçülür ve aşırı uyumu yansıtır; daha güvenilir bir ölçü olan permütasyon önemini Ders 08'de göreceğiz.

Ölçekleme gerekmez

Ağaç yalnızca “$x_j \le t$ mi?” diye sorar; bir özelliği ölçeklemek ya da kaydırmak örneklerin sırasını değiştirmez, yalnızca eşiğin sayısal değerini değiştirir. Standartlaştırılmış özelliklerle eğitilen ağaç, 124 test profilinin hepsinde aynı tahmini verdi. k-NN ve SVM'den farklı olarak birimlerle uğraşmak gerekmez.

Kararsızlık: yüksek varyans

Ağaçların en büyük zayıflığı kararsızlıklarıdır. Aynı eğitim verisinden beş bootstrap örneklemi (yerine koyarak yeniden örnekleme) çekip her birine budamasız bir ağaç uydurduk. Kök bölünmeleri şöyle çıktı: $N_{60} \le 54{,}2$; $c_u \le 244{,}0$; $N_{60} \le 48{,}3$; $c_u \le 264{,}6$; $c_u \le 265{,}8$. Verideki küçük bir değişiklik kökteki soruyu, dolayısıyla altındaki bütün ağacı değiştiriyor. Test profillerinin yüzde 12'sinin sınıfı en az bir ağaçta farklı tahmin ediliyor. Bir ağacın kurallarını okurken bunu unutmayın: aynı fiziği temsil eden çok sayıda farklı ağaç vardır.

Bu yüksek varyansın çaresi, çok sayıda ağacın ortalamasını almaktır. Bootstrap örneklemleri üzerinde eğitilen ağaçların oylarını birleştiren torbalama (bagging), buna özellik seçiminde rastgelelik ekleyen rastgele orman ve ağaçları artıklara sırayla ekleyen artırma (boosting), Ders 08'in konusu.

11. Sık yapılan hatalar

  • Budamasız ağaca güvenmek. Eğitim doğruluğu 1,000 olan ağacın test doğruluğu 0,887'ydi. Derinliği ya da $\alpha$'yı çapraz doğrulamayla seçin.
  • Ağacı eğitim aralığının dışında kullanmak. Ağaç, gördüğü hedeflerin dışına çıkamaz; 9 m'lik kirişte sehim yüzde 80 eksik tahmin edildi.
  • Safsızlık önemini kesin bir sıralama sanmak. Anlamsız bir sütun bile önem alabilir. Önemi budanmış modelde ve tercihen permütasyonla ölçün.
  • Tek bir ağacın kurallarını “doğanın kuralı” diye sunmak. Bootstrap örneklemleri kökü bile değiştirdi. Kural çıkarıyorsanız kararlılığını yeniden örneklemeyle sınayın.
  • Öğrenilen eşikleri yönetmelik değeri gibi okumak. 179,2 m/s, 180 m/s'nin veriden gelen bir tahminidir; kesinliği eşiğin çevresindeki veri yoğunluğuna bağlıdır.

12. Alıştırmalar

Alıştırma 1KolayGini, entropi ve bilgi kazancı

Bir düğümde 40 ZC, 30 ZD ve 30 ZE profili var. Bir bölünme bunları sol (40 ZC, 5 ZD) ve sağ (25 ZD, 30 ZE) olarak ayırıyor. Ebeveyn ve çocukların Gini safsızlığını ve entropisini, ağırlıklı çocuk safsızlığını ve kazancı hesaplayın.

Çözümü göster

Gini: ebeveyn $1 - (0{,}4^2 + 0{,}3^2 + 0{,}3^2) = 0{,}660$; sol $1 - (40/45)^2 - (5/45)^2 = 0{,}198$; sağ $1 - (25/55)^2 - (30/55)^2 = 0{,}496$. Ağırlıklı çocuk safsızlığı $0{,}45 \cdot 0{,}198 + 0{,}55 \cdot 0{,}496 = 0{,}362$; kazanç $0{,}660 - 0{,}362 = 0{,}298$.

Entropi: ebeveyn 1,571 bit, sol 0,503 bit, sağ 0,994 bit; ağırlıklı 0,773 bit; bilgi kazancı 0,798 bit. İki ölçüt farklı ölçeklerde, ama aynı yönde konuşuyor: bölünme sol düğümü neredeyse saf hâle getirdiği için değerlidir.

Alıştırma 2KolayOrtalamanın türü sınıfı değiştirir

Bir profil 4 m kalınlığında 160 m/s, 7 m kalınlığında 250 m/s, 8 m kalınlığında 350 m/s ve 11 m kalınlığında 530 m/s hızlı katmanlardan oluşuyor. $(V_S)_{30}$'u hesaplayın ve kalınlıkla ağırlıklı aritmetik ortalamayla karşılaştırın. Profil hangi sınıfa girer?

Çözümü göster

Seyahat süreleri: $4/160 = 0{,}02500$; $7/250 = 0{,}02800$; $8/350 = 0{,}02286$; $11/530 = 0{,}02075$; toplam 0,09661 s. $(V_S)_{30} = 30/0{,}09661 = 310{,}5$ m/s: sınıf ZD.

Kalınlıkla ağırlıklı aritmetik ortalama ise şu olurdu:

$$ \begin{aligned} \bar V &= (4 \cdot 160 + 7 \cdot 250 + 8 \cdot 350 \\ &\quad + 11 \cdot 530)/30 = 367{,}3\ \text{m/s} \end{aligned} $$

Bu değer yanlışlıkla ZC sınıfı verirdi. Yavaş katmanlar seyahat süresine orantısız katkı yapar; harmonik ortalama bunu yansıtır. Regresyon ağacının yapraklarındaki aritmetik ortalamalar da aynı nedenle $(V_S)_{30}$'u büyük tahmin ediyordu.

Alıştırma 3OrtaGini yerine entropi

2. bölümdeki deneyi (yalnız $N_{60}$, $c_u$ ve gürültü) criterion="entropy" ile tekrarlayın: budamasız ağaç, ve 5 katlı çapraz doğrulamayla budanmış ağaç. Yaprak sayıları, kök bölünmesi ve test doğrulukları Gini ile nasıl karşılaştırılır?

Çözümü göster

Budamasız: Gini ve entropi ağaçlarının ikisi de 23 yapraklı; test doğruluğu 0,887 ve 0,879. Budanmış: Gini ile $\alpha$ = 0,0050, 6 yaprak, CV 0,937, test 0,911; entropi ile $\alpha$ = 0,0281, 5 yaprak, CV 0,930, test 0,895. İkisinin kök bölünmesi de aynı: $c_u \le 264{,}6$.

Farklar bir iki test profili düzeyinde. Ölçüt seçimi, ağacın ne kadar budandığı yanında ikincil kalıyor. Not: $\alpha$'nın ölçeği safsızlık ölçütüne bağlıdır; bu yüzden iki ölçütün $\alpha$ değerleri doğrudan karşılaştırılamaz.

Alıştırma 4OrtaÖn budama mı, sonradan budama mı?

Aynı veride max_depth değerini 1'den 10'a kadar 5 katlı çapraz doğrulamayla seçin. En iyi derinlikteki ağacın yaprak sayısını ve test doğruluğunu maliyet–karmaşıklık budamasının sonucuyla (6 yaprak, test 0,911) karşılaştırın.

Çözümü göster

Çapraz doğrulama doğrulukları derinlik 1'den 10'a: 0,672; 0,895; 0,927; 0,948; 0,937; 0,927; 0,923; 0,923; 0,923; 0,923. En iyi derinlik 4: 11 yaprak, test doğruluğu 0,903.

İki yöntem benzer test başarısı veriyor (0,903 ve 0,911), ama maliyet–karmaşıklık budaması bunu neredeyse yarı yaprakla yapıyor. Derinlik sınırı ağacın her dalını aynı derinlikte keser; budama ise yalnızca katkısı küçük dalları keser ve önemli dalların derinleşmesine izin verir. Çapraz doğrulama doğruluğunun derinlik 4'te daha yüksek görünmesi (0,948'e karşı 0,937) de iki farklı aday kümesinde arama yapılmasından ve 287 örnekli eğitim kümesindeki örnekleme gürültüsünden kaynaklanır.

Alıştırma 5OrtaSıfırdan ağaca min_samples_leaf eklemek

agac_kur fonksiyonuna bir min_yaprak parametresi ekleyin: her yaprakta en az bu kadar örnek kalsın. Derinlik 8 ve min_yaprak=5 için sonucu DecisionTreeRegressor(max_depth=8, min_samples_leaf=5) ile karşılaştırın. Gerçek profile göre RMSE ne olur?

Çözümü göster

İki değişiklik yeter: düğümde $2 \cdot$ min_yaprak'tan az örnek varsa bölmeyin; sol ya da sağ tarafta min_yaprak'tan az örnek bırakan eşiklere sonsuz SSE verin.

if derinlik == en_cok or len(y) < 2 * min_yaprak or np.all(y == y[0]):
    return {"deger": y.mean()}
...
sse[(nl < min_yaprak) | (m - nl < min_yaprak)] = np.inf
if not np.isfinite(sse).any():
    return {"deger": y.mean()}

Sonuç: 8 yaprak, scikit-learn ile en büyük fark $1{,}1\times10^{-13}$ m/s. Gerçek profile göre RMSE 18,3 m/s; sınırsız derinlik-8 ağacının 25,7 m/s'sinden ve derinlik-3 ağacının 19,7 m/s'sinden iyi. Yaprak başına en az örnek koşulu, her yaprağın ortalamasını birkaç ölçüme yayar ve gürültüyü bastırır; derinlik sınırından daha esnek bir düzenlileştirmedir.

Alıştırma 6ZorAğaca dış değeri fizikle öğretmek

Kiriş deneyinde ağacı iki farklı biçimde yeniden eğitin: (a) özellik $\ln L$, hedef $\ln\delta$; (b) özellik $L$, hedef $\delta/L^4$ (tahmini sonra $L^4$ ile çarpın). 7,5 m ve 9 m'de hatalar ne olur? Neden?

Çözümü göster

(a) Aralık dışındaki sonuç değişmez: 7,5 m'de yüzde −59,1, 9 m'de yüzde −80,3 hata; tahmin yine 9,60 mm'de donar. Ama ağacın kendisi değişir, ve nedeni öğreticidir. Bir özelliğe monoton dönüşüm uygulamak (yalnız $\ln L$) örneklerin sırasını korur; ağaç aynı bölünmeleri yapar (61 yaprak, aynı bölümleme). Hedefi dönüştürmek ise SSE ölçütünü değiştirir: $\ln\delta$ ile ağaç başka eşikler seçer (63 yaprak; kök bölünmesi $L$ = 4,73 m yerine 3,52 m'de). Aralık dışındaki tahmin yine de aynı kalır, çünkü iki ağaçta da son yaprak yalnızca en uzun açıklıklı eğitim örneğini ($L$ = 6,00 m, $\delta$ = 9,60 mm) içerir; ağaç bu yaprağın değerinin ötesine çıkamaz.

(b) Hedef $\delta/L^4 = 5q/(384EI)$ bu problemde sabittir; ağaç tek yapraklı olur ve tahmin $L^4$ ile çarpılınca 7,5 m'de de 9 m'de de analitik değeri yuvarlama düzeyinde (yüzde $10^{-13}$ mertebesinde hata) verir. Ders: ağaç dış değer bulamaz, ama dış değeri bilinen fiziğe bırakıp ağaca yalnızca sınırlı bir düzeltme öğretebilirsiniz. Gerçek problemlerde bu düzeltme sabit olmayacaktır; yine de ağacın aralık dışındaki hatası, fiziksel ölçeklemenin hatasıyla sınırlı kalır. Bu, Ders 05'teki $u = n/\chi$ özelliğiyle aynı fikirdir.

Özet

Özet
  • Karar ağacı, özellik uzayını eksenlere paralel sorularla dikdörtgenlere böler; her yol okunabilir bir kuraldır. Zemin sınıfı örneğinde ağaç, tablodaki $(V_S)_{30}$ eşiklerini yüzde 1'den yakın buldu.
  • Bölünmeler açgözlü olarak, sınıflandırmada Gini ya da entropi azalmasıyla, regresyonda SSE azalmasıyla seçilir. Birikimli toplamlar bütün eşikleri tek geçişte değerlendirmeyi sağlar.
  • Budamasız ağaç ezberler. Maliyet–karmaşıklık budaması ve çapraz doğrulama, 23 yapraklı ağacı 6 yaprağa indirip test doğruluğunu artırdı.
  • Ağaçlar ölçekleme istemez, ama eğitim aralığının dışına çıkamaz: 9 m'lik kirişte sehim yüzde 80 eksik tahmin edildi.
  • Safsızlık önemi yanlıdır ve tek ağaç kararsızdır; bu yüksek varyans, topluluk yöntemlerine geçişin gerekçesidir.

Sonraki derste tek bir ağacın kararsızlığını bir avantaja çeviren yöntemleri göreceğiz: çok sayıda ağacın ortalamasını alan rastgele orman ve ağaçları hatalara sırayla ekleyen gradyan artırma.

Kaynaklar

  • L. Breiman, J. Friedman, R. Olshen, C. Stone (1984). Classification and Regression Trees. Wadsworth.
  • T. Hastie, R. Tibshirani, J. Friedman — The Elements of Statistical Learning, 2. baskı, Bölüm 9.2 (ağaç tabanlı yöntemler).
  • J. R. Quinlan (1986). Induction of decision trees. Machine Learning, 1(1), 81–106.
  • Türkiye Bina Deprem Yönetmeliği (TBDY 2018), Bölüm 16, Tablo 16.1 (yerel zemin sınıfları).
  • scikit-learn — Decision Trees (maliyet–karmaşıklık budaması dahil).