랜덤 포레스트(Random Forest): 특성 무작위성으로 상관관계를 깨다

배깅:          각 트리 → 부트스트랩 샘플 사용
랜덤 포레스트: 각 트리 → 부트스트랩 샘플 사용
               각 노드 → max_features개 특성만 고려 (← 이 부분이 추가!)

from sklearn.ensemble import RandomForestClassifier

# p=30개 특성이면 sqrt(30) ≈ 5~6개 특성만 각 노드에서 고려
rf = RandomForestClassifier(
    n_estimators=100,
    max_features='sqrt',  # 기본값: 분류에서 √p
    random_state=42
)

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier, RandomForestClassifier

cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 단일 결정 트리
dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)

# 배깅
bagging = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=100,
    max_samples=1.0,    # 부트스트랩 샘플 크기 (기본: 전체)
    max_features=1.0,   # 특성 서브샘플 없음 (배깅의 경우)
    bootstrap=True,
    random_state=42,
    n_jobs=-1
)
bagging.fit(X_train, y_train)

# 랜덤 포레스트
rf = RandomForestClassifier(
    n_estimators=100,
    max_features='sqrt',  # 특성 무작위성 (핵심 차이!)
    random_state=42,
    n_jobs=-1
)
rf.fit(X_train, y_train)

print(f"단일 DecisionTree: {dt.score(X_test, y_test):.4f}")
print(f"BaggingClassifier: {bagging.score(X_test, y_test):.4f}")
print(f"RandomForest:      {rf.score(X_test, y_test):.4f}")

단일 DecisionTree: 0.9474
BaggingClassifier: 0.9561
RandomForest:      0.9649

from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import root_mean_squared_error

housing = fetch_california_housing()
X_h, y_h = housing.data, housing.target
X_tr, X_te, y_tr, y_te = train_test_split(X_h, y_h, test_size=0.2, random_state=42)

rf_reg = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
rf_reg.fit(X_tr, y_tr)

y_pred = rf_reg.predict(X_te)
rmse = root_mean_squared_error(y_te, y_pred)
print(f"RMSE: {rmse:.4f}")
print(f"R²:   {rf_reg.score(X_te, y_te):.4f}")

RMSE: 0.5032
R²:   0.8050

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

rf = RandomForestClassifier(
    n_estimators=200,
    oob_score=True,     # OOB 점수 계산 활성화
    random_state=42,
    n_jobs=-1
)
rf.fit(X_train, y_train)

# 세 가지 평가 방법 비교
cv_scores = cross_val_score(
    RandomForestClassifier(n_estimators=200, random_state=42, n_jobs=-1),
    X, y, cv=5
)

print(f"OOB Score:    {rf.oob_score_:.4f}")
print(f"5-Fold CV:    {cv_scores.mean():.4f} ± {cv_scores.std():.4f}")
print(f"Test Score:   {rf.score(X_test, y_test):.4f}")

OOB Score:    0.9604
5-Fold CV:    0.9578 ± 0.0238
Test Score:   0.9649

특성 j의 중요도 = (1/B) Σ_{b=1}^{B} Σ_{노드 t, 분기 특성=j} Δ불순도(t)

여기서 Δ불순도(t) = 부모 노드 불순도 - (왼쪽 자식 가중 불순도 + 오른쪽 자식 가중 불순도)

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

rf = RandomForestClassifier(n_estimators=200, random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)

# 특성 중요도 추출
importances = rf.feature_importances_
feature_names = cancer.feature_names
sorted_idx = np.argsort(importances)[::-1]

print("상위 10개 중요 특성:")
for i in range(10):
    idx = sorted_idx[i]
    print(f"  {i+1:2d}. {feature_names[idx]:<35s} {importances[idx]:.4f}")

상위 10개 중요 특성:
   1. worst concave points                0.1521
   2. worst perimeter                     0.1047
   3. worst radius                        0.0937
   4. mean concave points                 0.0835
   5. worst area                          0.0703
   6. mean perimeter                      0.0554
   7. mean radius                         0.0483
   8. worst concavity                     0.0445
   9. mean area                           0.0397
  10. mean concavity                      0.0336

from sklearn.inspection import permutation_importance

perm_result = permutation_importance(
    rf, X_test, y_test, n_repeats=10, random_state=42, n_jobs=-1
)

print("Permutation Importance 상위 5개:")
perm_sorted = np.argsort(perm_result.importances_mean)[::-1]
for i in range(5):
    idx = perm_sorted[i]
    mean = perm_result.importances_mean[idx]
    std = perm_result.importances_std[idx]
    print(f"  {feature_names[idx]:<35s} {mean:.4f} ± {std:.4f}")

