Регуляризація в регресії — Ridge та Lasso

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Ridge, LinearRegression
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score

# Генеруємо дані (квадратична залежність + шум)
rng = np.random.default_rng(42)
X = np.linspace(0, 10, 100).reshape(-1, 1)
y = 30 + 5*X.ravel() + 2*X.ravel()**2 + rng.normal(0, 10, 100)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Побудова моделей з різними alpha
alphas = [0, 0.1, 1, 10, 100]
results = {}

plt.figure(figsize=(15, 10))

for i, alpha in enumerate(alphas, 1):
    if alpha == 0:
        model = Pipeline([
            ('poly', PolynomialFeatures(degree=10)),
            ('scaler', StandardScaler()),
            ('regressor', LinearRegression())
        ])
        label = 'LinearRegression (без регуляризації)'
    else:
        model = Pipeline([
            ('poly', PolynomialFeatures(degree=10)),
            ('scaler', StandardScaler()),
            ('regressor', Ridge(alpha=alpha))
        ])
        label = f'Ridge (alpha={alpha})'
    
    model.fit(X_train, y_train)
    
    r2_train = model.score(X_train, y_train)
    r2_test = model.score(X_test, y_test)
    results[alpha] = {'R² train': r2_train, 'R² test': r2_test}
    
    # Візуалізація
    X_line = np.linspace(0, 10, 300).reshape(-1, 1)
    y_line = model.predict(X_line)
    
    plt.subplot(2, 3, i)
    plt.scatter(X_train, y_train, alpha=0.5, s=30, label='Train', edgecolors='k', linewidths=0.5)
    plt.scatter(X_test, y_test, alpha=0.5, s=30, color='orange', label='Test', edgecolors='k', linewidths=0.5)
    plt.plot(X_line, y_line, color='red', linewidth=2.5)
    plt.xlabel('X', fontsize=11)
    plt.ylabel('y', fontsize=11)
    plt.title(f'{label}\nR² train={r2_train:.3f}, test={r2_test:.3f}', fontsize=10, fontweight='bold')
    plt.legend(fontsize=9)
    plt.grid(alpha=0.3)
    plt.ylim(0, 250)

plt.tight_layout()
plt.show()

print("\nПорівняльна таблиця:")
print(f"{'Alpha':<10} {'R² train':<12} {'R² test':<12} {'Різниця':<10}")
print("-" * 50)
for alpha, metrics in results.items():
    diff = metrics['R² train'] - metrics['R² test']
    print(f"{alpha:<10} {metrics['R² train']:<12.4f} {metrics['R² test']:<12.4f} {diff:<10.4f}")

from sklearn.linear_model import Lasso
import pandas as pd

# Створимо датасет з багатьма ознаками, більшість з яких — шум
rng = np.random.default_rng(42)
n_samples = 200
n_features = 50

X_full = rng.standard_normal((n_samples, n_features))
# Тільки перші 5 ознак впливають на y, решта — шум
true_coefs = np.zeros(n_features)
true_coefs[:5] = [10, -5, 3, -2, 8]
y_full = X_full @ true_coefs + rng.normal(0, 5, n_samples)

X_train_full, X_test_full, y_train_full, y_test_full = train_test_split(
    X_full, y_full, test_size=0.3, random_state=42
)

# Порівняємо LinearRegression, Ridge та Lasso
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train_full)
X_test_scaled = scaler.transform(X_test_full)

models = {
    'LinearRegression': LinearRegression(),
    'Ridge (alpha=10)': Ridge(alpha=10),
    'Lasso (alpha=1)': Lasso(alpha=1, max_iter=10000)
}

results_comparison = []
coef_data = {}

for name, model in models.items():
    model.fit(X_train_scaled, y_train_full)
    r2_train = model.score(X_train_scaled, y_train_full)
    r2_test = model.score(X_test_scaled, y_test_full)
    
    # Скільки коефіцієнтів обнулено?
    n_nonzero = np.sum(np.abs(model.coef_) > 1e-5)
    
    results_comparison.append({
        'Модель': name,
        'R² train': f"{r2_train:.4f}",
        'R² test': f"{r2_test:.4f}",
        'Ненульових ваг': n_nonzero
    })
    
    coef_data[name] = model.coef_

