트리와 앙상블

06장에서 원 모양 데이터는 직선으로 나눌 수 없었고, 제곱 특성을 직접 만들어 넣어서야 풀렸다. 이 장의 결정 트리는 “x2≤−0.70x_2 \le -0.70인가?” 같은 예/아니오 질문을 이어 붙여 경계 모양을 데이터에서 스스로 찾는다. 트리 하나는 훈련 데이터를 외우기 쉽다. 그래서 트리를 여러 개 묶는 앙상블을 쓴다. 서로 다른 데이터로 키운 트리를 평균하는 랜덤 포레스트, 앞 트리가 틀린 만큼을 다음 트리가 고치는 그래디언트 부스팅이다. 마지막으로 모델이 어떤 특성을 썼는지 보는 특성 중요도와 그 함정, 표 데이터에서 트리 앙상블이 강한 이유와 약점을 정리한다.

7-1. 이 장의 목표와 완료 기준

섹션 제목: “7-1. 이 장의 목표와 완료 기준”
목표 완료 기준
트리를 읽는다 export_text로 트리를 규칙으로 읽고, 경계가 축에 평행한 계단이 되는 이유를 말한다
분할 기준을 계산한다 지니 불순도·엔트로피를 직접 계산하고, 가장 좋은 첫 분할을 찾아 sklearn과 맞춘다
트리의 과적합을 다룬다 max_depth·min_samples_leaf로 트리를 제한하고 검증으로 고른다
편향과 분산을 구분한다 같은 규칙에서 뽑은 여러 훈련 데이터로 편향²·분산을 재고, 얕은 트리·깊은 트리·숲의 차이를 말한다
랜덤 포레스트를 쓴다 부트스트랩·특성 무작위 선택·확률 평균을 코드로 확인하고 OOB 점수를 읽는다
그래디언트 부스팅을 이해한다 잔차에 트리를 이어 붙이는 부스팅을 NumPy로 구현해 sklearn과 맞추고, 학습률·트리 수의 관계를 말한다
특성 중요도를 바르게 읽는다 불순도 중요도와 순열 중요도의 차이를 말하고, ID 같은 열이 중요해 보이는 함정을 피한다
표 데이터에서 고른다 트리 앙상블이 강한 경우와 약한 경우(외삽, 확률)를 말하고 06장 기준선과 비교한다
선택 기준표에 줄을 더한다 트리·앙상블을 언제 고르는지 적는다
실습 노트북 07을 끝낸다 실습/문제/ch07_트리와_앙상블.ipynb의 점검 셀이 모두 “통과”를 출력한다

예상 시간: 원고 1시간 30분, 실습 1시간 30분.

7-2. 왜 트리와 앙상블인가

섹션 제목: “7-2. 왜 트리와 앙상블인가”

7-3. 결정 트리

섹션 제목: “7-3. 결정 트리”

질문을 이어 붙인다

섹션 제목: “질문을 이어 붙인다”

06장의 원 모양 데이터와 훈련·검증 분할을 그대로 쓴다. 깊이(질문 단계 수)를 2로 제한한 트리를 학습하고 규칙으로 출력한다.

import numpy as np
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, export_text
Xc, yc = make_circles(n_samples=300, factor=0.5, noise=0.1, random_state=0)
c_tr, c_va, yc_tr, yc_va = train_test_split(Xc, yc, test_size=0.3, stratify=yc, random_state=0) # 06장과 같은 분할
tree2 = DecisionTreeClassifier(max_depth=2, random_state=0).fit(c_tr, yc_tr)
print(export_text(tree2, feature_names=["x1", "x2"]))
출력
|--- x2 <= -0.70
| |--- class: 0
|--- x2 > -0.70
| |--- x2 <= 0.58
| | |--- class: 1
| |--- x2 > 0.58
| | |--- class: 0

깊이를 늘리면

섹션 제목: “깊이를 늘리면”
print("깊이 잎 훈련 검증")
for d in [1, 2, 3, 4, 6, None]:
t = DecisionTreeClassifier(max_depth=d, random_state=0).fit(c_tr, yc_tr)
print(f"{str(d):>4} {t.get_n_leaves():3d} {t.score(c_tr, yc_tr):5.3f} {t.score(c_va, yc_va):5.3f}")
출력
깊이 잎 훈련 검증
1 2 0.648 0.567
2 3 0.781 0.711
3 5 0.886 0.811
4 8 0.981 0.956
6 11 0.995 0.944
None 12 1.000 0.944

