Как детектировать переобучение неитеративного алгоритма?

Как детектировать переобучение неитеративного алгоритма

Переобучение (overfitting) в неитеративных алгоритмах (Decision Trees, SVM, Random Forest, KNN) сложнее обнаружить, чем в нейронных сетях, где можно смотреть на график loss. Однако существуют эффективные методы диагностики.

Основной подход: Cross-Validation

from sklearn.model_selection import cross_val_score, cross_validate
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score
import numpy as np

# Модель
model = RandomForestClassifier(n_estimators=100, random_state=42)

# 5-fold Cross-Validation
scores = cross_val_score(
    model, X_train, y_train,
    cv=5,
    scoring='accuracy'
)

print(f"CV scores: {scores}")
print(f"Mean: {scores.mean():.3f}")
print(f"Std: {scores.std():.3f}")

# Если std высокой (> 0.05), возможно переобучение
# Если высокая дисперсия между folds - проблема с обобщением

Диагностика через Train vs Test сплит

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score

# Разделение данных
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Обучение
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Оценка
train_score = accuracy_score(y_train, model.predict(X_train))
test_score = accuracy_score(y_test, model.predict(X_test))

print(f"Train Accuracy: {train_score:.4f}")
print(f"Test Accuracy: {test_score:.4f}")
print(f"Gap (overfitting indicator): {train_score - test_score:.4f}")

# Если gap > 0.05-0.10, вероятно переобучение

Множественные метрики

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, roc_auc_score, confusion_matrix
)

def evaluate_model(model, X_train, X_test, y_train, y_test):
    """
    Полная диагностика переобучения
    """
    y_train_pred = model.predict(X_train)
    y_test_pred = model.predict(X_test)
    
    metrics = {}
    
    # Accuracy
    metrics['train_accuracy'] = accuracy_score(y_train, y_train_pred)
    metrics['test_accuracy'] = accuracy_score(y_test, y_test_pred)
    
    # Precision
    metrics['train_precision'] = precision_score(y_train, y_train_pred, average='weighted')
    metrics['test_precision'] = precision_score(y_test, y_test_pred, average='weighted')
    
    # Recall
    metrics['train_recall'] = recall_score(y_train, y_train_pred, average='weighted')
    metrics['test_recall'] = recall_score(y_test, y_test_pred, average='weighted')
    
    # F1
    metrics['train_f1'] = f1_score(y_train, y_train_pred, average='weighted')
    metrics['test_f1'] = f1_score(y_test, y_test_pred, average='weighted')
    
    # Gaps (индикаторы переобучения)
    metrics['accuracy_gap'] = metrics['train_accuracy'] - metrics['test_accuracy']
    metrics['precision_gap'] = metrics['train_precision'] - metrics['test_precision']
    metrics['f1_gap'] = metrics['train_f1'] - metrics['test_f1']
    
    return metrics

metrics = evaluate_model(model, X_train, X_test, y_train, y_test)

import pandas as pd
df = pd.DataFrame([metrics]).T
print(df)

# Пороги переобучения:
# accuracy_gap > 0.10 → явное переобучение
# accuracy_gap > 0.05 → возможное переобучение
# accuracy_gap < 0.03 → хорошая обобщающая способность

Learning Curve анализ

from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

def plot_learning_curve(model, X, y, cv=5):
    """
    Визуализирует переобучение через learning curves
    """
    train_sizes, train_scores, val_scores = learning_curve(
        model, X, y,
        cv=cv,
        train_sizes=np.linspace(0.1, 1.0, 10),
        scoring='accuracy',
        n_jobs=-1
    )
    
    # Усреднение
    train_mean = train_scores.mean(axis=1)
    train_std = train_scores.std(axis=1)
    val_mean = val_scores.mean(axis=1)
    val_std = val_scores.std(axis=1)
    
    # Визуализация
    plt.figure(figsize=(10, 6))
    plt.plot(train_sizes, train_mean, 'o-', label='Training score')
    plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.1)
    plt.plot(train_sizes, val_mean, 'o-', label='Validation score')
    plt.fill_between(train_sizes, val_mean - val_std, val_mean + val_std, alpha=0.1)
    plt.xlabel('Training Set Size')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.grid()
    plt.show()
    
    # Интерпретация:
    # Если кривые близко друг к другу → хорошая обобщающая способность
    # Если большой gap → переобучение
    # Если обе низкие → недостаточное обучение (bias)

