콘텐츠로 이동
교육자료

AI 기초 › 07장

트리와 앙상블

읽기 1시간 30분 · 실습 1시간 30분인쇄용 보기(PDF)

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

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

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

  • 경계 모양을 스스로 찾는다. 선형 모델은 특성에 대해 선형이라 휘어진 경계나 “A이면서 B일 때만” 같은 상호작용은 사람이 특성을 만들어 줘야 했다(06장). 트리는 질문을 이어 붙여 이것을 스스로 찾는다.
  • 표 데이터의 강자다. 단위·스케일을 타지 않고, 결측값과 특성 간 상호작용을 다룬다. 표 데이터 대회와 실무에서 그래디언트 부스팅(XGBoost·LightGBM·CatBoost, sklearn HistGradientBoosting)이 가장 흔한 강한 모델이다.
  • 앙상블이라는 생각. “약한 모델 여럿을 묶어 강한 모델을 만든다”는 생각은 이 장의 트리뿐 아니라 딥러닝의 여러 모델 평균, 드롭아웃(11장) 해석에도 다시 나온다.

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
  • 맨 위 질문인 뿌리 노드(root)부터 내려가며 예/아니오로 갈라진다. 더 갈라지지 않는 끝이 잎 노드(leaf)이고, 잎에 도착한 표본은 그 잎의 훈련 표본 중 많은 쪽 범주로 예측한다. 확률(predict_proba)은 그 잎의 범주 비율이다.
  • 질문은 늘 “특성 하나 ≤ 임계값”이다. 그래서 경계는 축에 평행한 선분을 이은 계단 모양이 된다.
  • 위 트리는 x2x_2만 두 번 써서 가로 띠 하나를 1(안쪽 원)로 잘라냈다. 원을 그리기에는 질문이 부족하다.
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
  • 06장에서 직선 경계는 검증 정확도 0.433, 제곱 특성을 직접 넣은 로지스틱 회귀는 0.978이었다. 트리는 특성을 만들지 않고 깊이 4에서 0.956까지 왔다. 원을 계단으로 근사한 것이다.
  • max_depth=None이면 잎이 한 범주만 남거나 더 나눌 수 없을 때까지 나눈다. 이 데이터에서는 모든 잎이 한 범주만 남아 훈련 정확도가 1.0이 되지만 검증은 오르지 않는다. 특성 값이 똑같은데 정답이 다른 표본이 있으면 더 나눌 수 없어 섞인 잎이 남기도 한다. 다음 절에서 이 과적합을 다룬다.

질문이 ”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로 잰다.

  • 지니 불순도(Gini impurity): 1−∑kpk21 - \sum_k p_k^2. sklearn 기본값(criterion="gini").
  • 엔트로피(entropy): −∑kpklog⁡2pk-\sum_k p_k \log_2 p_k. criterion="entropy".
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
  • 두 범주가 반반이면 가장 크고(지니 0.5, 엔트로피 1), 한 범주만 남으면 0이다. 둘은 모양이 비슷해서 실제로 고르는 분할도 대개 같다. 지니가 로그가 없어 조금 빠르다.

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

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
  • 직접 찾은 분할(특성 1 = x2x_2, 임계값 −0.70)이 sklearn과 같다. sklearn은 특성을 32비트 실수로 바꿔 계산하므로 임계값의 아주 뒷자리는 다를 수 있다.
  • 불순도가 0.5에서 0.413으로 줄었다. 이 줄어든 양을 불순도 감소라 하고, 엔트로피를 쓸 때는 정보 이득(information gain)이라 한다. 트리는 이것을 노드마다 반복하는 탐욕적(greedy) 방법이다. 지금 가장 좋은 질문을 고를 뿐, 몇 단계 뒤까지 내다보지는 않는다.
  • 범주가 아니라 숫자를 예측하는 회귀 트리(DecisionTreeRegressor)는 기본값(제곱 오차 기준)에서 불순도 대신 잎 안의 분산(평균 제곱 오차)을 줄이는 분할을 고르고, 잎의 예측값은 그 잎 표본의 평균이다. criterion="absolute_error"를 고르면 절대 오차를 줄이고 잎의 예측값은 중앙값이 된다.

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

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