df_results = pd.DataFrame(results_comparison)
print(df_results.to_string(index=False))
print("\n⚠️ Lasso обнулив більшість ознак!")

# Візуалізація коефіцієнтів
fig, axes = plt.subplots(1, 3, figsize=(16, 5))

for ax, (name, coefs) in zip(axes, coef_data.items()):
    colors = ['red' if abs(c) < 1e-5 else 'blue' for c in coefs]
    ax.bar(range(len(coefs)), coefs, color=colors, alpha=0.7, edgecolor='k', linewidth=0.5)
    ax.axhline(0, color='black', linewidth=1, linestyle='--', alpha=0.5)
    ax.set_xlabel('Індекс ознаки', fontsize=11)
    ax.set_ylabel('Значення коефіцієнта', fontsize=11)
    ax.set_title(f'{name}', fontsize=12, fontweight='bold')
    ax.grid(alpha=0.3, axis='y')

plt.tight_layout()
plt.show()

from sklearn.model_selection import cross_val_score

# Діапазон alpha для перебору
alphas = [0.001, 0.01, 0.1, 1, 10, 100, 1000]
ridge_scores = []
lasso_scores = []

for alpha in alphas:
    # Ridge
    ridge_model = Ridge(alpha=alpha)
    ridge_cv = cross_val_score(ridge_model, X_train_scaled, y_train_full, cv=5, scoring='r2')
    ridge_scores.append(ridge_cv.mean())
    
    # Lasso
    lasso_model = Lasso(alpha=alpha, max_iter=10000)
    lasso_cv = cross_val_score(lasso_model, X_train_scaled, y_train_full, cv=5, scoring='r2')
    lasso_scores.append(lasso_cv.mean())

# Візуалізація
plt.figure(figsize=(10, 6))
plt.plot(alphas, ridge_scores, marker='o', linewidth=2, label='Ridge', color='blue')
plt.plot(alphas, lasso_scores, marker='s', linewidth=2, label='Lasso', color='orange')
plt.xscale('log')
plt.xlabel('Alpha (логарифмічна шкала)', fontsize=12)
plt.ylabel('R² (крос-валідація, 5-fold)', fontsize=12)
plt.title('Підбір оптимального alpha', fontsize=14, fontweight='bold')
plt.legend(fontsize=11)
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

# Оптимальні значення
optimal_ridge_alpha = alphas[np.argmax(ridge_scores)]
optimal_lasso_alpha = alphas[np.argmax(lasso_scores)]

print(f"Оптимальний alpha для Ridge: {optimal_ridge_alpha} (R² CV = {max(ridge_scores):.4f})")
print(f"Оптимальний alpha для Lasso: {optimal_lasso_alpha} (R² CV = {max(lasso_scores):.4f})")

from sklearn.linear_model import RidgeCV, LassoCV

# RidgeCV — автоматичний підбір alpha через CV
ridge_cv = RidgeCV(alphas=[0.001, 0.01, 0.1, 1, 10, 100, 1000], cv=5)
ridge_cv.fit(X_train_scaled, y_train_full)

print(f"Оптимальний alpha для Ridge: {ridge_cv.alpha_}")
print(f"R² test: {ridge_cv.score(X_test_scaled, y_test_full):.4f}")

# LassoCV — автоматичний підбір alpha через CV
lasso_cv = LassoCV(alphas=[0.001, 0.01, 0.1, 1, 10, 100], cv=5, max_iter=10000)
lasso_cv.fit(X_train_scaled, y_train_full)

print(f"\nОптимальний alpha для Lasso: {lasso_cv.alpha_:.4f}")
print(f"R² test: {lasso_cv.score(X_test_scaled, y_test_full):.4f}")
print(f"Кількість відібраних ознак: {np.sum(np.abs(lasso_cv.coef_) > 1e-5)}")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error

