06장에서 원 모양 데이터는 직선으로 나눌 수 없었고, 제곱 특성을 직접 만들어 넣어서야 풀렸다. 이 장의 결정 트리는 “인가?” 같은 예/아니오 질문을 이어 붙여 경계 모양을 데이터에서 스스로 찾는다. 트리 하나는 훈련 데이터를 외우기 쉽다. 그래서 트리를 여러 개 묶는 앙상블을 쓴다. 서로 다른 데이터로 키운 트리를 평균하는 랜덤 포레스트, 앞 트리가 틀린 만큼을 다음 트리가 고치는 그래디언트 부스팅이다. 마지막으로 모델이 어떤 특성을 썼는지 보는 특성 중요도와 그 함정, 표 데이터에서 트리 앙상블이 강한 이유와 약점을 정리한다.
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. 왜 트리와 앙상블인가”- 경계 모양을 스스로 찾는다. 선형 모델은 특성에 대해 선형이라 휘어진 경계나 “A이면서 B일 때만” 같은 상호작용은 사람이 특성을 만들어 줘야 했다(06장). 트리는 질문을 이어 붙여 이것을 스스로 찾는다.
- 표 데이터의 강자다. 단위·스케일을 타지 않고, 결측값과 특성 간 상호작용을 다룬다. 표 데이터 대회와 실무에서 그래디언트 부스팅(XGBoost·LightGBM·CatBoost, sklearn
HistGradientBoosting)이 가장 흔한 강한 모델이다. - 앙상블이라는 생각. “약한 모델 여럿을 묶어 강한 모델을 만든다”는 생각은 이 장의 트리뿐 아니라 딥러닝의 여러 모델 평균, 드롭아웃(11장) 해석에도 다시 나온다.
7-3. 결정 트리
섹션 제목: “7-3. 결정 트리”질문을 이어 붙인다
섹션 제목: “질문을 이어 붙인다”06장의 원 모양 데이터와 훈련·검증 분할을 그대로 쓴다. 깊이(질문 단계 수)를 2로 제한한 트리를 학습하고 규칙으로 출력한다.
import numpy as npfrom sklearn.datasets import make_circlesfrom sklearn.model_selection import train_test_splitfrom 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)은 그 잎의 범주 비율이다. - 질문은 늘 “특성 하나 ≤ 임계값”이다. 그래서 경계는 축에 평행한 선분을 이은 계단 모양이 된다.
- 위 트리는 만 두 번 써서 가로 띠 하나를 1(안쪽 원)로 잘라냈다. 원을 그리기에는 질문이 부족하다.
잠깐 확인 (ch07-i01)
본문의 깊이 2 트리(x2 <= -0.70이면 0, 아니면 x2 <= 0.58이면 1, 아니면 0)는 점 을 어떻게 예측하는가? 원 데이터에서 이 점은 바깥 고리보다도 멀리 있다.
0이다. 가 원 밖이라 바깥 고리 쪽으로 보낸다
0이다. 뿌리 노드에서 을 먼저 묻는다
1이다. 이 트리는 만 묻고, 은 −0.70과 0.58 사이다
어느 잎에도 닿지 않아 확률 0.5를 낸다
깊이를 늘리면
섹션 제목: “깊이를 늘리면”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.944None 12 1.000 0.944- 06장에서 직선 경계는 검증 정확도 0.433, 제곱 특성을 직접 넣은 로지스틱 회귀는 0.978이었다. 트리는 특성을 만들지 않고 깊이 4에서 0.956까지 왔다. 원을 계단으로 근사한 것이다.
max_depth=None이면 잎이 한 범주만 남거나 더 나눌 수 없을 때까지 나눈다. 이 데이터에서는 모든 잎이 한 범주만 남아 훈련 정확도가 1.0이 되지만 검증은 오르지 않는다. 특성 값이 똑같은데 정답이 다른 표본이 있으면 더 나눌 수 없어 섞인 잎이 남기도 한다. 다음 절에서 이 과적합을 다룬다.
스케일링이 필요 없다
섹션 제목: “스케일링이 필요 없다”질문이 ” 임계값”뿐이라, 특성에 양수를 곱하거나 어떤 수를 더해도(표준화가 이 경우다) 같은 분할·같은 예측이 나온다. 임계값만 그 단위로 바뀐다. 세제곱·로그처럼 순서만 지키는 변환에서도 훈련 표본을 나누는 방식은 같다. 다만 임계값은 이웃한 두 값의 가운데라, 변환한 뒤의 가운데가 원래 가운데와 대응하지 않아 그 사이에 오는 새 표본의 예측은 달라질 수 있다(아래 데이터에서는 같았다).
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 True06장에서 로지스틱 회귀는 단위 하나만 바꿔도 예측이 달라졌다. 트리는 그렇지 않으므로 StandardScaler가 필요 없다. 넣어도 해는 없지만 결과는 같다. 단, sklearn 트리는 입력을 32비트 실수로 바꾸므로, 아주 큰 수를 더해 서로 다른 값이 같은 수로 뭉개질 정도면 분할이 달라진다.
잠깐 확인 (ch07-i02)
결정 트리에서 특성 하나를 표준화하거나 단위만 바꿔(양수를 곱해) 같은 random_state로 다시 학습하고, 예측할 데이터에도 같은 변환을 했다. 부동소수점 반올림의 영향을 무시하면 예측은 그대로다.
O / X
7-4. 어떤 질문을 고르나: 불순도
섹션 제목: “7-4. 어떤 질문을 고르나: 불순도”지니 불순도와 엔트로피
섹션 제목: “지니 불순도와 엔트로피”트리는 각 노드에서 모든 특성 × 모든 임계값을 시도해, 나눈 뒤 두 자식 노드가 가장 “깨끗해지는” 질문을 고른다. 깨끗함의 반대를 불순도(impurity)라 하고, 범주 비율 로 잰다.
- 지니 불순도(Gini impurity): . sklearn 기본값(
criterion="gini"). - 엔트로피(entropy): .
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이다. 둘은 모양이 비슷해서 실제로 고르는 분할도 대개 같다. 지니가 로그가 없어 조금 빠르다.
잠깐 확인 (ch07-i03)
범주 0이 6개, 1이 2개인 노드다. 아래 코드의 출력은?
import numpy as np
y = np.array([0] * 6 + [1] * 2)
p = np.bincount(y) / len(y)
print(round(1 - np.sum(p ** 2), 3), round(-np.sum(p * np.log2(p)), 3))
0.375 0.811
0.625 0.811
0.375 0.562
0.25 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_samplesprint("직접 :", 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.4134sklearn: 1 -0.6996 0.4134뿌리 지니 0.5 → 나눈 뒤 0.4134- 직접 찾은 분할(특성 1 = , 임계값 −0.70)이 sklearn과 같다. sklearn은 특성을 32비트 실수로 바꿔 계산하므로 임계값의 아주 뒷자리는 다를 수 있다.
- 불순도가 0.5에서 0.413으로 줄었다. 이 줄어든 양을 불순도 감소라 하고, 엔트로피를 쓸 때는 정보 이득(information gain)이라 한다. 트리는 이것을 노드마다 반복하는 탐욕적(greedy) 방법이다. 지금 가장 좋은 질문을 고를 뿐, 몇 단계 뒤까지 내다보지는 않는다.
- 범주가 아니라 숫자를 예측하는 회귀 트리(
DecisionTreeRegressor)는 기본값(제곱 오차 기준)에서 불순도 대신 잎 안의 분산(평균 제곱 오차)을 줄이는 분할을 고르고, 잎의 예측값은 그 잎 표본의 평균이다.criterion="absolute_error"를 고르면 절대 오차를 줄이고 잎의 예측값은 중앙값이 된다.
잠깐 확인 (ch07-i04)
분류 트리가 한 노드에서 질문(특성, 임계값)을 고르는 기준으로 맞는 것은?
두 자식 노드 불순도의 단순 평균이 가장 작은 질문
두 자식 노드 불순도를 표본 수로 가중 평균한 값이 가장 작은 질문
나눈 뒤 다수결 정확도가 가장 높아지는 질문
몇 단계 뒤까지 내다봤을 때 최종 잎들이 가장 깨끗해지는 질문
수학 상자: 왜 정확도가 아니라 불순도인가
섹션 제목: “수학 상자: 왜 정확도가 아니라 불순도인가”정확도로 분할을 고르면 좋은 분할을 구분하지 못할 때가 있다. 범주 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를 더 좋게 본다.
- 지니·엔트로피는 비율 에 대해 위로 볼록한(∩ 모양) 곡선이다. 그래서 자식 노드의 비율이 부모 비율에서 멀어질수록(한쪽이 깨끗해질수록) 가중 불순도가 부모보다 줄어들고, “한쪽이라도 깨끗하게” 만드는 분할에 보상을 준다. 다수결 정확도는 꺾인 직선 모양이라, 위 A·B처럼 정확도가 같은 서로 다른 분할이 생기고 그 차이를 놓칠 수 있다.
- 엔트로피는 “표본의 범주를 알게 될 때 얻는 평균 정보량”을 비트 단위로 잰 값이다(같은 노드의 표본을 아주 많이 한꺼번에 알려 줄 때 표본 하나에 필요한 예/아니오 질문 수의 하한). 지니는 “노드에서 표본 하나를 뽑아 범주를 보고 되돌려 놓은 뒤(복원 추출) 다시 하나를 뽑았을 때 두 범주가 다를 확률”이다.
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.843max_depth=5 18 0.923 0.847제한 없음 47 1.000 0.830min_samples_leaf=10 16 0.903 0.863min_samples_leaf=40 6 0.847 0.813← 좌우로 밀거나, 그림을 누른 뒤 ← → 키로 옮겨 전체를 본다
그림 설명. 반달 데이터의 훈련 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도 같은 손잡이다.
잠깐 확인 (ch07-i05)
반달 데이터에서 트리 설정별 (훈련, 검증) 정확도가 max_depth=2 (0.890, 0.843), 제한 없음 (1.000, 0.830), min_samples_leaf=10 (0.903, 0.863), min_samples_leaf=40 (0.847, 0.813)이다. 옳은 해석은?
훈련 정확도가 1.000인 제한 없는 트리가 가장 좋은 모델이다
min_samples_leaf=40은 잎이 커서 과적합한 경우다max_depth와min_samples_leaf는 트리 수를 정하는 손잡이다이 중에서는 검증이 가장 높은
min_samples_leaf=10을 고르고, 제한 없는 트리는 과적합이다
편향과 분산
섹션 제목: “편향과 분산”깊은 트리의 과적합은 훈련 데이터가 조금만 바뀌어도 모델이 크게 바뀌는 성질과 관련이 있다. 이것을 재려면 같은 규칙에서 훈련 데이터를 여러 벌 뽑아 각각 학습하고, 같은 점에서의 예측이 얼마나 흔들리는지 본다. 정답 규칙을 아는 회귀 예()로 한다.
- 편향(bias): 여러 모델 예측의 평균이 정답과 얼마나 다른지를 나타낸다. 모델이 너무 단순하면 크다.
- 분산(variance): 예측이 훈련 데이터에 따라 얼마나 흔들리는지를 나타낸다. 모델이 너무 복잡하면 크다.
from sklearn.tree import DecisionTreeRegressorfrom 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← 좌우로 밀거나, 그림을 누른 뒤 ← → 키로 옮겨 전체를 본다
그림 설명. 왼쪽 두 칸은 가로축 (0~6), 세로축 예측값(−2~2)이다. 점선이 정답 , 파란 가는 선이 서로 다른 훈련 데이터 10벌로 학습한 트리의 예측, 빨간 굵은 선이 50벌 예측의 평균이다. 첫째 칸 깊이 1 트리는 모두 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) 데이터마다 크게 흔들려 분산이 크다(그림 왼쪽 두 칸).
- 새 데이터에서 기대 제곱 오차 이다(여기서 잡음 분산은 ). 잡음은 어떤 모델로도 줄일 수 없다. 같은 종류의 모델에서 복잡도를 올리면 보통 편향은 줄고 분산은 커진다. 이것이 편향-분산 트레이드오프이고, 05장의 과소적합·과적합을 수치로 본 것이다.
- 랜덤 포레스트는 깊은 트리의 낮은 편향을 유지하면서 분산을 절반 아래로 줄였다. 깊은 트리 여러 개를 평균했기 때문이다. 이 예에서는 깊이 3 트리와 합이 비슷하지만, 숲은 깊이를 고르지 않고도 이 수준에 왔다. 다음 절이 그 방법이다.
잠깐 확인 (ch07-i06)
같은 규칙에서 뽑은 훈련 데이터 50벌로 잰 결과가 깊이 1 트리 (편향² 0.064, 분산 0.033), 깊이 제한 없는 트리 (편향² 0.002, 분산 0.089)다. 옳은 것은?
깊이 1 트리는 분산이 커서 오차가 크다
두 트리의 편향²+분산이 비슷하므로 둘은 같은 방식으로 틀린다
제한 없는 트리는 평균 예측이 정답에 가깝지만, 훈련 데이터마다 예측이 크게 흔들린다
모델을 더 복잡하게 하면 잡음 분산까지 줄일 수 있다
7-6. 랜덤 포레스트
섹션 제목: “7-6. 랜덤 포레스트”서로 다른 트리를 평균한다
섹션 제목: “서로 다른 트리를 평균한다”같은 데이터로 같은 트리를 여러 번 학습하면 같은 트리만 나온다. 평균이 효과를 보려면 트리들이 서로 달라야 한다. 랜덤 포레스트(random forest)는 두 가지 무작위성을 넣는다.
- 부트스트랩(bootstrap): 트리마다 훈련 데이터 N개에서 중복을 허락해 N개를 다시 뽑아 학습한다. 이렇게 뽑은 데이터로 학습해 평균하는 방법을 배깅(bagging, bootstrap aggregating)이라 한다.
- 특성 무작위 선택: 노드마다 특성 일부만 후보로 보고 분할을 고른다(
max_features, 분류 기본값"sqrt"= ). 강한 특성 하나가 모든 트리의 뿌리를 차지해 트리들이 닮는 것을 막는다.
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%()만 들어가고, 나머지 약 37%는 그 트리가 보지 못한 표본이다. 이를 OOB(out-of-bag) 표본이라 한다. 표본마다 자기를 못 본 트리들로만 예측해 채점한 것이
oob_score_다. 검증 데이터를 따로 떼지 않아도 일반화 성능을 어림할 수 있다. - 숲의 확률은 트리들의
predict_proba평균이다(위에서True). 예측은 그 평균 확률이 가장 큰 범주다. - 훈련 정확도가 1.0인데도 검증이 단일 트리(0.83)보다 높다. 숲의 훈련 정확도는 과적합 판단에 쓰지 않는다. 각 트리가 깊게 자라 훈련 표본을 외웠기 때문이다. 판단은 OOB나 검증으로 한다.
잠깐 확인 (ch07-i07)
랜덤 포레스트의 훈련 정확도가 1.000이면 과적합한 것이므로, 검증 정확도는 같은 데이터의 제한 없는 단일 트리보다 낮을 것이다.
O / X
트리 수
섹션 제목: “트리 수”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다. 기본값으로도 대체로 무난해서 튜닝 없이 바로 강한 기준선이 된다.
잠깐 확인 (ch07-i08)
랜덤 포레스트의 oob_score_는 어떻게 계산한 점수인가?
표본마다 그 표본이 부트스트랩에 들어가지 않은 트리들로만 예측해 채점한 점수
훈련 데이터 전체를 모든 트리로 예측해 채점한 점수
훈련 데이터에서 10%를 따로 떼어 검증 데이터로 채점한 점수
트리를 하나씩 더할 때마다 다시 채점한 점수들의 평균
7-7. 그래디언트 부스팅
섹션 제목: “7-7. 그래디언트 부스팅”틀린 만큼을 다음 트리가 고친다
섹션 제목: “틀린 만큼을 다음 트리가 고친다”랜덤 포레스트는 깊은 트리를 나란히 키워 평균한다. 부스팅(boosting)은 얕은 트리를 차례로 쌓는다. 회귀에서 제곱 오차를 쓰면 방법이 아주 단순하다.
- 처음 예측 의 평균.
- 지금 예측이 틀린 양 잔차(residual) 를 구한다.
- 얕은 트리 하나를 잔차에 맞춘다.
- . 는 학습률(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). - 이름의 그래디언트는 잔차가 제곱 오차 를 로 미분한 기울기의 반대 방향이라는 데서 왔다. 04장 경사하강법이 “매개변수”를 기울기 반대로 움직였다면, 부스팅은 “예측값 “를 기울기 반대로 움직이고, 그 움직임을 트리로 근사한다. 이진 분류에서는 가 로짓(06장의 선형 점수 자리)이고 확률은 다. 로그 손실을 로 미분한 기울기(06장의 )의 반대 방향, 즉 를 잔차 자리에 쓰고, 트리로 이 방향을 근사해 로짓을 고친다. sklearn은 여기에 손실에 맞게 잎 값을 보정하는 단계를 더한다.
잠깐 확인 (ch07-i09)
부스팅 한 단계를 손으로 해 본다. 트리가 잔차를 정확히 맞혔다고 가정하고 학습률 0.5로 더한다. 아래 코드의 출력은?
import numpy as np
y = np.array([1.0, 2.0, 6.0])
F = np.full(3, y.mean())
r = y - F
F = F + 0.5 * r
print(F.tolist())
[1.0, 2.0, 6.0]
[3.0, 3.0, 3.0]
[4.0, 3.5, 1.5]
[2.0, 2.5, 4.5]
트리 수와 학습률
섹션 제목: “트리 수와 학습률”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는 별도 라이브러리다. 원리와 손잡이(트리 수·학습률·트리 크기·조기 종료)는 같다.
잠깐 확인 (ch07-i10)
그래디언트 부스팅의 트리 수에 대해 옳은 것은?
랜덤 포레스트처럼, 트리를 많이 둘수록 검증 성능이 좋아지거나 그대로다
트리를 계속 더하면 과적합할 수 있어, 작은 학습률을 두고 조기 종료로 트리 수를 정한다
학습률을 낮추면 같은 성능에 필요한 트리 수가 줄어든다
staged_predict를 부르면 가장 좋은 트리 수만 남기고 나머지 트리를 지운다
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 = 3000df = 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.nanD_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가 순열 중요도에서 위에 온다. 그래서 중요도는 검증 데이터의 순열 중요도를 기본으로 본다.
- 둘 다 주의할 점: 서로 강하게 얽힌 특성(예: 월요금과 연간요금)이 있으면 중요도를 그대로 믿기 어렵다. 불순도 중요도는 둘이 나눠 갖거나 한쪽에 몰린다. 순열 중요도는 하나를 섞어도 다른 하나가 정보를 대신해 둘 다 낮게 나올 수 있다. 또 중요도는 “모델이 그 특성을 썼다”는 뜻이지 “그 특성이 이탈의 원인”이라는 뜻이 아니다. 인과는 실험이나 다른 분석이 필요하다.
잠깐 확인 (ch07-i11)
이탈과 무관한 고객번호의 불순도 중요도(feature_importances_)가 나이·상담횟수보다 높게 나왔다. 그 이유로 가장 알맞은 것은?
데이터를 만들 때 고객번호가 이탈 확률에 조금씩 반영됐기 때문이다
불순도 중요도는 검증 데이터로 재므로 작은 우연이 크게 반영되기 때문이다
서로 다른 값이 3000개라, 깊은 곳에서 몇 명만 떼어 내는 질문에 자주 쓰이기 때문이다
정수 열이라 트리가 범주형으로 보고 값마다 따로 가지를 치기 때문이다
7-9. 표 데이터에서 트리 앙상블이 강한 이유
섹션 제목: “7-9. 표 데이터에서 트리 앙상블이 강한 이유”같은 데이터로 비교
섹션 제목: “같은 데이터로 비교”06장 기준선(결측 대체 + 표준화 + 로지스틱 회귀)과 트리 모델을 같은 교차검증으로 비교한다. 로지스틱 회귀는 NaN을 받지 못해 SimpleImputer(평균으로 채움)를 앞에 둔다. sklearn 1.9의 트리·랜덤 포레스트·HistGradientBoosting은 NaN을 그대로 받는다.
from sklearn.model_selection import StratifiedKFold, cross_val_scorefrom sklearn.pipeline import make_pipelinefrom sklearn.preprocessing import StandardScalerfrom sklearn.impute import SimpleImputerfrom sklearn.linear_model import LogisticRegressionfrom 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.017HistGB AUC 0.795 ± 0.030- 트리 앙상블이 로지스틱 회귀보다 AUC가 0.05가량 높다. 이탈 규칙의 상호작용(짧은 계약 이면서 높은 요금)과 문턱(상담 4회 이상)을 트리는 질문 두어 개로 바로 표현하지만, 선형 모델은 “계약이 짧을수록 조금씩, 요금이 높을수록 조금씩”밖에 표현하지 못한다.
- 단일 트리는 로지스틱 회귀와 비슷하다. 트리 하나는 분산이 커서 앙상블로 묶어야 힘이 난다.
- 이 정도 데이터(2100명, 특성 6개)에서는 랜덤 포레스트와 HistGB의 차이가 조각 간 흔들림보다 작다. 둘 중 무엇이 이길지는 데이터마다 다르므로 둘 다 돌려 본다.
잠깐 확인 (ch07-i12)
이탈 데이터의 5-겹 교차검증 AUC가 랜덤 포레스트 0.803 ± 0.017, HistGB 0.795 ± 0.030이었다. 이것으로 "표 데이터에서는 랜덤 포레스트가 HistGB보다 낫다"고 결론 내릴 수 있다.
O / X
트리 앙상블이 표 데이터에 잘 맞는 이유
섹션 제목: “트리 앙상블이 표 데이터에 잘 맞는 이유”| 성질 | 트리 앙상블 | 선형 모델 |
|---|---|---|
| 단위·스케일 | 영향 없음(순서만 본다) | 스케일링 필요(06장) |
| 상호작용·문턱 | 질문을 이어 붙여 스스로 찾는다 | 곱·구간 특성을 직접 만들어야 한다 |
| 결측값 | HistGB·sklearn 1.4 이후 트리는 그대로 받는다 | 대체가 필요하다 |
| 이상치 | 특성의 극단값에는 임계값만 영향을 받아 덜 민감하다. 회귀 정답의 이상치는 잎 평균을 끌어당긴다 | 계수가 끌려간다 |
| 쓸모없는 특성 | 분할에 덜 쓰일 뿐 대체로 버틴다 | 정규화로 눌러야 한다 |
약점: 범위 밖 예측과 확률
섹션 제목: “약점: 범위 밖 예측과 확률”회귀 트리와 랜덤 포레스트는 잎의 평균값만 낼 수 있으므로 훈련 데이터 범위 밖으로 외삽하지 못한다.
from sklearn.linear_model import LinearRegression
x_line = np.arange(0, 10, 0.5).reshape(-1, 1) # 0 ~ 9.5y_line = 2 * x_line[:, 0] # y = 2xx_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.]- 에서 정답은 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.954HistGB 로그 손실 0.124, 정확도 0.960- 단일 트리는 정확도 0.93인데 로그 손실이 2를 넘는다. 잎의 확률이 0·1이라 틀릴 때 확신하고 틀리기 때문이다(06장 6-5절). 랜덤 포레스트는 트리 확률을 평균하고, HistGB는 트리 점수를 더한 뒤 시그모이드로 확률을 내므로(06장) 0·1에 덜 몰려 훨씬 낫다. 그래도 확률 자체가 중요하면 검증 로그 손실로 확인한다.
- 이 데이터처럼 관계가 거의 선형이고 표본이 적으면 로지스틱 회귀가 트리 앙상블과 비슷하거나 더 낫다. 그래서 늘 06장 기준선과 비교한다.
- 이미지·소리·문장 원본처럼 특성 하나하나(픽셀 하나)에 뜻이 없는 데이터에는 약하다. 이런 데이터는 신경망(10장 이후)이 특성을 스스로 만든다.
잠깐 확인 (ch07-i13)
가 0~9.5인 구간에서 를 학습한 랜덤 포레스트 회귀(본문처럼 기본 설정)에 을 넣으면 예측은 대략 어떻게 되는가?
훈련에서 본 가장 큰 (19) 근처의 값
60에 가까운 값
0에 가까운 값
훈련 범위 밖이라 오류가 난다
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 |
확인 문제
섹션 제목: “확인 문제”문제 1 (ch07-e01)
특성이 2개일 때 결정 트리는 질문 하나로 "" 같은 비스듬한 직선 경계를 만들 수 있다.
O / X
문제 2 (ch07-e02)
범주 0과 1이 5개씩인 노드를 왼쪽 (0이 4개, 1이 0개)과 오른쪽 (0이 1개, 1이 5개)으로 나눴다. 이 분할의 가중 지니 불순도를 소수 셋째 자리까지 반올림하면 ____이다.
답: ________________
문제 3 (ch07-e03)
범주 0·1이 400개씩인 노드를 A (300, 100)/(100, 300)와 B (200, 400)/(200, 0)로 나누는 두 후보가 있다. 둘 다 다수결 정확도는 0.75다. 트리가 정확도 대신 불순도로 분할을 고르는 이유를 이 예로 설명한 것은?
정확도는 계산에 로그가 들어가 느리기 때문이다
불순도는 검증 데이터로 계산해 과적합을 막기 때문이다
불순도를 쓰면 트리가 B 다음 단계까지 내다보고 고르기 때문이다
정확도는 A와 B를 같게 보지만, 지니는 한쪽을 완전히 깨끗하게 만든 B를 더 좋게 본다
문제 4 (ch07-e04)
같은 실험에서 깊이 3 트리의 편향²이 0.003, 분산이 0.035이고, 데이터의 잡음 분산이 0.09다. 새 데이터에서 이 트리의 기대 제곱 오차는 약 얼마인가?
0.038
0.128
0.09
0.035
문제 5 (ch07-e05)
표본 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())))
6 []
3 [0, 2, 4]
3 [1, 3, 5]
4 [1, 3]
문제 6 (ch07-e06)
랜덤 포레스트는 n_estimators(트리 수)를 늘리면 과적합이 심해지므로, 검증으로 작은 값을 골라야 한다.
O / X
문제 7 (ch07-e07)
그래디언트 부스팅의 이름에 "그래디언트"가 붙은 이유로 맞는 것은?
제곱 오차에서 잔차가 손실을 예측값 로 미분한 기울기의 반대 방향이기 때문이다
트리의 분할 임계값을 경사하강법으로 조금씩 옮기기 때문이다
학습률을 매 단계 손실의 기울기에 맞춰 바꾸기 때문이다
특성 값의 변화율(기울기)을 새 특성으로 더하기 때문이다
문제 8 (ch07-e08)
특성에 월요금과 연간요금(월요금 × 12)이 함께 있다. 검증 데이터로 순열 중요도를 재면 어떻게 될 가능성이 큰가?
연간요금이 월요금보다 높게 나올 수 있다. 값의 단위가 12배이기 때문이다
둘 다 높게 나올 수 있다. 같은 정보가 두 번 세어지기 때문이다
둘 다 제 몫대로 나올 수 있다. 특성마다 따로 섞어 재기 때문이다
둘 다 낮게 나올 수 있다. 하나를 섞어도 다른 하나가 정보를 대신하기 때문이다
문제 9 (ch07-e09)
유방암 데이터에서 제한 없는 결정 트리의 교차검증 정확도는 0.927인데 로그 손실은 2.614로, 로지스틱 회귀(0.088)보다 훨씬 크다. 그 이유는?
트리는 확률을 낼 수 없어 로그 손실이 제대로 정의되지 않기 때문이다
잎마다 확률이 한 범주로 몰려, 틀린 표본에서 정답 쪽 확률이 0에 가깝기 때문이다
정확도가 0.95보다 낮으면 로그 손실은 늘 2를 넘기 때문이다
트리에 표준화를 하지 않았기 때문이다
문제 10 (ch07-e10)
해마다 매출이 꾸준히 오르는 매장들의 내년 매출을, 지난 몇 해 데이터로 예측하려 한다. 가장 알맞은 선택은?
튜닝 없이 강한 랜덤 포레스트를 단독으로 쓴다
제한 없는 결정 트리로 연도별 규칙을 그대로 외우게 한다
선형 모델을 쓰거나, 추세를 따로 뺀 뒤 남은 부분에 트리를 쓴다
HistGradientBoosting을 트리 수를 크게 두고 조기 종료 없이 학습한다
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. 공식 문서와 참고 자료”- 결정 트리(사용자 안내서): https://scikit-learn.org/stable/modules/tree.html
- 앙상블(사용자 안내서): https://scikit-learn.org/stable/modules/ensemble.html
DecisionTreeClassifier: https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.htmlRandomForestClassifier: https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.htmlGradientBoostingRegressor: https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.htmlHistGradientBoostingClassifier: https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.HistGradientBoostingClassifier.html- 순열 중요도(사용자 안내서): https://scikit-learn.org/stable/modules/permutation_importance.html
- 불순도 중요도와 순열 중요도 비교 예제: https://scikit-learn.org/stable/auto_examples/inspection/plot_permutation_importance.html
- 부스팅의 조기 종료 예제: https://scikit-learn.org/stable/auto_examples/ensemble/plot_gradient_boosting_early_stopping.html