스케일링이 필요 없다

섹션 제목: “스케일링이 필요 없다”

질문이 ”x≤x \le 임계값”뿐이라, 특성에 양수를 곱하거나 어떤 수를 더해도(표준화가 이 경우다) 같은 분할·같은 예측이 나온다. 임계값만 그 단위로 바뀐다. 세제곱·로그처럼 순서만 지키는 변환에서도 훈련 표본을 나누는 방식은 같다. 다만 임계값은 이웃한 두 값의 가운데라, 변환한 뒤의 가운데가 원래 가운데와 대응하지 않아 그 사이에 오는 새 표본의 예측은 달라질 수 있다(아래 데이터에서는 같았다).

t_a = DecisionTreeClassifier(random_state=0).fit(c_tr, yc_tr)
t_b = DecisionTreeClassifier(random_state=0).fit(c_tr * [1000, 0.01], yc_tr) # 단위만 바꿈
t_c = DecisionTreeClassifier(random_state=0).fit(c_tr ** 3, yc_tr) # 순서를 지키는 변환
print(np.array_equal(t_a.predict(c_va), t_b.predict(c_va * [1000, 0.01])),
np.array_equal(t_a.predict(c_va), t_c.predict(c_va ** 3)))
출력
True True

06장에서 로지스틱 회귀는 단위 하나만 바꿔도 예측이 달라졌다. 트리는 그렇지 않으므로 StandardScaler가 필요 없다. 넣어도 해는 없지만 결과는 같다. 단, sklearn 트리는 입력을 32비트 실수로 바꾸므로, 아주 큰 수를 더해 서로 다른 값이 같은 수로 뭉개질 정도면 분할이 달라진다.

7-4. 어떤 질문을 고르나: 불순도

섹션 제목: “7-4. 어떤 질문을 고르나: 불순도”

지니 불순도와 엔트로피

섹션 제목: “지니 불순도와 엔트로피”

트리는 각 노드에서 모든 특성 × 모든 임계값을 시도해, 나눈 뒤 두 자식 노드가 가장 “깨끗해지는” 질문을 고른다. 깨끗함의 반대를 불순도(impurity)라 하고, 범주 비율 pkp_k로 잰다.

def gini(y):
p = np.bincount(y) / len(y)
return 1 - np.sum(p ** 2)
def entropy(y):
p = np.bincount(y) / len(y)
p = p[p > 0] # 0 log 0 = 0으로 둔다
return np.sum(p * np.log2(1 / p)) # −Σ p log₂ p와 같다
for counts in [(5, 5), (8, 2), (9, 1), (10, 0)]:
node = np.array([0] * counts[0] + [1] * counts[1])
print(f"범주 0:{counts[0]:2d}개, 1:{counts[1]:2d}개 → 지니 {gini(node):.3f}, 엔트로피 {entropy(node):.3f}")
출력
범주 0: 5개, 1: 5개 → 지니 0.500, 엔트로피 1.000
범주 0: 8개, 1: 2개 → 지니 0.320, 엔트로피 0.722
범주 0: 9개, 1: 1개 → 지니 0.180, 엔트로피 0.469
범주 0:10개, 1: 0개 → 지니 0.000, 엔트로피 0.000

가장 좋은 첫 분할을 직접 찾기

섹션 제목: “가장 좋은 첫 분할을 직접 찾기”

분할의 점수는 두 자식 불순도를 표본 수로 가중 평균한 값이다. 이것이 가장 작은 (특성, 임계값)을 고른다. 임계값 후보는 정렬한 값들의 가운데 점이다.

def best_split(X, y):
best = (np.inf, None, None) # (가중 불순도, 특성, 임계값)
for j in range(X.shape[1]):
v = np.unique(X[:, j])
for thr in (v[:-1] + v[1:]) / 2:
left = X[:, j] <= thr
score = (left.sum() * gini(y[left]) + (~left).sum() * gini(y[~left])) / len(y)
if score < best[0]:
best = (score, j, thr)
return best
score, j, thr = best_split(c_tr, yc_tr)
s = DecisionTreeClassifier(max_depth=1, random_state=0).fit(c_tr, yc_tr).tree_
L, R, n = s.children_left[0], s.children_right[0], s.n_node_samples
print("직접 :", j, round(thr, 4), round(score, 4))
print("sklearn:", s.feature[0], round(s.threshold[0], 4), round((n[L] * s.impurity[L] + n[R] * s.impurity[R]) / n[0], 4))
print("뿌리 지니", round(gini(yc_tr), 4), "→ 나눈 뒤", round(score, 4))
출력
직접 : 1 -0.6996 0.4134
sklearn: 1 -0.6996 0.4134
뿌리 지니 0.5 → 나눈 뒤 0.4134