# Генерація даних (квадратична залежність)
rng = np.random.default_rng(42)
X = np.linspace(0, 10, 100).reshape(-1, 1)
y = 30 + 5*X.ravel() + 2*X.ravel()**2 + rng.normal(0, 10, 100)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Порівняємо моделі на поліномі ступеня 12
degree = 12

models = {
    'LinearRegression': Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', LinearRegression())
    ]),
    'Ridge (α=10)': Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', Ridge(alpha=10))
    ]),
    'Lasso (α=1)': Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', Lasso(alpha=1, max_iter=10000))
    ])
}

# Навчання та оцінка
results = {}
plt.figure(figsize=(15, 5))

for i, (name, model) in enumerate(models.items(), 1):
    model.fit(X_train, y_train)
    
    y_train_pred = model.predict(X_train)
    y_test_pred = model.predict(X_test)
    
    r2_train = r2_score(y_train, y_train_pred)
    r2_test = r2_score(y_test, y_test_pred)
    
    results[name] = {
        'R² train': r2_train,
        'R² test': r2_test,
        'Gap': r2_train - r2_test
    }
    
    # Візуалізація
    X_line = np.linspace(0, 10, 300).reshape(-1, 1)
    y_line = model.predict(X_line)
    
    plt.subplot(1, 3, i)
    plt.scatter(X_train, y_train, alpha=0.5, s=30, label='Train', edgecolors='k', linewidths=0.5)
    plt.scatter(X_test, y_test, alpha=0.5, s=30, color='orange', label='Test', edgecolors='k', linewidths=0.5)
    plt.plot(X_line, y_line, color='red', linewidth=2.5)
    plt.xlabel('X', fontsize=11)
    plt.ylabel('y', fontsize=11)
    plt.title(f'{name}\nR² train={r2_train:.3f}, test={r2_test:.3f}', fontsize=11, fontweight='bold')
    plt.legend(fontsize=10)
    plt.grid(alpha=0.3)
    plt.ylim(0, 250)

plt.tight_layout()
plt.show()

# Порівняльна таблиця
print(f"\nПорівняння моделей на поліномі ступеня {degree}:")
print(f"{'Модель':<25} {'R² train':<12} {'R² test':<12} {'Gap':<10}")
print("-" * 65)
for name, metrics in results.items():
    print(f"{name:<25} {metrics['R² train']:<12.4f} {metrics['R² test']:<12.4f} {metrics['Gap']:<10.4f}")

print("\n✅ Ridge та Lasso успішно зменшили перенавчання!")

import pandas as pd

# Створимо датасет: 20 ознак, але тільки 3 реально впливають на y
rng = np.random.default_rng(123)
n_samples = 300
n_features = 20

X_data = rng.standard_normal((n_samples, n_features))

# Тільки ознаки 2, 7, 15 впливають на y
true_coefficients = np.zeros(n_features)
true_coefficients[2] = 8.5
true_coefficients[7] = -6.2
true_coefficients[15] = 4.8

y_data = X_data @ true_coefficients + rng.normal(0, 3, n_samples)

X_train_data, X_test_data, y_train_data, y_test_data = train_test_split(
    X_data, y_data, test_size=0.3, random_state=42
)

# Стандартизація
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train_data)
X_test_scaled = scaler.transform(X_test_data)

# Навчання Lasso з різними alpha
alphas_test = [0.1, 0.5, 1.0, 2.0]
lasso_results = []

for alpha in alphas_test:
    lasso_model = Lasso(alpha=alpha, max_iter=10000)
    lasso_model.fit(X_train_scaled, y_train_data)
    
    r2_test = lasso_model.score(X_test_scaled, y_test_data)
    n_selected = np.sum(np.abs(lasso_model.coef_) > 1e-5)
    
    lasso_results.append({
        'alpha': alpha,
        'R² test': r2_test,
        'Selected features': n_selected
    })

df_lasso = pd.DataFrame(lasso_results)
print("Lasso: вплив alpha на відбір ознак\n")
print(df_lasso.to_string(index=False))

# Візуалізація коефіцієнтів для оптимального alpha
optimal_lasso = Lasso(alpha=1.0, max_iter=10000)
optimal_lasso.fit(X_train_scaled, y_train_data)

plt.figure(figsize=(12, 5))

