В чем разница между ридж и линейной регрессией?

Разница между Ridge и линейной регрессией

Ridge регрессия - это модификация линейной регрессии, которая добавляет штраф на размер коэффициентов.

Линейная регрессия (OLS - Ordinary Least Squares)

Формула:

Минимизируем: MSE = (1/n) * Σ(y_i - (w₀ + w₁x₁ + ... + w_px_p))²

• Ищем веса w, которые минимизируют ошибку
• Нет регуляризации
• Может привести к переобучению при большом числе признаков

from sklearn.linear_model import LinearRegression
import numpy as np

X = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])
y = np.array([2, 4, 5, 4])

model = LinearRegression()
model.fit(X, y)
print(f"Коэффициенты: {model.coef_}")
print(f"MSE: {np.mean((y - model.predict(X))**2):.4f}")

Ridge регрессия (L2 регуляризация)

Формула:

Минимизируем: MSE + α * Σ(w_i)²

или в виде:

MSE = (1/n) * Σ(y_i - ŷ_i)² + α * Σ(w_i)²

• Добавляет штраф за большие коэффициенты
• α (alpha) контролирует силу регуляризации
• При α=0 становится обычной линейной регрессией
• При α→∞ все коэффициенты стремятся к 0

from sklearn.linear_model import Ridge

# Ridge с α=1.0
model_ridge = Ridge(alpha=1.0)
model_ridge.fit(X, y)
print(f"Ridge коэффициенты: {model_ridge.coef_}")

# Сравним разные alpha
for alpha in [0.0, 0.1, 1.0, 10.0, 100.0]:
    ridge = Ridge(alpha=alpha)
    ridge.fit(X, y)
    print(f"alpha={alpha}: coef={ridge.coef_}, MSE={np.mean((y - ridge.predict(X))**2):.4f}")

Визуальное сравнение

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge

# Данные с шумом
np.random.seed(42)
X = np.linspace(0, 10, 30).reshape(-1, 1)
y = 2 * X.ravel() + np.random.normal(0, 3, 30)

# Обучаем модели
lr = LinearRegression()
lr.fit(X, y)

ridge_weak = Ridge(alpha=0.1)
ridge_weak.fit(X, y)

ridge_strong = Ridge(alpha=10.0)
ridge_strong.fit(X, y)

# На полиномиальных признаках разница видна ярче
from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=10)
X_poly = poly.fit_transform(X)

lr_poly = LinearRegression()
lr_poly.fit(X_poly, y)

ridge_poly = Ridge(alpha=1.0)
ridge_poly.fit(X_poly, y)

print("\nЛинейная регрессия на полиномах:")
print(f"Коэффициенты: {lr_poly.coef_}")
print(f"Максимальный коэф: {np.max(np.abs(lr_poly.coef_)):.2f}")

print("\nRidge регрессия:")
print(f"Коэффициенты: {ridge_poly.coef_}")
print(f"Максимальный коэф: {np.max(np.abs(ridge_poly.coef_)):.2f}")

Таблица сравнения

Когда использовать Ridge

1. Мультиколлинеарность (коррелированные признаки)

import numpy as np
from sklearn.linear_model import LinearRegression, Ridge

# Создаём признаки с высокой корреляцией
X = np.random.randn(100, 10)
X[:, 1] = X[:, 0] + np.random.randn(100) * 0.01  # Почти копия столбца 0

y = X.sum(axis=1) + np.random.randn(100) * 0.1

# Linear Reg - нестабильные коэффициенты
lr = LinearRegression()
lr.fit(X, y)
print(f"Linear: coef std = {np.std(lr.coef_):.2f}")

# Ridge - стабильнее
ridge = Ridge(alpha=1.0)
ridge.fit(X, y)
print(f"Ridge: coef std = {np.std(ridge.coef_):.2f}")

2. Много признаков, мало данных

# 1000 признаков, но только 50 примеров
n_samples = 50
n_features = 1000

X = np.random.randn(n_samples, n_features)
y = np.random.randn(n_samples)

# Linear Reg переобучится
lr = LinearRegression()
lr.fit(X, y)
lr_pred_train = lr.predict(X)
lr_train_r2 = 1 - np.mean((y - lr_pred_train)**2) / np.var(y)
print(f"Linear R²: {lr_train_r2:.3f}")  # Высокий, но на тесте упадет

# Ridge лучше обобщается
ridge = Ridge(alpha=10.0)
ridge.fit(X, y)
ridge_pred_train = ridge.predict(X)
ridge_train_r2 = 1 - np.mean((y - ridge_pred_train)**2) / np.var(y)
print(f"Ridge R²: {ridge_train_r2:.3f}")  # Ниже на обучении, но лучше на тесте

Выбор параметра α (Alpha)

from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score
import numpy as np

# Cross-validation для подбора alpha
alphas = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000]
best_alpha = None
best_score = -np.inf

for alpha in alphas:
    ridge = Ridge(alpha=alpha)
    scores = cross_val_score(ridge, X, y, cv=5, scoring='r2')
    mean_score = scores.mean()
    print(f"alpha={alpha:.4f}: CV R² = {mean_score:.3f}")
    
    if mean_score > best_score:
        best_score = mean_score
        best_alpha = alpha

print(f"\nЛучший alpha: {best_alpha}")

Опции подбора:

# RidgeCV - автоматический подбор
from sklearn.linear_model import RidgeCV

model = RidgeCV(alphas=[0.1, 1, 10, 100])
model.fit(X, y)
print(f"Подобран alpha: {model.alpha_}")

Ridge vs Lasso

Есть ещё Lasso (L1 регуляризация), которая отличается от Ridge:

from sklearn.linear_model import Lasso, Ridge

# Ridge: MSE + α*Σ(w²)  - штраф на квадрат
ridge = Ridge(alpha=1.0)

# Lasso: MSE + α*Σ(|w|)  - штраф на модуль
lasso = Lasso(alpha=0.1)

# Различие:
# - Ridge: уменьшает все коэффициенты
# - Lasso: может обнулить некоторые (автоматический отбор признаков)

Практический пример: Предсказание цены дома

from sklearn.linear_model import LinearRegression, Ridge
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Linear Regression
lr = LinearRegression()
lr.fit(X_train, y_train)
lr_pred_test = lr.predict(X_test)
lr_mse = mean_squared_error(y_test, lr_pred_test)
lr_r2 = r2_score(y_test, lr_pred_test)

print(f"Linear Reg - MSE: {lr_mse:.2f}, R²: {lr_r2:.3f}")

# Ridge Regression
ridge = Ridge(alpha=10.0)
ridge.fit(X_train, y_train)
ridge_pred_test = ridge.predict(X_test)
ridge_mse = mean_squared_error(y_test, ridge_pred_test)
ridge_r2 = r2_score(y_test, ridge_pred_test)

print(f"Ridge Reg - MSE: {ridge_mse:.2f}, R²: {ridge_r2:.3f}")

Итоговые выводы

1. Linear Regression - базовый вариант, без регуляризации
2. Ridge - добавляет штраф на размер коэффициентов
3. Используй Ridge когда:
   • Много коррелированных признаков
   • Признаков больше, чем примеров
   • Переобучение очевидно
4. Параметр α подбирается через cross-validation