수학 상자: 왜 정확도가 아니라 불순도인가

섹션 제목: “수학 상자: 왜 정확도가 아니라 불순도인가”

정확도로 분할을 고르면 좋은 분할을 구분하지 못할 때가 있다. 범주 0과 1이 400개씩인 노드를 두 가지로 나눈다고 하자.

def split_report(name, left, right):
nodes = [np.array([0] * a + [1] * b) for a, b in (left, right)]
n_all = sum(len(v) for v in nodes)
acc = sum(max(np.bincount(v, minlength=2)) for v in nodes) / n_all
g = sum(len(v) * gini(v) for v in nodes) / n_all
print(f"{name}: 왼쪽 {left}, 오른쪽 {right} → 정확도 {acc:.3f}, 가중 지니 {g:.3f}")
split_report("분할 A", (300, 100), (100, 300))
split_report("분할 B", (200, 400), (200, 0))
출력
분할 A: 왼쪽 (300, 100), 오른쪽 (100, 300) → 정확도 0.750, 가중 지니 0.375
분할 B: 왼쪽 (200, 400), 오른쪽 (200, 0) → 정확도 0.750, 가중 지니 0.333

7-5. 트리의 과적합과 편향-분산

섹션 제목: “7-5. 트리의 과적합과 편향-분산”

깊이와 잎 크기로 제한한다

섹션 제목: “깊이와 잎 크기로 제한한다”

잡음이 섞인 반달 모양 데이터(make_moons)로 본다. 두 범주가 겹치는 곳이 있어 100% 맞히는 것은 잡음까지 외웠다는 뜻이다.

from sklearn.datasets import make_moons
Xm, ym = make_moons(n_samples=600, noise=0.35, random_state=0)
m_tr, m_va, ym_tr, ym_va = train_test_split(Xm, ym, test_size=0.5, stratify=ym, random_state=0)
print("설정 잎 훈련 검증")
for name, kw in [("max_depth=2", dict(max_depth=2)), ("max_depth=5", dict(max_depth=5)), ("제한 없음", dict()),
("min_samples_leaf=10", dict(min_samples_leaf=10)), ("min_samples_leaf=40", dict(min_samples_leaf=40))]:
t = DecisionTreeClassifier(random_state=0, **kw).fit(m_tr, ym_tr)
print(f"{name:19s} {t.get_n_leaves():3d} {t.score(m_tr, ym_tr):5.3f} {t.score(m_va, ym_va):5.3f}")
출력
설정 잎 훈련 검증
max_depth=2 4 0.890 0.843
max_depth=5 18 0.923 0.847
제한 없음 47 1.000 0.830
min_samples_leaf=10 16 0.903 0.863
min_samples_leaf=40 6 0.847 0.813
얕은 트리는 큰 직사각형 두어 개로, 제한 없는 트리는 작은 섬까지 만들어 나누고, 랜덤 포레스트와 HistGB는 그 중간의 계단 경계를 만든다얕은 트리는 큰 직사각형 두어 개로, 제한 없는 트리는 작은 섬까지 만들어 나누고, 랜덤 포레스트와 HistGB는 그 중간의 계단 경계를 만든다

그림 설명. 반달 데이터의 훈련 300개를 네 모델로 학습한 결정 영역이다. 회색 점이 범주 0(왼쪽 위 반달), 빨간 삼각형이 범주 1(오른쪽 아래 반달)이고, 붉게 칠한 영역이 1로 예측하는 곳이다. 경계는 모두 가로·세로 선분으로만 이루어진 계단이다. 첫째 칸 max_depth=2 트리는 영역을 직사각형 몇 개로만 나눈다(훈련 0.890, 검증 0.843). 둘째 칸 제한 없는 트리는 상대 범주 영역 안에 가늘고 작은 직사각형 섬을 여럿 만든다(훈련 1.000, 검증 0.830). 셋째 칸 랜덤 포레스트 200그루는 경계가 더 잘게 꺾이며 두 반달 사이를 따라가고, 훈련 표본 둘레에 작은 섬이 일부 남는다(훈련 1.000, 검증 0.857). 넷째 칸 HistGradientBoosting도 비슷한 계단 경계다(훈련 0.997, 검증 0.850).