정확도로 분할을 고르면 좋은 분할을 구분하지 못할 때가 있다. 범주 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
  • 두 분할 모두 다수결 정확도는 0.75로 같지만, 분할 B는 오른쪽 노드를 완전히 깨끗하게(한 범주만) 만들어 더 이상 나눌 필요가 없다. 지니는 B를 더 좋게 본다.
  • 지니·엔트로피는 비율 pp에 대해 위로 볼록한(∩ 모양) 곡선이다. 그래서 자식 노드의 비율이 부모 비율에서 멀어질수록(한쪽이 깨끗해질수록) 가중 불순도가 부모보다 줄어들고, “한쪽이라도 깨끗하게” 만드는 분할에 보상을 준다. 다수결 정확도는 꺾인 직선 모양이라, 위 A·B처럼 정확도가 같은 서로 다른 분할이 생기고 그 차이를 놓칠 수 있다.
  • 엔트로피는 “표본의 범주를 알게 될 때 얻는 평균 정보량”을 비트 단위로 잰 값이다(같은 노드의 표본을 아주 많이 한꺼번에 알려 줄 때 표본 하나에 필요한 예/아니오 질문 수의 하한). 지니는 “노드에서 표본 하나를 뽑아 범주를 보고 되돌려 놓은 뒤(복원 추출) 다시 하나를 뽑았을 때 두 범주가 다를 확률”이다.

잡음이 섞인 반달 모양 데이터(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).

  • 제한이 없으면 잎이 47개, 훈련 정확도 1.0이지만 검증은 0.83이다. 그림 둘째 칸처럼 상대 범주 영역 안에 작은 섬을 만들어 표본 하나하나를 외웠다.
  • max_depth는 질문 단계 수를, min_samples_leaf는 잎에 남아야 할 최소 표본 수를 제한한다. 둘 다 트리의 복잡도 손잡이다(06장의 C, 05장의 다항식 차수와 같은 역할). min_samples_leaf=10이 검증 0.863으로 가장 좋았다. 너무 세게 제한하면(min_samples_leaf=40) 훈련·검증 모두 떨어져 과소적합한다.
  • 값은 검증이나 교차검증으로 고른다(실습 문제 4). 이 밖에 max_leaf_nodes, min_samples_split, 가지치기 강도 ccp_alpha도 같은 손잡이다.

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

  • 편향(bias): 여러 모델 예측의 평균이 정답과 얼마나 다른지를 나타낸다. 모델이 너무 단순하면 크다.
  • 분산(variance): 예측이 훈련 데이터에 따라 얼마나 흔들리는지를 나타낸다. 모델이 너무 복잡하면 크다.
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다.

  • 깊이 1(질문 하나)은 sin 곡선을 계단 두 개로만 그려 편향이 크다. 깊이 제한이 없는 트리는 평균은 정답에 가깝지만(편향² 0.002) 데이터마다 크게 흔들려 분산이 크다(그림 왼쪽 두 칸).
  • 새 데이터에서 기대 제곱 오차 =편향2+분산+잡음 분산= \text{편향}^2 + \text{분산} + \text{잡음 분산}이다(여기서 잡음 분산은 0.32=0.090.3^2 = 0.09). 잡음은 어떤 모델로도 줄일 수 없다. 같은 종류의 모델에서 복잡도를 올리면 보통 편향은 줄고 분산은 커진다. 이것이 편향-분산 트레이드오프이고, 05장의 과소적합·과적합을 수치로 본 것이다.
  • 랜덤 포레스트는 깊은 트리의 낮은 편향을 유지하면서 분산을 절반 아래로 줄였다. 깊은 트리 여러 개를 평균했기 때문이다. 이 예에서는 깊이 3 트리와 합이 비슷하지만, 숲은 깊이를 고르지 않고도 이 수준에 왔다. 다음 절이 그 방법이다.