plot_learning_curve(model, X, y)

Анализ Feature Importance

def detect_overfitting_by_importance(model, feature_names):
    """
    Переобучение часто видно в отдельных очень важных признаках
    """
    importances = model.feature_importances_
    indices = np.argsort(importances)[::-1]
    
    # Если 2-3 признака дают > 80% важности, возможна проблема
    top_3_importance = sum(importances[indices[:3]])
    
    print(f"Top 3 features importance: {top_3_importance:.3f}")
    
    if top_3_importance > 0.8:
        print("⚠️  Внимание: модель слишком зависит от нескольких признаков")
        print("Это может указывать на переобучение")
    
    return importances[indices]

importances = detect_overfitting_by_importance(model, X.columns)

Пермутационная важность признаков

from sklearn.inspection import permutation_importance

# Пермутационная важность на тестовом наборе
perm_importance = permutation_importance(
    model, X_test, y_test,
    n_repeats=10,
    random_state=42
)

# Если важности сильно отличаются на train и test,
# это указывает на переобучение
print(f"Mean importance: {perm_importance.importances_mean}")
print(f"Std importance: {perm_importance.importances_std}")

# Высокая std указывает на нестабильность

Confusion Matrix анализ

from sklearn.metrics import confusion_matrix
import seaborn as sns

def compare_confusion_matrices(model, X_train, X_test, y_train, y_test):
    """
    Сравнение матриц ошибок на train и test
    """
    y_train_pred = model.predict(X_train)
    y_test_pred = model.predict(X_test)
    
    cm_train = confusion_matrix(y_train, y_train_pred)
    cm_test = confusion_matrix(y_test, y_test_pred)
    
    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
    
    sns.heatmap(cm_train, annot=True, ax=axes[0], cmap='Blues')
    axes[0].set_title('Train Confusion Matrix')
    
    sns.heatmap(cm_test, annot=True, ax=axes[1], cmap='Blues')
    axes[1].set_title('Test Confusion Matrix')
    
    plt.show()
    
    # Если в train почти нет ошибок, а в test много → переобучение

compare_confusion_matrices(model, X_train, X_test, y_train, y_test)

Практическая диагностическая схема

def diagnose_overfitting(model, X_train, X_test, y_train, y_test):
    """
    Полная диагностика переобучения
    """
    results = {}
    
    # 1. Train vs Test gap
    train_acc = model.score(X_train, y_train)
    test_acc = model.score(X_test, y_test)
    gap = train_acc - test_acc
    results['train_acc'] = train_acc
    results['test_acc'] = test_acc
    results['gap'] = gap
    
    # 2. Cross-validation std
    from sklearn.model_selection import cross_val_score
    cv_scores = cross_val_score(model, X_train, y_train, cv=5)
    results['cv_std'] = cv_scores.std()
    
    # 3. Feature importance concentration
    if hasattr(model, 'feature_importances_'):
        top_3_sum = sorted(model.feature_importances_, reverse=True)[:3]
        results['top_3_importance'] = sum(top_3_sum)
    
    # Диагностика
    print("=== OVERFITTING DIAGNOSIS ===")
    print(f"Train Accuracy: {results['train_acc']:.4f}")
    print(f"Test Accuracy: {results['test_acc']:.4f}")
    print(f"Gap: {results['gap']:.4f}")
    
    if results['gap'] > 0.10:
        print("⚠️  STRONG OVERFITTING DETECTED")
    elif results['gap'] > 0.05:
        print("⚠️  MODERATE OVERFITTING DETECTED")
    else:
        print("✅ Good generalization")
    
    return results

diagnose_overfitting(model, X_train, X_test, y_train, y_test)

Итоги

Детектирование переобучения в неитеративных алгоритмах:

1. Train vs Test gap (основной индикатор)
2. Cross-Validation (стабильность между folds)
3. Learning curves (визуальная диагностика)
4. Feature importance (зависимость от нескольких признаков)
5. Множественные метрики (precision, recall, F1)
6. Confusion matrices (сравнение ошибок)

Нормальные значения:

• Gap < 0.03: отличная обобщающая способность
• Gap 0.03-0.05: хорошая обобщающая способность
• Gap 0.05-0.10: возможное переобучение
• Gap > 0.10: явное переобучение