편향과 분산

섹션 제목: “편향과 분산”

깊은 트리의 과적합은 훈련 데이터가 조금만 바뀌어도 모델이 크게 바뀌는 성질과 관련이 있다. 이것을 재려면 같은 규칙에서 훈련 데이터를 여러 벌 뽑아 각각 학습하고, 같은 점에서의 예측이 얼마나 흔들리는지 본다. 정답 규칙을 아는 회귀 예(y=sin⁡x+잡음y = \sin x + \text{잡음})로 한다.

from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
rng = np.random.default_rng(0)
x_grid = np.linspace(0, 6, 200).reshape(-1, 1)
f_true = np.sin(x_grid[:, 0])
def sample(n=80): # 같은 규칙에서 훈련 데이터 한 벌
x = rng.uniform(0, 6, (n, 1))
return x, np.sin(x[:, 0]) + rng.normal(0, 0.3, n)
sets = [sample() for _ in range(50)]
for name, make in [("깊이 1 ", lambda: DecisionTreeRegressor(max_depth=1)),
("깊이 3 ", lambda: DecisionTreeRegressor(max_depth=3)),
("깊이 제한 없음", lambda: DecisionTreeRegressor()),
("랜덤 포레스트", lambda: RandomForestRegressor(n_estimators=100, random_state=0))]:
P = np.array([make().fit(x, y).predict(x_grid) for x, y in sets]) # (50벌, 200점)
bias2 = np.mean((P.mean(axis=0) - f_true) ** 2)
var = np.mean(P.var(axis=0))
print(f"{name}: 편향² {bias2:.3f}, 분산 {var:.3f}, 합 {bias2 + var:.3f}")
출력
깊이 1 : 편향² 0.064, 분산 0.033, 합 0.097
깊이 3 : 편향² 0.003, 분산 0.035, 합 0.038
깊이 제한 없음: 편향² 0.002, 분산 0.089, 합 0.091
랜덤 포레스트: 편향² 0.001, 분산 0.041, 합 0.043
깊이 1 트리는 예측이 정답 곡선에서 벗어나 있고, 제한 없는 트리는 정답 주변에서 크게 흔들리며, 부스팅은 트리 수가 늘면 검증 오차가 다시 커진다깊이 1 트리는 예측이 정답 곡선에서 벗어나 있고, 제한 없는 트리는 정답 주변에서 크게 흔들리며, 부스팅은 트리 수가 늘면 검증 오차가 다시 커진다

그림 설명. 왼쪽 두 칸은 가로축 xx(0~6), 세로축 예측값(−2~2)이다. 점선이 정답 sin⁡x\sin x, 파란 가는 선이 서로 다른 훈련 데이터 10벌로 학습한 트리의 예측, 빨간 굵은 선이 50벌 예측의 평균이다. 첫째 칸 깊이 1 트리는 모두 xx 3 근처에서 한 번 꺾이는 계단 두 개(약 0.6과 −0.7)라 평균도 사인 곡선과 크게 다르다(편향). 파란 선끼리는 서로 비슷하다. 둘째 칸 제한 없는 트리는 파란 선이 위아래로 크게 흔들리지만(분산), 빨간 평균은 사인 곡선과 거의 겹친다. 오른쪽 칸은 가로축 트리 수(1~2000, 로그 눈금), 세로축 MSE(0~0.6)의 부스팅 학습 곡선이다. 훈련 MSE는 약 0.51에서 0까지 계속 내려가고, 검증 MSE(초록)는 트리 28개에서 약 0.09로 가장 낮았다가(빨간 원) 그 뒤로 올라가 2000개에서 약 0.18이 된다. 가로 점선은 잡음 분산 0.09다.

7-6. 랜덤 포레스트

섹션 제목: “7-6. 랜덤 포레스트”

서로 다른 트리를 평균한다

