Как улучшить стабильность модели?

Стабильность модели: комплексный подход

Стабильность (stability) — это способность модели давать консистентные результаты на разных данных и через времени. Это критически важно для production-систем.

1. Проблемы нестабильности

Стабильность может пострадать по нескольким причинам:

1. HIGH VARIANCE: модель переучилась на обучающих данных
2. DATA DRIFT: распределение данных изменилось
3. OVERFITTING: модель запомнила "шум" вместо паттернов
4. SMALL TRAINING SET: мало данных для обобщений
5. EXTREME VALUES: выбросы дестабилизируют модель
6. FEATURE INSTABILITY: источники признаков нестабильны

2. Регуляризация

Уменьшаю complexity модели, чтобы она не переучилась:

from sklearn.linear_model import Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor
import xgboost as xgb

# L1 и L2 регуляризация
model_l2 = Ridge(alpha=1.0)  # штрафует большие веса
model_l1 = Lasso(alpha=0.1)  # обнуляет неважные веса

# Random Forest с ограничениями
rf = RandomForestRegressor(
    max_depth=10,          # ограничиваю глубину
    min_samples_leaf=5,    # минимум примеров в листе
    min_samples_split=10,  # минимум для split
    max_features='sqrt'    # не все признаки в каждом split
)

# XGBoost с регуляризацией
xgb_model = xgb.XGBRegressor(
    reg_alpha=0.01,        # L1
    reg_lambda=0.1,        # L2
    max_depth=5,
    learning_rate=0.05,
    subsample=0.8,         # используй 80% примеров в каждой итерации
    colsample_bytree=0.8   # используй 80% признаков в каждой итерации
)

3. Cross-Validation для оценки стабильности

Проверяю, как модель работает на разных фолдах:

from sklearn.model_selection import cross_val_score, cross_validate
import numpy as np

# K-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='r2')
print(f"Fold scores: {scores}")
print(f"Mean: {scores.mean():.4f}, Std: {scores.std():.4f}")

# Стабильная модель должна иметь НИЗКОЕ std
if scores.std() < 0.05:
    print("Модель стабильна")
else:
    print("Модель нестабильна, нужна регуляризация")

# Подробнее
results = cross_validate(
    model, X, y, cv=5,
    scoring=['r2', 'mae'],
    return_train_score=True
)

# Проверяю разницу train vs test
train_r2 = results['train_r2'].mean()
test_r2 = results['test_r2'].mean()

if train_r2 - test_r2 > 0.1:
    print("Признак переобучения!")

4. Handling выбросов и экстремальных значений

Выбросы дестабилизируют деревья и линейные модели:

import numpy as np
from scipy import stats

# Метод IQR (Inter-Quartile Range)
Q1 = X.quantile(0.25)
Q3 = X.quantile(0.75)
IQR = Q3 - Q1

lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# Удаляю или capped
X_clean = X[(X >= lower_bound) & (X <= upper_bound)]

# Или winsorize (capping)
from scipy.stats.mstats import winsorize
X_winsorized = winsorize(X, limits=0.05)  # обрезаю top 5% и bottom 5%

# Z-score метод
z_scores = np.abs(stats.zscore(X))
X_clean = X[z_scores < 3]  # оставляю если |z| < 3

5. Feature engineering для стабильности

# 1. Нормализация/Масштабирование
from sklearn.preprocessing import StandardScaler, RobustScaler

# StandardScaler чувствителен к выбросам
scaler_std = StandardScaler()

# RobustScaler устойчив к выбросам (использует median и IQR)
scaler_robust = RobustScaler()
X_scaled = scaler_robust.fit_transform(X)

# 2. Трансформации для стабилизации дисперсии
from sklearn.preprocessing import PowerTransformer

# Yeo-Johnson трансформация
pt = PowerTransformer(method='yeo-johnson')
X_transformed = pt.fit_transform(X)

