Как боролся с мультиколлинеарностью\?

Борьба с мультиколлинеарностью: Практические подходы

Мультиколлинеарность — это ситуация, когда в модели присутствует высокая корреляция между независимыми переменными. Это ухудшает интерпретируемость моделей и может привести к нестабильным коэффициентам регрессии. Я использовал множество методов для её решения.

Шаг 1: Диагностика мультиколлинеарности

1.1 Матрица корреляций

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Загрузить данные
df = pd.read_csv("data.csv")

# Вычислить корреляционную матрицу
corr_matrix = df.corr()

# Визуализация
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr_matrix,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    vmin=-1, vmax=1,
    square=True
)
plt.title("Матрица корреляций")
plt.tight_layout()
plt.show()

# Найти коррелирующие пары
for i in range(len(corr_matrix.columns)):
    for j in range(i+1, len(corr_matrix.columns)):
        if abs(corr_matrix.iloc[i, j]) > 0.8:  # Высокая корреляция
            print(
                f"{corr_matrix.columns[i]} <-> "
                f"{corr_matrix.columns[j]}: "
                f"{corr_matrix.iloc[i, j]:.3f}"
            )

1.2 Variance Inflation Factor (VIF)

ВIF показывает, во сколько раз дисперсия коэффициента увеличивается из-за мультиколлинеарности:

from statsmodels.stats.outliers_influence import variance_inflation_factor
from statsmodels.tools.tools import add_constant

# Добавить константу для VIF
X = df[feature_columns]
X = add_constant(X)

# Вычислить VIF для каждого признака
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]

print(vif_data.sort_values("VIF", ascending=False))

# Интерпретация:
# VIF = 1: Нет корреляции
# VIF < 5: Приемлемо
# VIF > 10: Серьёзная мультиколлинеарность (нужно действовать)

1.3 Число обусловленности (Condition Number)

# Число обусловленности матрицы признаков
cond_number = np.linalg.cond(X)
print(f"Condition Number: {cond_number:.2f}")

# Интерпретация:
# < 30: Хорошо
# 30-100: Умеренная мультиколлинеарность
# > 100: Серьёзная мультиколлинеарность

Шаг 2: Методы борьбы с мультиколлинеарностью

Метод 1: Удаление коррелирующих признаков

Простой и часто эффективный подход — удалить один из двух сильно коррелирующих признаков:

def remove_correlated_features(df, threshold=0.8):
    """
    Удалить один признак из каждой пары с корреляцией > threshold
    """
    corr_matrix = df.corr().abs()
    
    # Создать верхнюю треугольную матрицу
    upper = corr_matrix.where(
        np.triu(np.ones(corr_matrix.shape), k=1).astype(bool)
    )
    
    # Найти признаки для удаления
    to_drop = [col for col in upper.columns if any(upper[col] > threshold)]
    
    print(f"Удаляю признаки: {to_drop}")
    return df.drop(columns=to_drop)

# Применить
df_reduced = remove_correlated_features(df, threshold=0.8)
print(f"Осталось {len(df_reduced.columns)} признаков")

Плюсы:

• Простая реализация
• Модель остаётся интерпретируемой
• Может улучшить обобщение

Минусы:

• Теряем информацию
• Может снизить точность модели

Метод 2: Principal Component Analysis (PCA)

Преобразовать коррелирующие признаки в некоррелирующие главные компоненты:

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression

# Стандартизация (ВАЖНО для PCA!)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# PCA
pca = PCA(n_components=0.95)  # Сохранить 95% дисперсии
X_pca = pca.fit_transform(X_scaled)

print(f"Исходно признаков: {X.shape[1]}")
print(f"После PCA: {X_pca.shape[1]}")
print(f"Объясняемая дисперсия: {pca.explained_variance_ratio_.sum():.3f}")

# Обучить модель на PCA-признаках
model = LinearRegression()
model.fit(X_pca, y)

# Прогноз
y_pred = model.predict(pca.transform(X_test_scaled))

Плюсы:

• Эффективно избавляет от мультиколлинеарности
• Уменьшает размерность данных
• Может улучшить обобщение

Минусы:

• Компоненты PCA сложнее интерпретировать
• Требует стандартизации

Метод 3: Ridge Regression (L2 регуляризация)

Добавляет штраф на размер коэффициентов:

from sklearn.linear_model import Ridge, RidgeCV

# Выбрать alpha через кросс-валидацию
alphas = np.logspace(-4, 4, 100)
ridge_cv = RidgeCV(alphas=alphas, cv=5)
ridge_cv.fit(X_scaled, y)

print(f"Оптимальная alpha: {ridge_cv.alpha_:.4f}")

# Обучить модель
ridge = Ridge(alpha=ridge_cv.alpha_)
ridge.fit(X_scaled, y)

# Коэффициенты будут меньше и стабильнее
print(f"Коэффициенты Ridge:\n{ridge.coef_}")
print(f"Сумма квадратов коэффициентов: {(ridge.coef_**2).sum():.4f}")

Как работает:

Loss = MSE(y, y_pred) + alpha * sum(coef²)

Ridge штрафует большие коэффициенты, заставляя их уменьшаться.

Плюсы:

• Просто реализовать
• Хорошая интерпретируемость
• Обычно улучшает обобщение

Минусы:

• Не удаляет признаки (все имеют ненулевой вес)
• Не объясняет связи между признаками

Метод 4: Lasso Regression (L1 регуляризация)

