결정 트리(Decision Tree): 데이터를 질문으로 쪼개는 알고리즘

"꽃잎 길이가 2.5cm 이하인가?"
  → Yes: setosa
  → No: "꽃잎 너비가 1.8cm 이하인가?"
         → Yes: versicolor
         → No: virginica

                    [루트 노드: Root Node]
                    꽃잎 길이 ≤ 2.5?
                    Gini=0.667, n=150
                   /                 \
          Yes /                       \ No
             /                         \
    [내부 노드: Internal Node]    [내부 노드: Internal Node]
       setosa (순수)               꽃잎 너비 ≤ 1.8?
       Gini=0.0, n=50              Gini=0.5, n=100
                                  /             \
                           Yes /                 \ No
                              /                   \
                    [리프 노드: Leaf Node]    [리프 노드: Leaf Node]
                       versicolor              virginica
                       Gini≈0.05, n=54         Gini≈0.04, n=46

Gini(t) = 1 - Σᵢ pᵢ²

pᵢ = 노드 t에서 클래스 i의 비율

# 분할 전: 루트 노드 [setosa=50, versicolor=50, virginica=50]
# 총 150개, 각 클래스 비율 = 1/3

def gini(counts):
    total = sum(counts)
    probs = [c / total for c in counts]
    return 1 - sum(p**2 for p in probs)

# 루트 노드
g_root = gini([50, 50, 50])
print(f"루트 Gini: {g_root:.4f}")

# 분할: petal_length <= 2.5
# 왼쪽: [setosa=50, versicolor=0, virginica=0] → 완전 순수
g_left = gini([50, 0, 0])
print(f"왼쪽 Gini: {g_left:.4f}")

# 오른쪽: [setosa=0, versicolor=50, virginica=50]
g_right = gini([0, 50, 50])
print(f"오른쪽 Gini: {g_right:.4f}")

루트 Gini: 0.6667
왼쪽 Gini: 0.0000
오른쪽 Gini: 0.5000

# 가중 평균 (샘플 수 기준)
n_left, n_right, n_total = 50, 100, 150
g_weighted = (n_left/n_total) * g_left + (n_right/n_total) * g_right
print(f"가중 평균 Gini: {g_weighted:.4f}")

# Gini 감소량 (클수록 좋은 분할)
gini_gain = g_root - g_weighted
print(f"Gini 감소량: {gini_gain:.4f}")

가중 평균 Gini: 0.3333
Gini 감소량: 0.3333

Entropy(t) = -Σᵢ pᵢ × log₂(pᵢ)

이진 분류: Entropy = -p log₂p - (1-p) log₂(1-p)

IG = Entropy(parent) - Σⱼ (nⱼ/n) × Entropy(childⱼ)

import numpy as np

def entropy(counts):
    total = sum(counts)
    result = 0
    for c in counts:
        if c > 0:
            p = c / total
            result -= p * np.log2(p)
    return result

# 루트 엔트로피: 3개 클래스가 균등 → 최대 불순도
e_root = entropy([50, 50, 50])
print(f"루트 Entropy: {e_root:.4f}")  # log₂(3) = 1.585

# 분할 후
e_left  = entropy([50, 0, 0])    # 완전 순수 → 0
e_right = entropy([0, 50, 50])   # 2 클래스 균등 → 1.0
e_weighted = (50/150) * e_left + (100/150) * e_right

ig = e_root - e_weighted
print(f"엔트로피 왼쪽: {e_left:.4f}")
print(f"엔트로피 오른쪽: {e_right:.4f}")
print(f"정보 이득(IG): {ig:.4f}")

루트 Entropy: 1.5850
엔트로피 왼쪽: 0.0000
엔트로피 오른쪽: 1.0000
정보 이득(IG): 0.9183

import numpy as np

def gini(y):
    """레이블 배열의 Gini 불순도 계산"""
    if len(y) == 0:
        return 0
    classes, counts = np.unique(y, return_counts=True)
    probs = counts / len(y)
    return 1 - np.sum(probs ** 2)