# 3. Создание стабильных признаков
# Вместо "Price" использую "Log(Price)"
X['log_price'] = np.log1p(X['price'])  # log1p для защиты от log(0)

# 4. Бинирование для категоризации
X['price_bin'] = pd.cut(X['price'], bins=[0, 100, 500, 1000, np.inf],
                        labels=['cheap', 'mid', 'expensive', 'premium'])

6. Ensemble методы для стабильности

Ансамбли стабильнее отдельных моделей:

from sklearn.ensemble import BaggingRegressor, AdaBoostRegressor, VotingRegressor

# Bagging: обучай разные модели на разных подвыборках
bagging = BaggingRegressor(
    base_estimator=DecisionTreeRegressor(max_depth=10),
    n_estimators=100,
    bootstrap=True,
    random_state=42
)

# Voting ensemble: усредняй предсказания
voting = VotingRegressor([
    ('rf', RandomForestRegressor()),
    ('xgb', xgb.XGBRegressor()),
    ('ridge', Ridge())
])

7. Мониторинг стабильности в production

import numpy as np
from datetime import datetime

# Отслеживаю характеристики данных со временем
def monitor_data_stability(X_new, X_train_statistics):
    """
    Сравниваю распределение новых данных с обучающими
    """
    alerts = []
    
    for feature in X_new.columns:
        train_mean = X_train_statistics[feature]['mean']
        train_std = X_train_statistics[feature]['std']
        
        new_mean = X_new[feature].mean()
        new_std = X_new[feature].std()
        
        # Проверяю дрейф средного значения (mean drift)
        if abs(new_mean - train_mean) > 2 * train_std:
            alerts.append(f"DRIFT в {feature}: mean {new_mean:.2f} vs {train_mean:.2f}")
        
        # Проверяю изменение дисперсии
        if new_std / train_std > 1.5 or new_std / train_std < 0.67:
            alerts.append(f"VARIANCE CHANGE в {feature}")
    
    return alerts

# Также отслеживаю метрики модели
def monitor_model_stability(predictions, actuals, thresholds):
    """
    Проверяю деградацию метрик модели
    """
    current_r2 = r2_score(actuals, predictions)
    baseline_r2 = thresholds['baseline_r2']
    
    if current_r2 < baseline_r2 * 0.95:  # падение на 5%
        print("WARNING: Model performance degradation!")
        print(f"Expected R2: {baseline_r2:.4f}, Current: {current_r2:.4f}")
        return False
    return True

8. Стратегия переобучения модели

# Переобучай модель регулярно, но осторожно

def should_retrain(model, X_recent, y_recent, threshold=0.95):
    """
    Проверяю нужно ли переобучать
    """
    recent_score = model.score(X_recent, y_recent)
    baseline_score = model.baseline_score
    
    if recent_score < baseline_score * threshold:
        return True
    return False

# Переобучаю с расписанием
import schedule

def weekly_retrain():
    # Обучаю на последних 30 дней данных
    X_recent, y_recent = load_recent_data(days=30)
    
    # Проверяю качество перед заменой
    new_model = train_model(X_recent, y_recent)
    new_score = evaluate_model(new_model, X_val, y_val)
    old_score = evaluate_model(current_model, X_val, y_val)
    
    if new_score >= old_score * 0.98:  # может быть немного хуже
        deploy_model(new_model)
        print("Model updated successfully")
    else:
        print("Model performance degradation, rollback")

schedule.every().week.do(weekly_retrain)

Чеклист стабильности

• Cross-validation показывает низкую дисперсию между фолдами
• Нет большой разницы между train и test metrics
• Обработаны выбросы
• Данные нормализованы/масштабированы
• Гиперпараметры подобраны через GridSearch/RandomSearch
• Используются ensemble методы
• Настроена система мониторинга дрейфа данных
• У нас есть процедура переобучения
• Результаты воспроизводимы (зафиксирован random_state)