섹션 제목: “서로 다른 트리를 평균한다”

같은 데이터로 같은 트리를 여러 번 학습하면 같은 트리만 나온다. 평균이 효과를 보려면 트리들이 서로 달라야 한다. 랜덤 포레스트(random forest)는 두 가지 무작위성을 넣는다.

  1. 부트스트랩(bootstrap): 트리마다 훈련 데이터 N개에서 중복을 허락해 N개를 다시 뽑아 학습한다. 이렇게 뽑은 데이터로 학습해 평균하는 방법을 배깅(bagging, bootstrap aggregating)이라 한다.
  2. 특성 무작위 선택: 노드마다 특성 일부만 후보로 보고 분할을 고른다(max_features, 분류 기본값 "sqrt" = 특성 수\sqrt{\text{특성 수}}). 강한 특성 하나가 모든 트리의 뿌리를 차지해 트리들이 닮는 것을 막는다.
idx = np.random.default_rng(0).integers(0, 300, 300) # 300개에서 중복 허락해 300번
print("부트스트랩에 들어간 서로 다른 표본 비율", round(len(np.unique(idx)) / 300, 3))
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, oob_score=True, random_state=0).fit(m_tr, ym_tr)
avg = np.mean([t.predict_proba(m_va) for t in rf.estimators_], axis=0)
print("트리", len(rf.estimators_), "개 / 확률 평균 = predict_proba:", np.allclose(avg, rf.predict_proba(m_va)))
print(f"훈련 {rf.score(m_tr, ym_tr):.3f}, 검증 {rf.score(m_va, ym_va):.3f}, OOB {rf.oob_score_:.3f}")
출력
부트스트랩에 들어간 서로 다른 표본 비율 0.63
트리 200 개 / 확률 평균 = predict_proba: True
훈련 1.000, 검증 0.857, OOB 0.860

트리 수

섹션 제목: “트리 수”
print("트리 수 검증 OOB")
for n_trees in [20, 50, 200, 500]:
f = RandomForestClassifier(n_estimators=n_trees, oob_score=True, random_state=0).fit(m_tr, ym_tr)
print(f"{n_trees:6d} {f.score(m_va, ym_va):6.3f} {f.oob_score_:6.3f}")
출력
트리 수 검증 OOB
20 0.857 0.857
50 0.860 0.870
200 0.857 0.860
500 0.860 0.863

7-7. 그래디언트 부스팅

섹션 제목: “7-7. 그래디언트 부스팅”

틀린 만큼을 다음 트리가 고친다

섹션 제목: “틀린 만큼을 다음 트리가 고친다”

랜덤 포레스트는 깊은 트리를 나란히 키워 평균한다. 부스팅(boosting)은 얕은 트리를 차례로 쌓는다. 회귀에서 제곱 오차를 쓰면 방법이 아주 단순하다.

  1. 처음 예측 F0=yF_0 = y의 평균.
  2. 지금 예측이 틀린 양 잔차(residual) r=y−Fr = y - F를 구한다.
  3. 얕은 트리 하나를 잔차에 맞춘다.
  4. F←F+η⋅(그 트리의 예측)F \leftarrow F + \eta \cdot (\text{그 트리의 예측}). η\eta는 학습률(learning rate)이다. 2로 돌아간다.
from sklearn.ensemble import GradientBoostingRegressor
def boost(x, y, n_trees=100, lr=0.1, depth=2):
F0 = y.mean()
F, trees = np.full(len(y), F0), []
for _ in range(n_trees):
t = DecisionTreeRegressor(max_depth=depth, random_state=0).fit(x, y - F) # 잔차에 맞춘다
F = F + lr * t.predict(x)
trees.append(t)
return F0, trees
def boost_predict(F0, trees, x, lr=0.1):
return F0 + lr * sum(t.predict(x) for t in trees)
x_b, y_b = sets[0] # 편향-분산 실험의 첫 훈련 데이터
x_v, y_v = sample(200) # 새 검증 데이터
F0, trees = boost(x_b, y_b)
gbr = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=2, random_state=0).fit(x_b, y_b)
print("sklearn과 최대 차이", np.abs(boost_predict(F0, trees, x_v) - gbr.predict(x_v)).max().round(10))
출력
sklearn과 최대 차이 0.0

트리 수와 학습률