def best_split(X, y):
    """모든 특성과 임계값을 탐색해 최적 분할 반환"""
    best_gain = -1
    best_feature, best_threshold = None, None
    g_parent = gini(y)

    for feature_idx in range(X.shape[1]):
        thresholds = np.unique(X[:, feature_idx])

        for threshold in thresholds:
            left_mask = X[:, feature_idx] <= threshold
            right_mask = ~left_mask

            if left_mask.sum() == 0 or right_mask.sum() == 0:
                continue

            g_left  = gini(y[left_mask])
            g_right = gini(y[right_mask])
            n, n_l, n_r = len(y), left_mask.sum(), right_mask.sum()
            g_weighted = (n_l/n) * g_left + (n_r/n) * g_right

            gain = g_parent - g_weighted
            if gain > best_gain:
                best_gain = gain
                best_feature = feature_idx
                best_threshold = threshold

    return best_feature, best_threshold, best_gain

# Iris 데이터에 적용
from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target

feat, thresh, gain = best_split(X, y)
print(f"최적 분할 특성: {iris.feature_names[feat]}")
print(f"최적 임계값:    {thresh:.2f} cm")
print(f"Gini 감소량:    {gain:.4f}")

최적 분할 특성: petal length (cm)
최적 임계값:    1.90 cm
Gini 감소량:    0.3333

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# 깊이 3으로 제한
clf = DecisionTreeClassifier(max_depth=3, random_state=42)
clf.fit(X_train, y_train)

print(f"훈련 정확도: {clf.score(X_train, y_train):.4f}")
print(f"테스트 정확도: {clf.score(X_test, y_test):.4f}")

훈련 정확도: 0.9524
테스트 정확도: 1.0000

fig, ax = plt.subplots(figsize=(20, 10))
plot_tree(clf,
          feature_names=iris.feature_names,
          class_names=iris.target_names,
          filled=True,       # 클래스별 색상 채움
          rounded=True,      # 노드 모서리 둥글게
          fontsize=11,
          ax=ax)
ax.set_title('Iris 결정 트리 (max_depth=3)', fontsize=16)
plt.tight_layout()
plt.show()

꽃잎 길이 (cm) <= 2.45      ← 분할 조건
gini = 0.667                ← 현재 노드의 Gini 불순도
samples = 105               ← 이 노드에 도달한 훈련 샘플 수
value = [36, 31, 38]        ← [setosa, versicolor, virginica] 수
class = virginica            ← 현재 다수 클래스 (예측값)

import numpy as np

X_2d = iris.data[:, 2:4]  # petal length, petal width
clf_2d = DecisionTreeClassifier(max_depth=3, random_state=42)
clf_2d.fit(X_2d, y)

xx, yy = np.meshgrid(np.linspace(0.5, 7.5, 300),
                      np.linspace(0.0, 2.7, 300))
Z = clf_2d.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

plt.figure(figsize=(8, 6))
plt.contourf(xx, yy, Z, alpha=0.25, cmap='RdYlBu_r')
plt.contour(xx, yy, Z, colors='black', linewidths=0.8, alpha=0.5)

colors = ['#3182f6', '#ff6b6b', '#51cf66']
for k, (c, name) in enumerate(zip(colors, iris.target_names)):
    mask = y == k
    plt.scatter(X_2d[mask, 0], X_2d[mask, 1],
                c=c, edgecolors='white', label=name, s=50)

plt.xlabel('Petal Length (cm)')
plt.ylabel('Petal Width (cm)')
plt.title('결정 트리의 결정 경계 (max_depth=3)')
plt.legend()
plt.show()

# 깊이 무제한 → 훈련 100%, 하지만 새 데이터에는?
clf_full = DecisionTreeClassifier(random_state=42)
clf_full.fit(X_train, y_train)
print(f"훈련 정확도: {clf_full.score(X_train, y_train):.4f}")  # 1.0000
print(f"테스트 정확도: {clf_full.score(X_test, y_test):.4f}")  # 1.0000
print(f"트리 깊이: {clf_full.get_depth()}")                    # 6
print(f"리프 노드 수: {clf_full.get_n_leaves()}")              # 10

훈련 정확도: 1.0000
테스트 정확도: 1.0000
트리 깊이: 6
리프 노드 수: 10

