Как избежать переобучения в деревьях решений?

Как избежать переобучения в деревьях решений

Переобучение (overfitting) в деревьях решений одна из самых актуальных проблем. Деревья имеют природную склонность к переобучению, потому что они могут разбивать данные вплоть до полного достижения чистоты классов в листьях. Есть несколько проверенных стратегий борьбы с этой проблемой.

Причины переобучения в деревьях

Дерево может разветвляться слишком глубоко, запоминая специфичные закономерности обучающих данных, которые не обобщаются на новые данные. Это особенно проблематично при:

• Отсутствии ограничений на глубину
• Наличии шума в данных
• Недостатке обучающих примеров

Стратегия 1: Ограничение гиперпараметров

Основной способ контролировать сложность дерева путём регуляризации параметров:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV, cross_val_score

# Плохо: неограниченное дерево
bad_model = DecisionTreeClassifier()
bad_model.fit(X_train, y_train)
# Обычно даёт переобучение!

# Хорошо: регуляризованное дерево
good_model = DecisionTreeClassifier(
    max_depth=10,                    # Максимальная глубина
    min_samples_split=20,            # Минимум примеров для разбиения
    min_samples_leaf=10,             # Минимум примеров в листе
    max_features=None,               # Количество признаков для разбиения
    min_impurity_decrease=0.01,      # Минимальное снижение примеси
    random_state=42
)
good_model.fit(X_train, y_train)

# Поиск оптимальных параметров
param_grid = {
    max_depth: [3, 5, 10, 15, 20, None],
    min_samples_split: [2, 5, 10, 20],
    min_samples_leaf: [1, 5, 10, 20]
}

grid_search = GridSearchCV(
    DecisionTreeClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring=roc_auc,
    n_jobs=-1
)

grid_search.fit(X_train, y_train)
print(f"Best parameters: {grid_search.best_params_}")
print(f"Best CV score: {grid_search.best_score_:.4f}")

Ключевые параметры регуляризации:

Стратегия 2: Кросс-валидация

Используй кросс-валидацию для выбора оптимальной глубины:

import numpy as np
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

# Проверяем разные глубины
depths = range(1, 21)
train_scores = []
val_scores = []

for depth in depths:
    model = DecisionTreeClassifier(
        max_depth=depth,
        min_samples_split=10,
        min_samples_leaf=5,
        random_state=42
    )
    
    # На обучающих данных
    train_score = model.fit(X_train, y_train).score(X_train, y_train)
    train_scores.append(train_score)
    
    # На валидационных данных (кросс-валидация)
    val_score = cross_val_score(
        model, X_train, y_train,
        cv=5,
        scoring=roc_auc
    ).mean()
    val_scores.append(val_score)

# Ищем точку, где валидационная ошибка минимальна
optimal_depth = depths[np.argmax(val_scores)]
print(f"Optimal depth: {optimal_depth}")

# График переобучения
plt.figure(figsize=(10, 6))
plt.plot(depths, train_scores, label=Training)
plt.plot(depths, val_scores, label=Validation)
plt.xlabel(Tree Depth)
plt.ylabel(ROC-AUC)
plt.legend()
plt.axvline(x=optimal_depth, color=r, linestyle=--)
plt.show()

Стратегия 3: Pruning (обрезание дерева)

Построь полное дерево, а потом обрезь его на валидационном наборе:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import validation_curve

# Сначала строим полное дерево (без ограничений)
full_tree = DecisionTreeClassifier(random_state=42)
full_tree.fit(X_train, y_train)

# Используем встроенный cost complexity pruning
path = full_tree.cost_complexity_pruning_path(
    X_train, y_train
)
ccp_alphas = path.ccp_alphas
imperities = path.impurities

# Тренируем деревья с разными ccp_alpha
clfs = []
for ccp_alpha in ccp_alphas:
    clf = DecisionTreeClassifier(
        random_state=42,
        ccp_alpha=ccp_alpha
    )
    clf.fit(X_train, y_train)
    clfs.append(clf)

# Выбираем дерево с лучшим валидационным скором
val_scores = []
for clf in clfs:
    val_score = clf.score(X_val, y_val)
    val_scores.append(val_score)

best_tree = clfs[np.argmax(val_scores)]
print(f"Best validation score: {max(val_scores):.4f}")

Стратегия 4: Ансамбли вместо одного дерева

Используй несколько деревьев вместе, это значительно снижает переобучение:

from sklearn.ensemble import (
    RandomForestClassifier,
    GradientBoostingClassifier,
    ExtraTreesClassifier
)

# Random Forest: множество независимых деревьев
rf_model = RandomForestClassifier(
    n_estimators=100,
    max_depth=10,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=42,
    n_jobs=-1
)
rf_model.fit(X_train, y_train)
rf_score = rf_model.score(X_test, y_test)
print(f"Random Forest score: {rf_score:.4f}")

# Gradient Boosting: последовательные деревья с корректировкой
gb_model = GradientBoostingClassifier(
    n_estimators=100,
    max_depth=5,
    learning_rate=0.1,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=42
)
gb_model.fit(X_train, y_train)
gb_score = gb_model.score(X_test, y_test)
print(f"Gradient Boosting score: {gb_score:.4f}")

# ExtraTrees: рандомизированные разбиения
et_model = ExtraTreesClassifier(
    n_estimators=100,
    max_depth=10,
    random_state=42,
    n_jobs=-1
)
et_model.fit(X_train, y_train)
et_score = et_model.score(X_test, y_test)
print(f"ExtraTrees score: {et_score:.4f}")

Стратегия 5: Ранняя остановка (Early Stopping)

Для Gradient Boosting можно останавливать обучение, когда валидационная ошибка начинает расти:

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split

X_train_split, X_val_split, y_train_split, y_val_split = train_test_split(
    X_train, y_train,
    test_size=0.2,
    random_state=42
)

# GradientBoosting с early stopping
gb_model = GradientBoostingClassifier(
    n_estimators=1000,
    max_depth=5,
    learning_rate=0.1,
    validation_fraction=0.2,
    n_iter_no_change=10,  # Остановка, если нет улучшения 10 итераций
    tol=1e-4,
    random_state=42
)

gb_model.fit(X_train_split, y_train_split)
print(f"Number of estimators used: {gb_model.n_estimators_}")

Практический чеклист

Для новой задачи с деревом решений:

1. Начни с ограниченного дерева:

   • max_depth = 10 (или меньше)
   • min_samples_split = 10
   • min_samples_leaf = 5

2. Проверь переобучение через кросс-валидацию:

   • Если train_score >> val_score = переобучение
   • Уменьши max_depth или увеличь min_samples_split

3. Используй Grid Search для оптимизации:

   • GridSearchCV с cv=5 и scoring=roc_auc

4. Рассмотри ансамбли:

   • Random Forest часто лучше одного дерева
   • Gradient Boosting, если нужна максимальная точность

5. Мониторь переобучение в production:

   • Сравнивай train и test метрики
   • Проверяй data drift

В большинстве практических задач правильная регуляризация параметров + кросс-валидация полностью решают проблему переобучения.