섹션 제목: “트리 수와 학습률”
gbr_long = GradientBoostingRegressor(n_estimators=2000, learning_rate=0.1, max_depth=2, random_state=0).fit(x_b, y_b)
print("트리 수 훈련 MSE 검증 MSE")
for k, (p_tr, p_va) in enumerate(zip(gbr_long.staged_predict(x_b), gbr_long.staged_predict(x_v)), start=1):
if k in (1, 10, 30, 100, 300, 2000):
print(f"{k:6d} {np.mean((p_tr - y_b) ** 2):9.3f} {np.mean((p_va - y_v) ** 2):9.3f}")
출력
트리 수 훈련 MSE 검증 MSE
1 0.513 0.490
10 0.154 0.156
30 0.047 0.092
100 0.021 0.114
300 0.004 0.148
2000 0.000 0.181

실무에서 쓰는 부스팅: HistGradientBoosting

섹션 제목: “실무에서 쓰는 부스팅: HistGradientBoosting”

GradientBoostingRegressor·Classifier는 원리를 보기 좋지만 데이터가 수만 건을 넘으면 느리다. sklearn은 특성 값을 최대 255개 구간(bin, 결측용 구간은 따로)으로 묶어 분할 후보를 줄인 HistGradientBoostingClassifier·Regressor를 권한다. LightGBM과 같은 방식이다.

7-8. 특성 중요도

섹션 제목: “7-8. 특성 중요도”

표 데이터 예: 가상 고객 이탈

섹션 제목: “표 데이터 예: 가상 고객 이탈”

이제 표 데이터에 쓴다. 가상의 통신사 고객 3000명 데이터를 만든다. 이탈 규칙은 “계약 6개월 이하이면서 월요금 55,000원 이상”(상호작용), “상담 4회 이상”(문턱), **“데이터 5GB 미만”**이다. 고객번호는 이탈과 무관한 번호이고, 나이도 규칙에 없다. 데이터 사용량의 10%는 결측이다. 상담횟수는 평균 1.2회인 0 이상의 정수(포아송 분포), 데이터GB는 오른쪽 꼬리가 긴 양수(감마 분포)로 만들었다. 분포 이론은 몰라도 된다.

import pandas as pd
rng = np.random.default_rng(0)
n = 3000
df = pd.DataFrame({
"고객번호": rng.permutation(n) + 100000,
"나이": rng.integers(19, 70, n),
"월요금": rng.normal(50000, 15000, n).round(-2),
"계약개월": rng.integers(1, 37, n),
"상담횟수": rng.poisson(1.2, n),
"데이터GB": rng.gamma(2.0, 10.0, n).round(1),
})
z = (-3.0 + 4.0 * ((df["계약개월"] <= 6) & (df["월요금"] >= 55000))
+ 3.0 * (df["상담횟수"] >= 4) + 1.5 * (df["데이터GB"] < 5))
churn = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(int)
df.loc[rng.random(n) < 0.1, "데이터GB"] = np.nan
D_tr, D_va, ch_tr, ch_va = train_test_split(df, churn, test_size=0.3, stratify=churn, random_state=0)
print(df.shape, "이탈 비율", round(churn.mean(), 3), "/ 결측", int(df["데이터GB"].isna().sum()))
출력
(3000, 6) 이탈 비율 0.121 / 결측 297

불순도 중요도와 순열 중요도

섹션 제목: “불순도 중요도와 순열 중요도”

트리 모델의 feature_importances_는 불순도 중요도(MDI, mean decrease in impurity)다. 분할마다 줄인 불순도에 그 노드에 도착한 표본 비율을 곱해 특성별로 더하고, 합이 1이 되게 나눈 값이다(랜덤 포레스트는 트리별 값을 평균한다). 훈련 중에 계산되므로 공짜지만, 훈련 데이터 기준이라 과적합한 분할도 중요도로 센다.

순열 중요도(permutation importance)는 학습이 끝난 모델에서, 특성 하나를 표본 사이에서 무작위로 섞어 그 특성과 정답의 관계를 끊은 뒤 점수가 얼마나 떨어지는지 잰다. 검증 데이터로 재면 “일반화에 실제로 도움이 된 정도”다.