Может полностью обнулить коэффициенты слабых признаков:

from sklearn.linear_model import Lasso, LassoCV

# Выбрать alpha через кросс-валидацию
lasso_cv = LassoCV(cv=5, random_state=42)
lasso_cv.fit(X_scaled, y)

print(f"Оптимальная alpha: {lasso_cv.alpha_:.4f}")

# Обучить модель
lasso = Lasso(alpha=lasso_cv.alpha_)
lasso.fit(X_scaled, y)

# Количество ненулевых коэффициентов
n_features = np.sum(lasso.coef_ != 0)
print(f"Выбрано признаков: {n_features} из {len(X_scaled[0])}")
print(f"\nОбнулённые признаки:")
for i, coef in enumerate(lasso.coef_):
    if coef == 0:
        print(f"  {X.columns[i]}")

Как работает:

Loss = MSE(y, y_pred) + alpha * sum(|coef|)

Lasso может обнулить коэффициенты, выполняя отбор признаков.

Плюсы:

• Отбирает самые важные признаки
• Интерпретируемо
• Может улучшить производительность

Минусы:

• Когда много коррелирующих признаков, выбирает произвольно один
• Менее стабилен при высокой мультиколлинеарности

Метод 5: Elastic Net

Комбинация Ridge и Lasso:

from sklearn.linear_model import ElasticNetCV

elastic_cv = ElasticNetCV(
    alphas=np.logspace(-4, 4, 100),
    l1_ratio=[0.1, 0.3, 0.5, 0.7, 0.9],  # Balance между L1 и L2
    cv=5,
    random_state=42
)
elastic_cv.fit(X_scaled, y)

print(f"Оптимальная alpha: {elastic_cv.alpha_:.4f}")
print(f"Оптимальный l1_ratio: {elastic_cv.l1_ratio_:.2f}")

elastic = ElasticNetCV(alpha=elastic_cv.alpha_, l1_ratio=elastic_cv.l1_ratio_)
elastic.fit(X_scaled, y)

Формула:

Loss = MSE + alpha * (l1_ratio * sum(|coef|) + (1 - l1_ratio) * sum(coef²))

Плюсы:

• Комбинирует лучшие свойства Ridge и Lasso
• Работает лучше при высокой мультиколлинеарности

Метод 6: Partial Least Squares (PLS)

Похожа на PCA, но учитывает целевую переменную:

from sklearn.cross_decomposition import PLSRegression
from sklearn.model_selection import cross_val_score

# Выбрать количество компонент через кросс-валидацию
best_n = 1
best_score = -np.inf

for n_comp in range(1, min(X_scaled.shape[1], 20)):
    pls = PLSRegression(n_components=n_comp)
    scores = cross_val_score(pls, X_scaled, y, cv=5, scoring="r2")
    if scores.mean() > best_score:
        best_score = scores.mean()
        best_n = n_comp

print(f"Оптимальное количество компонент: {best_n}")

# Обучить финальную модель
pls = PLSRegression(n_components=best_n)
pls.fit(X_scaled, y)

Плюсы:

• Эффективна при высокой мультиколлинеарности
• Учитывает целевую переменную
• Хорошая интерпретируемость

Метод 7: Feature Engineering

Создать новые признаки, которые менее коррелированы:

# Пример: Если high_price и low_price коррелируют
# Создать средневзвешенную цену
df["weighted_price"] = (
    0.7 * df["high_price"] + 0.3 * df["low_price"]
)

# Или создать разницу (more unique information)
df["price_spread"] = df["high_price"] - df["low_price"]

# Использовать новые признаки вместо исходных
df_new = df.drop(columns=["high_price", "low_price"])
df_new = df_new.drop(columns=[], errors="ignore").assign(
    weighted_price=df["weighted_price"],
    price_spread=df["price_spread"]
)

Практический пример: Комплексное решение

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score

# Этап 1: Удалить явно коррелирующие признаки
df_cleaned = remove_correlated_features(df, threshold=0.9)

# Этап 2: Стандартизировать
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df_cleaned)

# Этап 3: Применить Ridge Regression
ridge = Ridge(alpha=1.0)
cv_scores = cross_val_score(
    ridge, X_scaled, y, cv=5, scoring="r2"
)

print(f"R² Score: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")

# Этап 4: Проверить коэффициенты
ridge.fit(X_scaled, y)
coef_importance = pd.DataFrame({
    "Feature": df_cleaned.columns,
    "Coefficient": ridge.coef_
}).sort_values("Coefficient", key=abs, ascending=False)

print("\nСамые важные признаки:")
print(coef_importance.head(10))

Мой практический опыт

На реальных проектах я использовал:

1. Для финансовых данных: Ridge + feature engineering (коэффициенты стали стабильнее)

2. Для image recognition: PCA + Random Forest (уменьшилась размерность, улучшилась скорость)

3. Для текстовых данных: Elastic Net (автоматически выбрал самые информативные слова)

4. Для временных рядов: PLS (лучше учитывала целевую переменную)

5. Для исследовательских моделей: Удаление признаков (интерпретируемость критична)

Выводы

Выбор метода зависит от:

• Цель: Интерпретируемость vs Точность
• Размер данных: Много ли признаков и наблюдений
• Тип признаков: Категориальные, числовые, смешанные
• Бизнес-контекст: Нужно ли объяснять коэффициенты

Рекомендация: Начни с диагностики (VIF), затем пробуй Ridge или Elastic Net, и если нужна интерпретируемость — удаляй признаки.