clf = DecisionTreeClassifier(
    max_depth=3,           # 최대 깊이. 가장 중요한 파라미터
    min_samples_split=10,  # 분할하려면 노드에 최소 이 수 이상의 샘플 필요
    min_samples_leaf=5,    # 리프 노드에 최소 이 수의 샘플 필요
    max_features=None,     # 분할 후보 특성 수 ('sqrt', 'log2', int)
    random_state=42
)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42
)

depths = range(1, 16)
train_accs, test_accs = [], []

for d in depths:
    clf = DecisionTreeClassifier(max_depth=d, random_state=42)
    clf.fit(X_train, y_train)
    train_accs.append(clf.score(X_train, y_train))
    test_accs.append(clf.score(X_test, y_test))

# 주요 결과
for d in [1, 2, 3, 5, None]:
    clf = DecisionTreeClassifier(max_depth=d, random_state=42)
    clf.fit(X_train, y_train)
    print(f"depth={str(d):4s} | train={clf.score(X_train, y_train):.4f} "
          f"| test={clf.score(X_test, y_test):.4f}")

depth=1    | train=0.6476 | test=0.7111
depth=2    | train=0.9429 | test=0.9778
depth=3    | train=0.9524 | test=1.0000
depth=5    | train=0.9905 | test=1.0000
depth=None | train=1.0000 | test=1.0000

from sklearn.model_selection import cross_val_score

for d in [2, 3, 4, 5]:
    clf = DecisionTreeClassifier(max_depth=d, random_state=42)
    cv_scores = cross_val_score(clf, iris.data, iris.target, cv=5)
    print(f"depth={d}: CV 평균={cv_scores.mean():.4f} (±{cv_scores.std():.4f})")

depth=2: CV 평균=0.9333 (±0.0471)
depth=3: CV 평균=0.9733 (±0.0249)
depth=4: CV 평균=0.9533 (±0.0340)
depth=5: CV 평균=0.9533 (±0.0340)

특성 j의 중요도 = Σ (노드 샘플 비율 × Gini 감소량) / 총합
                   j로 분할하는 모든 노드

clf = DecisionTreeClassifier(max_depth=3, random_state=42)
clf.fit(X_train, y_train)

importances = clf.feature_importances_
for name, imp in zip(iris.feature_names, importances):
    bar = '█' * int(imp * 40)
    print(f"{name:25s}: {imp:.4f}  {bar}")

sepal length (cm)        : 0.0000
sepal width (cm)         : 0.0000
petal length (cm)        : 0.9251  █████████████████████████████████████
petal width (cm)         : 0.0749  ██

# ❌ 결정 트리에 StandardScaler 적용 — 불필요
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

pipe = Pipeline([
    ('scaler', StandardScaler()),  # 필요 없음
    ('clf', DecisionTreeClassifier())
])

# ✅ 스케일링 없이 바로 학습
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

# ❌ max_depth 제한 없음 → 훈련 데이터 암기
clf = DecisionTreeClassifier(random_state=42)
clf.fit(X_train, y_train)
print(clf.score(X_train, y_train))  # 1.0000 (훈련 완벽)
print(clf.score(X_test, y_test))    # 노이즈 있는 데이터면 크게 낮아질 수 있음

# ✅ max_depth 설정 + 교차 검증으로 최적화
from sklearn.model_selection import GridSearchCV

param_grid = {'max_depth': [2, 3, 4, 5, 6, 7, 8]}
grid = GridSearchCV(DecisionTreeClassifier(random_state=42),
                    param_grid, cv=5, scoring='accuracy')
grid.fit(X_train, y_train)
print(f"최적 depth: {grid.best_params_['max_depth']}")
print(f"CV 정확도: {grid.best_score_:.4f}")

최적 depth: 3
CV 정확도: 0.9333

# ❌ 클래스 불균형 데이터 (예: 사기 탐지 1% vs 정상 99%)
# 기본 결정 트리는 다수 클래스를 맞추는 쪽으로 편향된다
clf = DecisionTreeClassifier()

# ✅ class_weight='balanced' 또는 직접 가중치 설정
clf_balanced = DecisionTreeClassifier(
    class_weight='balanced',  # 각 클래스를 n_samples / (n_classes * count)로 가중
    random_state=42
)