하이퍼파라미터 튜닝: Grid Search, Random Search, Bayesian Optimization

선형 회귀: 가중치 w, 편향 b
신경망:    각 층의 가중치 행렬 W, 편향 벡터 b
결정 트리: 각 노드의 분기 기준값

랜덤 포레스트: n_estimators, max_depth, max_features
XGBoost:      learning_rate, max_depth, n_estimators, reg_lambda
신경망:        학습률, 배치 크기, 은닉층 수, 은닉 노드 수

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# 시도 1
rf = RandomForestClassifier(n_estimators=100, max_depth=5)
print(cross_val_score(rf, X, y, cv=5).mean())  # 0.847

# 시도 2 — max_depth를 올려보자
rf = RandomForestClassifier(n_estimators=100, max_depth=10)
print(cross_val_score(rf, X, y, cv=5).mean())  # 0.862

# 시도 3 — n_estimators도 늘려볼까
rf = RandomForestClassifier(n_estimators=300, max_depth=10)
print(cross_val_score(rf, X, y, cv=5).mean())  # 0.871

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15, 20],
    'max_features': ['sqrt', 'log2']
}

grid_search = GridSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,          # 모든 CPU 코어 사용
    verbose=1
)

grid_search.fit(X_train, y_train)

print(f"최적 파라미터: {grid_search.best_params_}")
print(f"최적 CV 점수: {grid_search.best_score_:.4f}")

하이퍼파라미터 3개 × 후보 4개 =   64 조합
하이퍼파라미터 5개 × 후보 4개 = 1,024 조합
하이퍼파라미터 7개 × 후보 4개 = 16,384 조합
하이퍼파라미터 10개 × 후보 4개 = 1,048,576 조합

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

param_distributions = {
    'n_estimators': randint(100, 500),       # 100~499 균등 분포
    'max_depth': randint(3, 20),             # 3~19 균등 분포
    'max_features': ['sqrt', 'log2'],
    'min_samples_split': randint(2, 20),
    'min_samples_leaf': randint(1, 10)
}

random_search = RandomizedSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_distributions=param_distributions,
    n_iter=60,          # 60개 조합만 시도
    cv=5,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1
)

random_search.fit(X_train, y_train)

print(f"최적 파라미터: {random_search.best_params_}")
print(f"최적 CV 점수: {random_search.best_score_:.4f}")

Grid Search (9회 탐색):

  파라미터 B (덜 중요)
  │ ● ● ●
  │ ● ● ●
  │ ● ● ●
  └──────── 파라미터 A (중요)
  → 파라미터 A에 대해 3개 값만 탐색

Random Search (9회 탐색):

  파라미터 B (덜 중요)
  │   ●     ●
  │ ●    ●
  │    ●   ●
  │  ●       ●  ●
  └──────────── 파라미터 A (중요)
  → 파라미터 A에 대해 9개 값을 탐색

실제 목적 함수:   f(하이퍼파라미터) = CV 점수  ← 비용이 크다 (모델 학습 필요)
대리 모델:       ĝ(하이퍼파라미터) ≈ f       ← 비용이 작다 (예측만)

Exploitation (활용): 현재까지 좋았던 영역 근처를 집중 탐색
Exploration (탐색):  아직 시도하지 않은 미지의 영역 탐색

1. 초기 몇 개의 하이퍼파라미터 조합을 무작위로 평가
2. 결과로 대리 모델 학습
3. 획득 함수를 통해 다음 탐색 지점 선택
4. 해당 지점에서 실제 모델 학습 + 평가
5. 결과를 대리 모델에 추가하고 업데이트
6. 3~5 반복

import optuna
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

def objective(trial):
    """Optuna가 최적화할 목적 함수"""
    # 하이퍼파라미터 탐색 공간 정의
    n_estimators = trial.suggest_int('n_estimators', 100, 500)
    max_depth = trial.suggest_int('max_depth', 3, 20)
    max_features = trial.suggest_categorical('max_features', ['sqrt', 'log2'])
    min_samples_split = trial.suggest_int('min_samples_split', 2, 20)
    min_samples_leaf = trial.suggest_int('min_samples_leaf', 1, 10)

    rf = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        max_features=max_features,
        min_samples_split=min_samples_split,
        min_samples_leaf=min_samples_leaf,
        random_state=42
    )

    score = cross_val_score(rf, X_train, y_train, cv=5, scoring='accuracy')
    return score.mean()

# 스터디 생성 및 최적화 실행
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50)

print(f"최적 파라미터: {study.best_params}")
print(f"최적 CV 점수: {study.best_value:.4f}")

import optuna
import xgboost as xgb
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# 데이터 준비
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

def objective(trial):
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 100, 1000),
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'subsample': trial.suggest_float('subsample', 0.6, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.6, 1.0),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-3, 10.0, log=True),
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-3, 10.0, log=True),
        'min_child_weight': trial.suggest_int('min_child_weight', 1, 10),
    }

    model = xgb.XGBClassifier(
        **params,
        tree_method='hist',
        random_state=42,
        eval_metric='logloss'
    )

    scores = cross_val_score(
        model, X_train, y_train,
        cv=5, scoring='accuracy'
    )
    return scores.mean()

