import numpy as np
from sklearn.linear_model import Lasso

# Simulate data with 10 features, only 3 are relevant
np.random.seed(42)
n_samples, n_features = 100, 10
X = np.random.randn(n_samples, n_features)
true_coefs = np.array([3, 0, 0, 2, 0, 0, 0, 0, 1, 0])
y = X @ true_coefs + np.random.randn(n_samples) * 0.5

# Fit Lasso
lasso = Lasso(alpha=0.1).fit(X, y)

print("True coefficients:", true_coefs)
print("Lasso coefficients:", np.round(lasso.coef_, 2))
print(f"Features selected: {np.sum(lasso.coef_ != 0)} / {n_features}")

# Output:
# True coefficients: [3 0 0 2 0 0 0 0 1 0]
# Lasso coefficients: [2.85 0.   0.   1.73 0.   0.   0.   0.   0.65 0.  ]
# Features selected: 3 / 10

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# Generate synthetic data
np.random.seed(42)
n_samples, n_features = 200, 50
X = np.random.randn(n_samples, n_features)
# Only 5 features are truly relevant
true_coefs = np.zeros(n_features)
true_coefs[:5] = [3, -2, 1.5, -1, 0.5]
y = X @ true_coefs + np.random.randn(n_samples) * 0.3

# Create pipelines with scaling
models = {
    'Ridge': Pipeline([
        ('scaler', StandardScaler()),
        ('model', Ridge())
    ]),
    'Lasso': Pipeline([
        ('scaler', StandardScaler()),
        ('model', Lasso())
    ]),
    'ElasticNet': Pipeline([
        ('scaler', StandardScaler()),
        ('model', ElasticNet())
    ])
}

# Cross-validation with different alpha values
alphas = np.logspace(-3, 3, 50)

for name, model in models.items():
    scores = []
    for alpha in alphas:
        if name == 'ElasticNet':
            model.set_params(model__alpha=alpha)
        else:
            model.set_params(model__alpha=alpha)
        cv_score = cross_val_score(model, X, y, cv=5, scoring='r2').mean()
        scores.append(cv_score)
    
    best_alpha = alphas[np.argmax(scores)]
    print(f"{name}: Best alpha = {best_alpha:.4f}, Best R² = {max(scores):.4f}")

# Fit Lasso to see feature selection
lasso = Pipeline([
    ('scaler', StandardScaler()),
    ('model', Lasso(alpha=0.1))
])
lasso.fit(X, y)
print(f"Lasso selected {np.sum(lasso['model'].coef_ != 0)} features out of {n_features}")
print(f"True features selected: {np.sum(lasso['model'].coef_[:5] != 0)} / 5")

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import Ridge

# Define parameter grid
param_grid = {'alpha': np.logspace(-4, 4, 50)}

# Grid search with cross-validation
grid_search = GridSearchCV(
    Ridge(), 
    param_grid, 
    cv=5, 
    scoring='r2',
    return_train_score=True
)
grid_search.fit(X, y)

print(f"Best alpha: {grid_search.best_params_['alpha']:.4f}")
print(f"Best R² score: {grid_search.best_score_:.4f}")

# Plot results
results = grid_search.cv_results_
plt.figure(figsize=(10, 6))
plt.semilogx(param_grid['alpha'], results['mean_test_score'], label='Test')
plt.semilogx(param_grid['alpha'], results['mean_train_score'], label='Train')
plt.xlabel('Alpha')
plt.ylabel('R² Score')
plt.title('Ridge: Alpha vs Performance')
plt.legend()
plt.grid(True)
plt.show()