from sklearn.inspection import permutation_importance
rf_ch = RandomForestClassifier(random_state=0, n_jobs=-1).fit(D_tr, ch_tr)
pi = permutation_importance(rf_ch, D_va, ch_va, scoring="roc_auc", n_repeats=10, random_state=0)
print("특성 불순도 순열(AUC 감소)")
for name, mdi, perm, sd in zip(df.columns, rf_ch.feature_importances_, pi.importances_mean, pi.importances_std):
print(f"{name:8s} {mdi:7.3f} {perm:+8.3f} ± {sd:.3f}")
출력
특성 불순도 순열(AUC 감소)
고객번호 0.137 -0.015 ± 0.005
나이 0.100 +0.001 ± 0.010
월요금 0.255 +0.099 ± 0.019
계약개월 0.245 +0.170 ± 0.015
상담횟수 0.112 +0.066 ± 0.010
데이터GB 0.151 +0.033 ± 0.010

7-9. 표 데이터에서 트리 앙상블이 강한 이유

섹션 제목: “7-9. 표 데이터에서 트리 앙상블이 강한 이유”

같은 데이터로 비교

섹션 제목: “같은 데이터로 비교”

06장 기준선(결측 대체 + 표준화 + 로지스틱 회귀)과 트리 모델을 같은 교차검증으로 비교한다. 로지스틱 회귀는 NaN을 받지 못해 SimpleImputer(평균으로 채움)를 앞에 둔다. sklearn 1.9의 트리·랜덤 포레스트·HistGradientBoosting은 NaN을 그대로 받는다.

from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import HistGradientBoostingClassifier
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
models = {
"로지스틱 회귀": make_pipeline(SimpleImputer(), StandardScaler(), LogisticRegression()),
"트리(깊이 5)": DecisionTreeClassifier(max_depth=5, random_state=0),
"랜덤 포레스트": RandomForestClassifier(random_state=0, n_jobs=-1),
"HistGB": HistGradientBoostingClassifier(random_state=0),
}
for name, model in models.items():
s = cross_val_score(model, D_tr, ch_tr, cv=cv, scoring="roc_auc")
print(f"{name:8s} AUC {s.mean():.3f} ± {s.std(ddof=1):.3f}")
출력
로지스틱 회귀 AUC 0.745 ± 0.033
트리(깊이 5) AUC 0.745 ± 0.054
랜덤 포레스트 AUC 0.803 ± 0.017
HistGB AUC 0.795 ± 0.030

트리 앙상블이 표 데이터에 잘 맞는 이유

섹션 제목: “트리 앙상블이 표 데이터에 잘 맞는 이유”
성질 트리 앙상블 선형 모델
단위·스케일 영향 없음(순서만 본다) 스케일링 필요(06장)
상호작용·문턱 질문을 이어 붙여 스스로 찾는다 곱·구간 특성을 직접 만들어야 한다
결측값 HistGB·sklearn 1.4 이후 트리는 그대로 받는다 대체가 필요하다
이상치 특성의 극단값에는 임계값만 영향을 받아 덜 민감하다. 회귀 정답의 이상치는 잎 평균을 끌어당긴다 계수가 끌려간다
쓸모없는 특성 분할에 덜 쓰일 뿐 대체로 버틴다 정규화로 눌러야 한다

약점: 범위 밖 예측과 확률

섹션 제목: “약점: 범위 밖 예측과 확률”

회귀 트리와 랜덤 포레스트는 잎의 평균값만 낼 수 있으므로 훈련 데이터 범위 밖으로 외삽하지 못한다.

from sklearn.linear_model import LinearRegression
x_line = np.arange(0, 10, 0.5).reshape(-1, 1) # 0 ~ 9.5
y_line = 2 * x_line[:, 0] # y = 2x
x_far = np.array([[12.0], [20.0]])
print("트리 ", RandomForestRegressor(random_state=0).fit(x_line, y_line).predict(x_far).round(1))
print("선형 회귀 ", LinearRegression().fit(x_line, y_line).predict(x_far).round(1))
출력
트리 [18.4 18.4]
선형 회귀 [24. 40.]

단일 트리의 확률도 약점이다. 잎의 범주 비율이라 0이나 1이 많다. 06장의 유방암 데이터(특성 30개, 훈련+검증 455명)로 교차검증 로그 손실을 잰다.

