Modèle de régression Elastic-Net de Scikit-Learn

Introduction

Dans ce laboratoire, nous utiliserons le modèle de régression Elastic-Net de Scikit-learn pour illustrer pourquoi les performances d'un estimateur sur des données non vues (données de test) ne sont pas les mêmes que celles sur les données d'entraînement. Nous allons générer des données d'échantillonnage, calculer les erreurs d'entraînement et de test, et tracer les fonctions des résultats.

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 Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

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

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

Skills Graph

Générer des données d'échantillonnage

Nous allons générer des données d'échantillonnage à l'aide de la fonction make_regression() de Scikit-learn. Nous allons définir le nombre d'échantillons d'entraînement sur 75, le nombre d'échantillons de test sur 150 et le nombre de fonctionnalités sur 500. Nous allons également définir n_informative sur 50 et shuffle sur False.

import numpy as np
from sklearn import linear_model
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

n_samples_train, n_samples_test, n_features = 75, 150, 500
X, y, coef = make_regression(
    n_samples=n_samples_train + n_samples_test,
    n_features=n_features,
    n_informative=50,
    shuffle=False,
    noise=1.0,
    coef=True,
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=n_samples_train, test_size=n_samples_test, shuffle=False
)

Calculer les erreurs d'entraînement et de test

Nous allons calculer les erreurs d'entraînement et de test à l'aide du modèle de régression Elastic-Net de Scikit-learn. Nous allons définir le paramètre de régularisation alpha sur une plage de valeurs allant de 10^-5 à 10^1 à l'aide de np.logspace(). Nous allons également définir l1_ratio sur 0,7 et max_iter sur 10000.

alphas = np.logspace(-5, 1, 60)
enet = linear_model.ElasticNet(l1_ratio=0.7, max_iter=10000)
train_errors = list()
test_errors = list()
for alpha in alphas:
    enet.set_params(alpha=alpha)
    enet.fit(X_train, y_train)
    train_errors.append(enet.score(X_train, y_train))
    test_errors.append(enet.score(X_test, y_test))

i_alpha_optim = np.argmax(test_errors)
alpha_optim = alphas[i_alpha_optim]
print("Optimal regularization parameter : %s" % alpha_optim)

Tracer les fonctions des résultats

Nous allons tracer les fonctions des résultats à l'aide de la bibliothèque matplotlib. Nous utiliserons la fonction plt.subplot() pour créer deux sous-graphiques. Dans le premier sous-graphique, nous tracerons les erreurs d'entraînement et de test en fonction du paramètre de régularisation. Nous tracerons également une ligne verticale au niveau du paramètre de régularisation optimal. Dans le second sous-graphique, nous tracerons les coefficients réels et les coefficients estimés.

import matplotlib.pyplot as plt

plt.subplot(2, 1, 1)
plt.semilogx(alphas, train_errors, label="Train")
plt.semilogx(alphas, test_errors, label="Test")
plt.vlines(
    alpha_optim,
    plt.ylim()[0],
    np.max(test_errors),
    color="k",
    linewidth=3,
    label="Optimum on test",
)
plt.legend(loc="lower right")
plt.ylim([0, 1.2])
plt.xlabel("Paramètre de régularisation")
plt.ylabel("Performance")

## Afficher coef_ estimé vs coef réel
plt.subplot(2, 1, 2)
plt.plot(coef, label="Coef réel")
plt.plot(coef_, label="Coef estimé")
plt.legend()
plt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.26)
plt.show()

Résumé

Dans ce laboratoire, nous avons appris à utiliser le modèle de régression Elastic-Net de Scikit-learn pour calculer les erreurs d'entraînement et de test et tracer les fonctions des résultats. Nous avons également appris pourquoi les performances d'un estimateur sur des données non vues (données de test) ne sont pas les mêmes que celles sur les données d'entraînement. Nous avons généré des données d'échantillonnage, calculé les erreurs d'entraînement et de test, et tracé les fonctions des résultats à l'aide des fonctions make_regression(), linear_model.ElasticNet(), train_test_split(), np.logspace() et matplotlib.