같은 데이터로 같은 트리를 여러 번 학습하면 같은 트리만 나온다. 평균이 효과를 보려면 트리들이 서로 달라야 한다. 랜덤 포레스트(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
  • 부트스트랩에는 원래 표본의 약 63%(1−1/e1 - 1/e)만 들어가고, 나머지 약 37%는 그 트리가 보지 못한 표본이다. 이를 OOB(out-of-bag) 표본이라 한다. 표본마다 자기를 못 본 트리들로만 예측해 채점한 것이 oob_score_다. 검증 데이터를 따로 떼지 않아도 일반화 성능을 어림할 수 있다.
  • 숲의 확률은 트리들의 predict_proba 평균이다(위에서 True). 예측은 그 평균 확률이 가장 큰 범주다.
  • 훈련 정확도가 1.0인데도 검증이 단일 트리(0.83)보다 높다. 숲의 훈련 정확도는 과적합 판단에 쓰지 않는다. 각 트리가 깊게 자라 훈련 표본을 외웠기 때문이다. 판단은 OOB나 검증으로 한다.
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
  • 트리 수(n_estimators)를 늘린다고 과적합이 심해지지는 않는다. 평균하는 트리가 많을수록 결과가 안정될 뿐이고, 어느 지점부터는 시간만 든다. 그래서 랜덤 포레스트는 “충분히 크게(수백 개)” 두고 튜닝하지 않는 경우가 많다.
  • 트리 수가 아주 적으면(예: 10개) 모든 트리의 부트스트랩에 들어가 OOB 예측이 없는 표본이 생기고, oob_score_를 믿을 수 없다는 경고(UserWarning)가 난다.
  • 랜덤 포레스트에서 주로 고르는 값은 max_features와 min_samples_leaf다. 기본값으로도 대체로 무난해서 튜닝 없이 바로 강한 기준선이 된다.

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

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

랜덤 포레스트는 깊은 트리를 나란히 키워 평균한다. 부스팅(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
  • 직접 쓴 20줄이 sklearn GradientBoostingRegressor와 같은 예측을 낸다. 특성이 여럿이고 트리가 깊으면 훈련 표본을 똑같이 나누는 질문이 둘 이상인 동점이 생겨, 새 데이터 예측이 조금 다를 수 있다(실습 문제 6).
  • 이름의 그래디언트는 잔차가 제곱 오차 12(y−F)2\tfrac{1}{2}(y - F)^2를 FF로 미분한 기울기의 반대 방향이라는 데서 왔다. 04장 경사하강법이 “매개변수”를 기울기 반대로 움직였다면, 부스팅은 “예측값 FF“를 기울기 반대로 움직이고, 그 움직임을 트리로 근사한다. 이진 분류에서는 FF가 로짓(06장의 선형 점수 zz 자리)이고 확률은 p=σ(F)p = \sigma(F)다. 로그 손실을 FF로 미분한 기울기(06장의 p−yp - y)의 반대 방향, 즉 y−py - p를 잔차 자리에 쓰고, 트리로 이 방향을 근사해 로짓을 고친다. sklearn은 여기에 손실에 맞게 잎 값을 보정하는 단계를 더한다.
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
  • 부스팅은 트리를 더할수록 훈련 오차를 계속 줄인다. 검증 오차는 표시한 단계 중 30개에서 가장 작고(모든 단계를 보면 28개, 그림 오른쪽) 그 뒤로 늘었다. 랜덤 포레스트와 달리 부스팅은 트리를 계속 더하면 과적합할 수 있다. 이 예에서는 28개 뒤로 검증 오차가 커졌다. 데이터에 따라 트리가 많아도 검증 오차가 계속 줄거나 그대로일 수 있으므로, 알맞은 트리 수는 검증이나 조기 종료로 정한다. staged_predict는 트리를 하나씩 더한 단계별 예측이라 한 번 학습으로 이 곡선을 그릴 수 있다.
  • 학습률을 낮추면 한 트리가 고치는 양이 줄어 같은 성능에 트리가 더 많이 필요하지만, 대개 조금 더 좋은 곳에 도달한다. 그래서 실무에서는 학습률을 작게(0.05~0.1) 두고, 트리 수는 조기 종료(early stopping)로 검증 점수가 더 나아지지 않을 때 멈추게 한다.
  • 부스팅의 주요 손잡이: 트리 수, 학습률, 트리 크기(max_depth 또는 max_leaf_nodes). 랜덤 포레스트보다 튜닝에 민감하지만, 잘 맞추면 표 데이터에서 대개 가장 강하다.

실무에서 쓰는 부스팅: HistGradientBoosting

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

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

  • 결측값(NaN)을 그대로 받는다. 분할마다 결측 표본을 왼쪽·오른쪽 중 나은 쪽으로 보낸다.
  • 표본이 10,000개를 넘으면 기본으로 조기 종료가 켜진다(early_stopping="auto"). 그보다 적으면 early_stopping=True로 켠다. 이때 훈련 데이터의 일부(validation_fraction, 기본 10%)를 떼어 멈출 시점을 정한다.
  • 범주형 특성을 원-핫 없이 직접 다루는 categorical_features 옵션이 있다(9장).
  • 트리 수는 n_estimators가 아니라 max_iter(최대 반복 수, 기본 100)로 정한다. 학습 뒤 n_iter_로 실제 반복 수를(이 장의 회귀·이진 분류에서는 반복마다 트리 하나), do_early_stopping_로 조기 종료가 켜졌는지를 확인한다.
  • 같은 계열의 XGBoost·LightGBM·CatBoost는 별도 라이브러리다. 원리와 손잡이(트리 수·학습률·트리 크기·조기 종료)는 같다.

이제 표 데이터에 쓴다. 가상의 통신사 고객 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
  • 불순도 중요도로는 의미 없는 고객번호가 0.137로 나이·상담횟수보다 높다. 값이 모두 다른 숫자 열은 임계값 후보가 많아, 깊은 트리가 표본 몇 개를 가르는 데 쓰기 쉽기 때문이다. 순열 중요도로는 0 근처(음수)로 떨어진다. 검증 데이터에서는 아무 도움이 안 된다는 뜻이다.
  • 반대로 상담횟수는 값의 종류가 몇 개뿐이라 불순도 중요도가 낮게 나오지만, 순열 중요도로는 셋째로 중요하다.
  • 실제 규칙에 쓰인 계약개월·월요금·상담횟수·데이터GB가 순열 중요도에서 위에 온다. 그래서 중요도는 검증 데이터의 순열 중요도를 기본으로 본다.
  • 둘 다 주의할 점: 서로 강하게 얽힌 특성(예: 월요금과 연간요금)이 있으면 중요도를 그대로 믿기 어렵다. 불순도 중요도는 둘이 나눠 갖거나 한쪽에 몰린다. 순열 중요도는 하나를 섞어도 다른 하나가 정보를 대신해 둘 다 낮게 나올 수 있다. 또 중요도는 “모델이 그 특성을 썼다”는 뜻이지 “그 특성이 이탈의 원인”이라는 뜻이 아니다. 인과는 실험이나 다른 분석이 필요하다.

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
  • 트리 앙상블이 로지스틱 회귀보다 AUC가 0.05가량 높다. 이탈 규칙의 상호작용(짧은 계약 이면서 높은 요금)과 문턱(상담 4회 이상)을 트리는 질문 두어 개로 바로 표현하지만, 선형 모델은 “계약이 짧을수록 조금씩, 요금이 높을수록 조금씩”밖에 표현하지 못한다.
  • 단일 트리는 로지스틱 회귀와 비슷하다. 트리 하나는 분산이 커서 앙상블로 묶어야 힘이 난다.
  • 이 정도 데이터(2100명, 특성 6개)에서는 랜덤 포레스트와 HistGB의 차이가 조각 간 흔들림보다 작다. 둘 중 무엇이 이길지는 데이터마다 다르므로 둘 다 돌려 본다.

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

섹션 제목: “트리 앙상블이 표 데이터에 잘 맞는 이유”
성질 트리 앙상블 선형 모델
단위·스케일 영향 없음(순서만 본다) 스케일링 필요(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.]
  • x=20x = 20에서 정답은 40이지만, 숲은 12에서도 20에서도 18.4로 같다. 훈련에서 본 가장 큰 값(19) 근처의 잎 평균에 머문 것이다. 시간에 따라 계속 오르는 매출·가격처럼 앞으로의 값이 훈련 범위를 벗어나는 문제에는 트리를 그대로 쓰면 안 된다(추세를 따로 빼거나 선형 모델과 섞는다).
  • 부스팅은 트리 출력을 더하므로 훈련에서 본 정답 범위를 조금 벗어난 값을 낼 수는 있다. 그래도 입력이 훈련 범위를 넘으면 트리마다 맨 끝 잎에 머물러 예측이 일정해지므로, 추세를 이어 가지 못하는 것은 같다.

단일 트리의 확률도 약점이다. 잎의 범주 비율이라 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
  • 단일 트리는 정확도 0.93인데 로그 손실이 2를 넘는다. 잎의 확률이 0·1이라 틀릴 때 확신하고 틀리기 때문이다(06장 6-5절). 랜덤 포레스트는 트리 확률을 평균하고, HistGB는 트리 점수를 더한 뒤 시그모이드로 확률을 내므로(06장) 0·1에 덜 몰려 훨씬 낫다. 그래도 확률 자체가 중요하면 검증 로그 손실로 확인한다.
  • 이 데이터처럼 관계가 거의 선형이고 표본이 적으면 로지스틱 회귀가 트리 앙상블과 비슷하거나 더 낫다. 그래서 늘 06장 기준선과 비교한다.
  • 이미지·소리·문장 원본처럼 특성 하나하나(픽셀 하나)에 뜻이 없는 데이터에는 약하다. 이런 데이터는 신경망(10장 이후)이 특성을 스스로 만든다.

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

섹션 제목: “7-10. 트리와 앙상블을 언제 쓰나”
상황 고를 것 이유
표 데이터, 기준선 다음 랜덤 포레스트(튜닝 없이) → HistGradientBoosting(조기 종료) 상호작용·문턱·결측을 스스로 다룬다
규칙으로 설명해야 한다 얕은 트리 하나(max_depth 3~4) + export_text 질문 몇 개로 그대로 읽힌다. 성능은 앙상블보다 낮다
데이터가 크다(수만 건 이상) HistGradientBoosting 구간으로 묶어 빠르고 조기 종료가 기본으로 켜진다
어떤 특성을 썼는지 알고 싶다 검증 데이터의 순열 중요도 불순도 중요도는 값의 종류가 많은 열을 부풀린다
미래 값이 훈련 범위를 넘는다 선형 모델 또는 추세 제거 후 트리 트리는 외삽하지 못한다
이미지·소리·문장 원본 신경망(12·14장), 사전학습 모델이 뽑은 특성(15장) 원본 픽셀·글자 하나에는 뜻이 없다
상황 고를 것 이유 장
표 데이터에서 기준선보다 나은 모델 랜덤 포레스트, 그다음 HistGradientBoosting(조기 종료) 상호작용·문턱·결측·스케일을 스스로 다루고 튜닝 부담이 작다 07
트리 하나를 쓴다 max_depth·min_samples_leaf를 검증으로 제한 제한 없는 트리는 훈련 데이터를 외운다(분산이 크다) 07
부스팅을 쓴다 작은 학습률 + 조기 종료로 트리 수 결정 부스팅은 트리를 계속 더하면 과적합할 수 있다 07
특성 중요도를 보고한다 검증 데이터 순열 중요도, 인과로 해석하지 않음 불순도 중요도는 ID 같은 열을 부풀리고, 얽힌 특성은 서로 나눠 가진다 07
훈련 범위 밖 값을 예측한다 트리 단독은 피한다 트리는 범위 밖 입력에 맨 끝 잎의 값만 내서 추세를 잇지 못한다 07

10문항. 풀면 결과가 기록되고 복습 일정에 들어간다.

문제 1 · O/X

특성이 2개일 때 결정 트리는 질문 하나로 "x1+x2≤1x_1 + x_2 \le 1" 같은 비스듬한 직선 경계를 만들 수 있다.

보기
정답과 해설

정답: X (거짓)

트리의 질문은 늘 "특성 하나 ≤ 임계값"이라 한 번에 축에 평행한 선만 긋는다. 비스듬한 경계는 질문을 여러 번 이어 계단으로 근사할 뿐이다.

문제 2 · 빈칸

범주 0과 1이 5개씩인 노드를 왼쪽 (0이 4개, 1이 0개)과 오른쪽 (0이 1개, 1이 5개)으로 나눴다. 이 분할의 가중 지니 불순도를 소수 셋째 자리까지 반올림하면 ____이다.

정답과 해설

정답: 0.167

왼쪽은 한 범주뿐이라 지니 0이다. 오른쪽은 1−((1/6)2+(5/6)2)=10/36≈0.2781 - \left((1/6)^2 + (5/6)^2\right) = 10/36 \approx 0.278이다. 표본 수로 가중 평균하면 (4×0+6×10/36)/10=1/6≈0.167(4 \times 0 + 6 \times 10/36) / 10 = 1/6 \approx 0.167이다.

문제 3 · 객관식

범주 0·1이 400개씩인 노드를 A (300, 100)/(100, 300)와 B (200, 400)/(200, 0)로 나누는 두 후보가 있다. 둘 다 다수결 정확도는 0.75다. 트리가 정확도 대신 불순도로 분할을 고르는 이유를 이 예로 설명한 것은?

보기
정답과 해설

정답: 4번

가중 지니는 A 0.375, B 0.333으로 B가 더 작다. 지니·엔트로피는 비율에 대해 위로 볼록한 곡선이라 한쪽 자식이 깨끗해질수록 보상을 준다. 정확도는 꺾인 직선 모양이라 이런 차이를 놓친다.

오답 해설: 로그가 들어가는 것은 엔트로피이고 정확도는 아니다. 분할 점수는 검증이 아니라 그 노드의 훈련 표본으로 계산한다. 트리는 지금 가장 좋은 질문만 고르는 탐욕적 방법이라 다음 단계를 내다보지 않는다.

문제 4 · 객관식

같은 실험에서 깊이 3 트리의 편향²이 0.003, 분산이 0.035이고, 데이터의 잡음 분산이 0.09다. 새 데이터에서 이 트리의 기대 제곱 오차는 약 얼마인가?

보기
정답과 해설

정답: 2번

기대 제곱 오차는 편향² + 분산 + 잡음 분산 =0.003+0.035+0.09=0.128= 0.003 + 0.035 + 0.09 = 0.128이다. 잡음 분산은 어떤 모델로도 줄일 수 없어 늘 더해진다.

오답 해설: 0.038은 편향²과 분산만 더하고 잡음 분산을 빠뜨렸다. 0.090은 잡음 분산만, 0.035는 분산만 적은 값이다.

문제 5 · 결과 예측

표본 6개(번호 0~5)에서 부트스트랩으로 뽑은 번호가 아래 idx다. 아래 코드의 출력은?

import numpy as np
idx = np.array([0, 2, 2, 4, 4, 4])
print(len(np.unique(idx)), sorted(set(range(6)) - set(idx.tolist())))
보기
정답과 해설

정답: 3번

중복을 허락해 6번 뽑았지만 서로 다른 표본은 0, 2, 4의 3개뿐이다. 뽑히지 않은 1, 3, 5가 이 트리의 OOB 표본이다. 표본이 많으면 들어가는 비율은 약 63%, 빠지는 비율은 약 37%가 된다.

오답 해설: 6과 빈 목록은 중복 없이 모두 뽑혔다고 본 답이다. [0, 2, 4]는 뽑힌 표본을 OOB로 착각했다. 4와 [1, 3]은 서로 다른 표본 수를 잘못 셌다.

문제 6 · O/X

랜덤 포레스트는 n_estimators(트리 수)를 늘리면 과적합이 심해지므로, 검증으로 작은 값을 골라야 한다.

보기
정답과 해설

정답: X (거짓)

숲은 트리들의 확률을 평균하므로 트리가 많을수록 결과가 안정될 뿐 과적합이 심해지지 않는다. 어느 지점부터는 시간만 든다. 그래서 수백 개로 충분히 크게 두고 튜닝하지 않는 경우가 많다. 트리를 계속 더하면 과적합할 수 있는 것은 부스팅이다.

문제 7 · 객관식

그래디언트 부스팅의 이름에 "그래디언트"가 붙은 이유로 맞는 것은?

보기
정답과 해설

정답: 1번

12(y−F)2\tfrac{1}{2}(y - F)^2를 FF로 미분하면 F−yF - y이고, 그 반대 방향이 잔차 y−Fy - F다. 04장 경사하강법은 매개변수를 기울기 반대로 움직였고, 부스팅은 예측값 FF를 기울기 반대로 움직이며 그 움직임을 트리로 근사한다.

오답 해설: 트리의 분할 임계값은 불순도·분산을 줄이는 탐색으로 정하지 경사하강법으로 옮기지 않는다. 학습률 η\eta는 사람이 정하는 고정값이다. 부스팅은 특성을 새로 만들지 않는다.

문제 8 · 객관식

특성에 월요금과 연간요금(월요금 × 12)이 함께 있다. 검증 데이터로 순열 중요도를 재면 어떻게 될 가능성이 큰가?

보기
정답과 해설

정답: 4번

순열 중요도는 특성 하나를 섞어 그 특성과 정답의 관계를 끊은 뒤 점수가 얼마나 떨어지는지 잰다. 같은 정보를 가진 다른 특성이 남아 있으면 모델이 그것을 써서 점수가 별로 떨어지지 않으므로, 둘 다 중요도가 낮게 나올 수 있다.

오답 해설: 트리는 순서만 보므로 단위가 12배라는 것만으로 중요도가 커지지는 않는다. 정보가 겹친다고 중요도가 두 번 더해지는 것도 아니다. 특성마다 따로 섞어 재도 두 특성이 얽혀 있다는 영향은 남는다. 다만 모델이 두 특성에 어떻게 기대느냐에 따라 달라서, 한쪽만 주로 쓴 모델에서는 그쪽 중요도만 높게 나오기도 한다. 얽힌 특성은 불순도 중요도에서도 주의할 점이다(둘이 나눠 갖거나 한쪽에 몰린다).

문제 9 · 객관식

유방암 데이터에서 제한 없는 결정 트리의 교차검증 정확도는 0.927인데 로그 손실은 2.614로, 로지스틱 회귀(0.088)보다 훨씬 크다. 그 이유는?

보기
정답과 해설

정답: 2번

제한 없는 트리의 잎은 한 범주만 남을 때까지 나뉘므로 확률이 0 또는 1이다. 틀린 표본에서 정답 쪽 확률이 0에 가까우면 −log⁡p-\log p가 아주 커진다. 확신하고 틀리는 것을 크게 벌하는 로그 손실의 성질이다.

오답 해설: 트리도 잎의 범주 비율로 predict_proba를 낸다. 로그 손실은 정확도로 정해지지 않는다. 같은 정확도라도 확률이 얼마나 믿을 만한지에 따라 크게 다르다. 트리는 스케일링의 영향을 받지 않는다.

문제 10 · 객관식

해마다 매출이 꾸준히 오르는 매장들의 내년 매출을, 지난 몇 해 데이터로 예측하려 한다. 가장 알맞은 선택은?

보기
정답과 해설

정답: 3번

내년 매출은 훈련에서 본 범위를 넘어설 가능성이 크다. 트리는 범위 밖 입력에 맨 끝 잎의 값만 내서 추세를 잇지 못하므로, 추세를 다룰 수 있는 선형 모델을 쓰거나 추세를 빼고 트리를 쓴다.

오답 해설: 랜덤 포레스트도 트리라 훈련에서 본 가장 큰 매출 근처에 머문다. 제한 없는 트리는 외삽을 못 할 뿐 아니라 과적합까지 한다. HistGB도 트리를 더한 것이라 범위 밖에서 예측이 일정해져 추세를 잇지 못하고, 조기 종료 없이 트리 수를 키우면 과적합할 수 있다.

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

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