Как настроить валидацию при использовании стекинга и блендинга?

Как настроить валидацию при использовании стекинга и блендинга?

Введение в стекинг и блендинг

Блендинг (Blending) — это простой метод ансамбля, где предсказания базовых моделей усредняются или взвешиваются для получения финального результата.

Стекинг (Stacking) — это более сложный метод, где предсказания базовых моделей используются как признаки для обучения мета-модели (meta-learner).

Оба метода требуют особой осторожности при валидации, чтобы избежать утечки данных (data leakage) и переобучения на тренировочном наборе.

Проблемы при неправильной валидации

# НЕПРАВИЛЬНО - приводит к утечке данных
model1 = RandomForest()
model2 = GradientBoosting()
model1.fit(X_train, y_train)
model2.fit(X_train, y_train)

# Делаем предсказания на тренировочном наборе (УТЕЧКА!)
meta_features_train = np.hstack([
    model1.predict(X_train),  # Модель видела эти данные
    model2.predict(X_train)
])

# Обучаем мета-модель на этих же данных - это не надёжно
meta_model = LogisticRegression()
meta_model.fit(meta_features_train, y_train)

1. Валидация для Блендинга

Простой подход с холдаутом:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression

# Разделяем данные: 60% train, 20% blend, 20% test
X_train, X_temp, y_train, y_temp = train_test_split(
    X, y, test_size=0.4, random_state=42
)
X_blend, X_test, y_blend, y_test = train_test_split(
    X_temp, y_temp, test_size=0.5, random_state=42
)

# Обучаем базовые модели на тренировочном наборе
model1 = RandomForestClassifier(n_estimators=100, random_state=42)
model2 = GradientBoostingClassifier(n_estimators=100, random_state=42)

model1.fit(X_train, y_train)
model2.fit(X_train, y_train)

# Делаем предсказания на БЛЕНДОВОМ наборе (не видела модели)
blend_preds1 = model1.predict_proba(X_blend)[:, 1]
blend_preds2 = model2.predict_proba(X_blend)[:, 1]

# Объединяем предсказания в метапризнаки
meta_features_blend = np.column_stack([blend_preds1, blend_preds2])

# Простое взвешивание (веса найдены эмпирически)
weights = np.array([0.6, 0.4])
final_blend_pred = np.average(meta_features_blend, axis=1, weights=weights)

# Оценка на тестовом наборе
test_preds1 = model1.predict_proba(X_test)[:, 1]
test_preds2 = model2.predict_proba(X_test)[:, 1]
meta_features_test = np.column_stack([test_preds1, test_preds2])
final_test_pred = np.average(meta_features_test, axis=1, weights=weights)

accuracy = accuracy_score(y_test, final_test_pred > 0.5)
print(f'Test Accuracy: {accuracy:.4f}')

2. Валидация для Стекинга

Правильная валидация с k-fold cross-validation:

Это предотвращает утечку данных и обеспечивает надёжные метапризнаки:

from sklearn.model_selection import KFold
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
import numpy as np

def stacking_with_kfold(X, y, base_models, meta_model, n_splits=5):
    """
    Стекинг с k-fold кросс-валидацией
    
    Args:
        X: Признаки
        y: Целевая переменная
        base_models: Список базовых моделей
        meta_model: Мета-модель
        n_splits: Количество фолдов
    """
    
    kfold = KFold(n_splits=n_splits, shuffle=True, random_state=42)
    
    # Создаём массивы для метапризнаков
    meta_train = np.zeros((X.shape[0], len(base_models)))
    meta_test = np.zeros((X.shape[0], len(base_models)))
    
    # Для каждой базовой модели
    for model_idx, base_model in enumerate(base_models):
        meta_test_fold = np.zeros((X.shape[0], n_splits))
        
        # k-fold кросс-валидация
        for fold_idx, (train_idx, val_idx) in enumerate(kfold.split(X)):
            X_train_fold = X[train_idx]
            y_train_fold = y[train_idx]
            X_val_fold = X[val_idx]
            
            # Обучаем модель на тренировочной части фолда
            model_clone = clone(base_model)
            model_clone.fit(X_train_fold, y_train_fold)
            
            # Предсказываем на валидационной части
            meta_train[val_idx, model_idx] = model_clone.predict_proba(
                X_val_fold
            )[:, 1]
            
            # Предсказываем на всём датасете для тестирования
            meta_test_fold[:, fold_idx] = model_clone.predict_proba(X)[:, 1]
        
        # Усредняем предсказания мета-модели
        meta_test[:, model_idx] = meta_test_fold.mean(axis=1)
    
    return meta_train, meta_test