from sklearn.datasets import load_breast_cancer
bc = load_breast_cancer()
y_bc = (bc.target == 0).astype(int)
Xb_tmp, _, yb_tmp, _ = train_test_split(bc.data, y_bc, test_size=0.2, stratify=y_bc, random_state=0) # 06장과 같은 분할
for name, model in [("로지스틱 회귀", make_pipeline(StandardScaler(), LogisticRegression())),
("트리(제한 없음)", DecisionTreeClassifier(random_state=0)),
("랜덤 포레스트", RandomForestClassifier(random_state=0, n_jobs=-1)),
("HistGB", HistGradientBoostingClassifier(random_state=0))]:
ll = -cross_val_score(model, Xb_tmp, yb_tmp, cv=cv, scoring="neg_log_loss")
acc = cross_val_score(model, Xb_tmp, yb_tmp, cv=cv, scoring="accuracy")
print(f"{name:10s} 로그 손실 {ll.mean():.3f}, 정확도 {acc.mean():.3f}")
출력
로지스틱 회귀 로그 손실 0.088, 정확도 0.982
트리(제한 없음) 로그 손실 2.614, 정확도 0.927
랜덤 포레스트 로그 손실 0.112, 정확도 0.954
HistGB 로그 손실 0.124, 정확도 0.960

7-10. 트리와 앙상블을 언제 쓰나

섹션 제목: “7-10. 트리와 앙상블을 언제 쓰나”
상황 고를 것 이유
표 데이터, 기준선 다음 랜덤 포레스트(튜닝 없이) → HistGradientBoosting(조기 종료) 상호작용·문턱·결측을 스스로 다룬다
규칙으로 설명해야 한다 얕은 트리 하나(max_depth 3~4) + export_text 질문 몇 개로 그대로 읽힌다. 성능은 앙상블보다 낮다
데이터가 크다(수만 건 이상) HistGradientBoosting 구간으로 묶어 빠르고 조기 종료가 기본으로 켜진다
어떤 특성을 썼는지 알고 싶다 검증 데이터의 순열 중요도 불순도 중요도는 값의 종류가 많은 열을 부풀린다
미래 값이 훈련 범위를 넘는다 선형 모델 또는 추세 제거 후 트리 트리는 외삽하지 못한다
이미지·소리·문장 원본 신경망(12·14장), 사전학습 모델이 뽑은 특성(15장) 원본 픽셀·글자 하나에는 뜻이 없다

7-11. 선택 기준표에 추가

섹션 제목: “7-11. 선택 기준표에 추가”
상황 고를 것 이유 장
표 데이터에서 기준선보다 나은 모델 랜덤 포레스트, 그다음 HistGradientBoosting(조기 종료) 상호작용·문턱·결측·스케일을 스스로 다루고 튜닝 부담이 작다 07
트리 하나를 쓴다 max_depth·min_samples_leaf를 검증으로 제한 제한 없는 트리는 훈련 데이터를 외운다(분산이 크다) 07
부스팅을 쓴다 작은 학습률 + 조기 종료로 트리 수 결정 부스팅은 트리를 계속 더하면 과적합할 수 있다 07
특성 중요도를 보고한다 검증 데이터 순열 중요도, 인과로 해석하지 않음 불순도 중요도는 ID 같은 열을 부풀리고, 얽힌 특성은 서로 나눠 가진다 07
훈련 범위 밖 값을 예측한다 트리 단독은 피한다 트리는 범위 밖 입력에 맨 끝 잎의 값만 내서 추세를 잇지 못한다 07

확인 문제

섹션 제목: “확인 문제”

7-12. 실습과 문제

섹션 제목: “7-12. 실습과 문제”

실습/문제/ch07_트리와_앙상블.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안팎에 끝난다. 다 푼 뒤 해설 노트북과 비교한다.

번호 유형 내용
1 개념 결정 트리 참/거짓
2 코드 지니 불순도
3 코드 특성 하나의 가장 좋은 분할 찾기
4 코드 교차검증으로 max_depth 고르기
5 코드 부트스트랩 트리로 배깅 직접 구현
6 코드 잔차에 트리를 쌓는 부스팅 직접 구현
7 코드 순열 중요도 직접 구현
8 개념 앙상블·중요도 참/거짓
9 사례 회원번호가 가장 중요하다는 보고서
10 사례 상황별 모델·설정 고르기

7-13. 공식 문서와 참고 자료

섹션 제목: “7-13. 공식 문서와 참고 자료”