Maîtriser la régression Ridge pour la modélisation linéaire

Introduction

Dans ce laboratoire, nous allons apprendre à utiliser la régression Ridge pour la régression linéaire avec régularisation L2 pour éviter le surapprentissage. Nous utiliserons scikit-learn, une bibliothèque populaire de machine learning pour Python.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Importez les bibliothèques nécessaires

Nous allons commencer par importer les bibliothèques nécessaires pour ce laboratoire.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_regression
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error

Générer des données aléatoires

Nous allons générer des données aléatoires avec la fonction make_regression de scikit-learn. Nous allons définir n_samples sur 10, n_features sur 10 et random_state sur 1. Cette fonction retournera nos caractéristiques d'entrée X, notre variable cible y et les valeurs réelles des coefficients w.

X, y, w = make_regression(
    n_samples=10, n_features=10, coef=True, random_state=1, bias=3.5
)

Initialiser le modèle de régression Ridge

Nous allons initialiser le modèle de régression Ridge avec ses hyperparamètres par défaut.

clf = Ridge()

Entraîner le modèle avec différentes forces de régularisation

Nous allons entraîner le modèle avec différentes forces de régularisation en utilisant une boucle. Nous allons définir la force de régularisation en changeant la valeur de alpha dans la fonction set_params. Nous allons enregistrer les coefficients et les erreurs pour chaque valeur de alpha.

coefs = []
errors = []

alphas = np.logspace(-6, 6, 200)

for a in alphas:
    clf.set_params(alpha=a)
    clf.fit(X, y)
    coefs.append(clf.coef_)
    errors.append(mean_squared_error(clf.coef_, w))

Tracer les résultats

Nous allons tracer les coefficients et les erreurs en fonction de la force de régularisation à l'aide de Matplotlib.

plt.figure(figsize=(20, 6))

plt.subplot(121)
ax = plt.gca()
ax.plot(alphas, coefs)
ax.set_xscale("log")
plt.xlabel("alpha")
plt.ylabel("weights")
plt.title("Ridge coefficients as a function of the regularization")
plt.axis("tight")

plt.subplot(122)
ax = plt.gca()
ax.plot(alphas, errors)
ax.set_xscale("log")
plt.xlabel("alpha")
plt.ylabel("error")
plt.title("Coefficient error as a function of the regularization")
plt.axis("tight")

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à utiliser la régression Ridge avec une régularisation L2 pour éviter le surapprentissage. Nous avons généré des données aléatoires, entraîné un modèle de régression Ridge avec différentes forces de régularisation et tracé les coefficients et les erreurs en fonction de la force de régularisation.

Régression Ridge pour la modélisation linéaire