# Использование
from sklearn.base import clone
from sklearn.metrics import accuracy_score

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

# Базовые модели
base_models = [
    RandomForestClassifier(n_estimators=100, random_state=42),
    GradientBoostingClassifier(n_estimators=100, random_state=42),
    SVC(kernel='rbf', probability=True, random_state=42)
]

# Метаамодель
meta_model = LogisticRegression(random_state=42)

# Получаем метапризнаки
meta_train, meta_test = stacking_with_kfold(
    X_train, y_train, base_models, meta_model, n_splits=5
)

# Обучаем мета-модель
meta_model.fit(meta_train, y_train)

# Оценка на тестовом наборе
final_pred = meta_model.predict(meta_test)
accuracy = accuracy_score(y_test, final_pred)
print(f'Test Accuracy: {accuracy:.4f}')

3. Практический пример: Стекинг со сложной валидацией

def advanced_stacking(X, y, base_models, meta_model, 
                      train_size=0.6, val_size=0.2, test_size=0.2):
    """
    Расширенный стекинг с разделением на train/val/test
    """
    # 1. Разделяем на три части
    X_tr, X_temp, y_tr, y_temp = train_test_split(
        X, y, test_size=val_size + test_size, random_state=42
    )
    X_val, X_test, y_val, y_test = train_test_split(
        X_temp, y_temp, test_size=test_size / (val_size + test_size), 
        random_state=42
    )
    
    # 2. Обучаем базовые модели на train, делаем предсказания на val
    meta_val = np.zeros((X_val.shape[0], len(base_models)))
    meta_test = np.zeros((X_test.shape[0], len(base_models)))
    
    for idx, base_model in enumerate(base_models):
        model = clone(base_model)
        model.fit(X_tr, y_tr)
        
        meta_val[:, idx] = model.predict_proba(X_val)[:, 1]
        meta_test[:, idx] = model.predict_proba(X_test)[:, 1]
    
    # 3. Обучаем мета-модель на валидационных метапризнаках
    meta_model.fit(meta_val, y_val)
    
    # 4. Оцениваем на тестовом наборе
    final_pred = meta_model.predict(meta_test)
    accuracy = accuracy_score(y_test, final_pred)
    
    return meta_model, accuracy

4. Ключевые принципы валидации

Главное правило: No Data Leakage

5. Проверка переобучения

from sklearn.metrics import cross_val_score

# Валидационная кривая для мета-модели
train_scores = []
val_scores = []

for train_idx, val_idx in kfold.split(meta_train):
    X_tr = meta_train[train_idx]
    y_tr = y[train_idx]
    X_val = meta_train[val_idx]
    y_val = y[val_idx]
    
    meta_model.fit(X_tr, y_tr)
    train_scores.append(meta_model.score(X_tr, y_tr))
    val_scores.append(meta_model.score(X_val, y_val))

print(f'Train: {np.mean(train_scores):.4f}')
print(f'Val: {np.mean(val_scores):.4f}')

# Если val намного хуже train — переобучение

Заключение

• Блендинг: проще, но использует меньше данных. Разделяйте на train/blend/test
• Стекинг: сложнее, но эффективнее. Используйте k-fold для полного использования данных
• Никогда не делайте предсказания базовых моделей на том же наборе, где они обучались
• Всегда проверяйте переобучение на отдельном тестовом наборе