Permutation Importance 상위 5개:
  worst concave points                 0.0614 ± 0.0089
  worst perimeter                      0.0526 ± 0.0072
  mean concave points                  0.0438 ± 0.0065
  worst radius                         0.0351 ± 0.0054
  worst area                           0.0289 ± 0.0048

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(
    n_estimators=100,        # 트리 수
    max_depth=None,          # 최대 깊이 (None = 완전 성장)
    max_features='sqrt',     # 노드별 고려 특성 수
    min_samples_leaf=1,      # 리프 노드 최소 샘플 수
    min_samples_split=2,     # 내부 노드 최소 샘플 수
    bootstrap=True,          # 부트스트랩 샘플링 여부
    oob_score=False,         # OOB 점수 계산 여부
    n_jobs=-1,               # 병렬 처리 (코어 수 -1)
    random_state=42
)

from sklearn.model_selection import RandomizedSearchCV
import numpy as np

param_dist = {
    'n_estimators': [100, 200, 300],
    'max_depth': [None, 10, 20, 30],
    'max_features': ['sqrt', 'log2', 0.5],
    'min_samples_leaf': [1, 2, 5, 10],
    'min_samples_split': [2, 5, 10],
}

rf_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42, n_jobs=-1),
    param_distributions=param_dist,
    n_iter=30,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    random_state=42
)
rf_search.fit(X_train, y_train)

print(f"최적 파라미터: {rf_search.best_params_}")
print(f"CV 최고 점수: {rf_search.best_score_:.4f}")
print(f"테스트 점수:  {rf_search.best_estimator_.score(X_test, y_test):.4f}")

최적 파라미터: {'n_estimators': 300, 'min_samples_split': 2,
                'min_samples_leaf': 1, 'max_features': 'sqrt', 'max_depth': 20}
CV 최고 점수: 0.9648
테스트 점수:  0.9649

# ❌ 트리 10개는 너무 불안정
rf_small = RandomForestClassifier(n_estimators=10, random_state=42)
rf_small.fit(X_train, y_train)
print(f"n=10 정확도: {rf_small.score(X_test, y_test):.4f}")  # 0.9298 (불안정)

# ✅ 최소 100개부터 시작, OOB로 수렴 확인
rf_good = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=42)
rf_good.fit(X_train, y_train)
print(f"n=100 정확도: {rf_good.score(X_test, y_test):.4f}")  # 0.9649 (안정적)
print(f"OOB 점수:    {rf_good.oob_score_:.4f}")

n=10 정확도: 0.9298 (불안정)
n=100 정확도: 0.9649 (안정적)
OOB 점수:    0.9560

# ❌ 랜덤 포레스트에 StandardScaler를 쓸 필요가 없다
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipe_wrong = Pipeline([
    ('scaler', StandardScaler()),  # 트리 기반 모델에는 불필요
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42))
])
pipe_wrong.fit(X_train, y_train)

# ✅ 랜덤 포레스트는 분기점만 찾으므로 스케일에 불변(invariant)
rf_no_scale = RandomForestClassifier(n_estimators=100, random_state=42)
rf_no_scale.fit(X_train, y_train)

print(f"스케일링 O: {pipe_wrong.score(X_test, y_test):.4f}")
print(f"스케일링 X: {rf_no_scale.score(X_test, y_test):.4f}")
# 결과가 동일하다

스케일링 O: 0.9649
스케일링 X: 0.9649

# ❌ 상관된 특성이 있을 때 Gini 중요도는 오도할 수 있다
# 예: 두 특성이 강하게 상관되면, 중요도가 두 특성에 나뉘어 각각이 낮아 보인다

from sklearn.inspection import permutation_importance

# ✅ 중요한 특성 선택 시 Permutation Importance를 함께 확인한다
perm = permutation_importance(rf, X_test, y_test, n_repeats=30, random_state=42)

# 두 방법의 순위가 크게 다르면 특성 간 상관성을 의심하자
print("Gini Top3:", [cancer.feature_names[i] for i in np.argsort(rf.feature_importances_)[-3:][::-1]])
print("Perm Top3:", [cancer.feature_names[i] for i in np.argsort(perm.importances_mean)[-3:][::-1]])

Gini Top3: ['worst concave points', 'worst perimeter', 'worst radius']
Perm Top3: ['worst concave points', 'worst perimeter', 'mean concave points']