# Графік 1: Коефіцієнти
plt.subplot(1, 2, 1)
feature_names = [f'X{i}' for i in range(n_features)]
colors = ['green' if i in [2, 7, 15] else 'gray' for i in range(n_features)]
plt.bar(range(n_features), optimal_lasso.coef_, color=colors, alpha=0.7, edgecolor='k', linewidth=0.5)
plt.axhline(0, color='black', linewidth=1, linestyle='--', alpha=0.5)
plt.xlabel('Індекс ознаки', fontsize=11)
plt.ylabel('Коефіцієнт', fontsize=11)
plt.title('Lasso (α=1.0): автоматичний відбір ознак', fontsize=12, fontweight='bold')
plt.xticks(range(n_features), feature_names, rotation=45)
plt.grid(alpha=0.3, axis='y')

# Графік 2: Порівняння справжніх та знайдених ознак
plt.subplot(1, 2, 2)
selected_indices = np.where(np.abs(optimal_lasso.coef_) > 1e-5)[0]
true_indices = [2, 7, 15]

x_pos = np.arange(len(selected_indices))
plt.bar(x_pos - 0.2, [true_coefficients[i] for i in selected_indices], 
        width=0.4, label='Справжні', alpha=0.7, color='blue', edgecolor='k')
plt.bar(x_pos + 0.2, [optimal_lasso.coef_[i] for i in selected_indices], 
        width=0.4, label='Знайдені Lasso', alpha=0.7, color='orange', edgecolor='k')

plt.xlabel('Відібрані ознаки', fontsize=11)
plt.ylabel('Значення коефіцієнта', fontsize=11)
plt.title('Порівняння справжніх та знайдених коефіцієнтів', fontsize=12, fontweight='bold')
plt.xticks(x_pos, [f'X{i}' for i in selected_indices])
plt.legend(fontsize=10)
plt.grid(alpha=0.3, axis='y')

plt.tight_layout()
plt.show()

print(f"\n✅ Lasso знайшов {len(selected_indices)} ознак зі справжніх 3!")
print(f"Індекси відібраних ознак: {selected_indices}")

# Створимо дані з сильно корельованими ознаками
rng = np.random.default_rng(999)
n = 200

# Базова ознака
X1 = rng.standard_normal(n)
# X2 майже ідентична X1 (сильна кореляція)
X2 = X1 + rng.normal(0, 0.1, n)
# X3 незалежна
X3 = rng.standard_normal(n)

X_corr = np.column_stack([X1, X2, X3])
y_corr = 5*X1 + 3*X3 + rng.normal(0, 2, n)

X_train_corr, X_test_corr, y_train_corr, y_test_corr = train_test_split(
    X_corr, y_corr, test_size=0.3, random_state=42
)

scaler_corr = StandardScaler()
X_train_corr_scaled = scaler_corr.fit_transform(X_train_corr)
X_test_corr_scaled = scaler_corr.transform(X_test_corr)

# Порівняємо LinearRegression, Ridge та Lasso
models_corr = {
    'LinearRegression': LinearRegression(),
    'Ridge (α=1)': Ridge(alpha=1),
    'Lasso (α=0.1)': Lasso(alpha=0.1, max_iter=10000)
}

print("Коефіцієнти моделей при мультиколінеарності:\n")
print(f"{'Модель':<20} {'Coef X1':<12} {'Coef X2':<12} {'Coef X3':<12} {'R² test':<10}")
print("-" * 70)

for name, model in models_corr.items():
    model.fit(X_train_corr_scaled, y_train_corr)
    r2 = model.score(X_test_corr_scaled, y_test_corr)
    coefs = model.coef_
    print(f"{name:<20} {coefs[0]:<12.4f} {coefs[1]:<12.4f} {coefs[2]:<12.4f} {r2:<10.4f}")

print("\n📊 Аналіз:")
print("- LinearRegression: нестабільні коефіцієнти для X1 та X2 (корельовані)")
print("- Ridge: стабілізує коефіцієнти, розподіляє вагу між X1 та X2")
print("- Lasso: обирає одну з корельованих ознак, обнулює іншу")