# Optuna 스터디 실행
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100, show_progress_bar=True)

# 결과 확인
print(f"\n최적 CV 점수: {study.best_value:.4f}")
print(f"최적 하이퍼파라미터:")
for key, value in study.best_params.items():
    print(f"  {key}: {value}")

# 최적 파라미터로 최종 모델 학습
best_model = xgb.XGBClassifier(
    **study.best_params,
    tree_method='hist',
    random_state=42,
    eval_metric='logloss'
)
best_model.fit(X_train, y_train)
test_score = best_model.score(X_test, y_test)
print(f"\n테스트 점수: {test_score:.4f}")

# 최적화 이력 시각화
optuna.visualization.plot_optimization_history(study)

# 하이퍼파라미터 중요도
optuna.visualization.plot_param_importances(study)

# 하이퍼파라미터 간 관계
optuna.visualization.plot_contour(study, params=['learning_rate', 'max_depth'])

from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingRandomSearchCV
from scipy.stats import randint, uniform

param_distributions = {
    'n_estimators': randint(100, 500),
    'max_depth': randint(3, 20),
    'max_features': ['sqrt', 'log2'],
    'min_samples_split': randint(2, 20),
}

halving_search = HalvingRandomSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_distributions=param_distributions,
    n_candidates=100,     # 초기 후보 100개
    factor=3,             # 매 라운드 1/3만 생존
    resource='n_samples', # 리소스 = 데이터 샘플 수
    cv=5,
    random_state=42,
    n_jobs=-1
)

halving_search.fit(X_train, y_train)

라운드 1: 100개 후보 × 소량 데이터 → 상위 33개 생존
라운드 2:  33개 후보 × 3배 데이터 → 상위 11개 생존
라운드 3:  11개 후보 × 9배 데이터 → 상위  4개 생존
라운드 4:   4개 후보 × 전체 데이터 → 최종 1개 선택

외부 CV (평가용) — 5-Fold
├── Fold 1: Train(2,3,4,5) / Test(1)
│   └── 내부 CV (튜닝용) — 3-Fold
│       └── GridSearchCV로 최적 하이퍼파라미터 탐색
│       └── 최적 파라미터로 Train(2,3,4,5) 전체 학습 → Test(1) 평가
├── Fold 2: Train(1,3,4,5) / Test(2)
│   └── 내부 CV (튜닝용) — 3-Fold
│       └── ...
└── ...

→ 외부 5개 Fold의 테스트 점수 평균 = 편향 없는 최종 성능

from sklearn.model_selection import cross_val_score, GridSearchCV

# 내부 CV: 하이퍼파라미터 튜닝
inner_cv = GridSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_grid={
        'n_estimators': [100, 200, 300],
        'max_depth': [5, 10, 15]
    },
    cv=3,
    scoring='accuracy',
    n_jobs=-1
)

# 외부 CV: 편향 없는 성능 평가
outer_scores = cross_val_score(
    inner_cv,       # GridSearchCV 객체를 그대로 넣는다
    X, y,
    cv=5,
    scoring='accuracy'
)

print(f"Nested CV 점수: {outer_scores.mean():.4f} ± {outer_scores.std():.4f}")

# 1단계: 넓은 범위 탐색
param_dist_coarse = {
    'learning_rate': [0.001, 0.01, 0.1, 0.3],
    'max_depth': [3, 5, 7, 10, 15],
    'n_estimators': [100, 300, 500, 1000],
}
# → 결과: learning_rate=0.1, max_depth=5 근처가 좋다

# 2단계: 유망 영역 정밀 탐색
param_dist_fine = {
    'learning_rate': uniform(0.05, 0.2),       # 0.05~0.25
    'max_depth': randint(4, 8),                 # 4~7
    'n_estimators': randint(200, 600),           # 200~599
}

# 나쁜 예: 선형 균등 분포
trial.suggest_float('lr', 0.001, 1.0)
# → 0.5~1.0 구간에서 50% 샘플링

# 좋은 예: 로그 균등 분포
trial.suggest_float('lr', 0.001, 1.0, log=True)
# → 0.001~0.01, 0.01~0.1, 0.1~1.0 각 구간에서 ~33% 샘플링

XGBoost 튜닝 순서 (권장):
1. learning_rate, n_estimators  ← 가장 큰 영향
2. max_depth, min_child_weight  ← 트리 복잡도
3. subsample, colsample_bytree  ← 샘플링
4. reg_lambda, reg_alpha        ← 규제

def objective(trial):
    params = {
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'n_estimators': 1000,  # 충분히 크게
        # ...
    }

    model = xgb.XGBClassifier(**params, early_stopping_rounds=50)
    model.fit(
        X_train, y_train,
        eval_set=[(X_val, y_val)],
        verbose=False
    )
    return model.best_score  # early stopping 시점의 점수

sampler = optuna.samplers.TPESampler(seed=42)
study = optuna.create_study(direction='maximize', sampler=sampler)

1. 수동 튜닝으로 합리적인 탐색 범위 설정
2. Random Search로 넓은 영역 탐색 (coarse)
3. Optuna로 유망 영역 정밀 탐색 (fine)
4. Nested CV로 최종 성능 보고