Application de techniques de régularisation avec SGD

Introduction

Dans ce laboratoire, nous allons apprendre à connaître SGDClassifier et SGDRegressor dans scikit-learn et à les utiliser pour appliquer des pénalités L1, L2 et elastic-net sur les données.

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 à Jupyter Notebook pour pratiquer.

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ésoudrons rapidement le problème pour vous.

Importation des bibliothèques

La première étape consiste à importer les bibliothèques nécessaires. Nous allons utiliser numpy, matplotlib et scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import SGDClassifier, SGDRegressor

Génération de données

Nous allons générer quelques données d'échantillonnage pour appliquer nos pénalités dessus. Pour cet exemple, nous allons générer deux classes de données avec 100 échantillons chacune.

np.random.seed(42)

## Générer deux classes de données
X = np.random.randn(200, 2)
y = np.repeat([1, -1], 100)

Application de la pénalité L1

Nous allons maintenant appliquer la pénalité L1 sur nos données en utilisant SGDClassifier.

## Créer un classifieur avec la pénalité L1
clf = SGDClassifier(loss='hinge', penalty='l1', alpha=0.05, max_iter=1000, tol=1e-3)

## Ajuster le modèle
clf.fit(X, y)

## Tracer la frontière de décision
plt.scatter(X[:, 0], X[:, 1], c=y)
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 201), np.linspace(ylim[0], ylim[1], 201))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5, linestyles=['--', '-', '--'])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
plt.title('Pénalité L1')
plt.show()

Application de la pénalité L2

Nous allons maintenant appliquer la pénalité L2 sur nos données en utilisant SGDClassifier.

## Créer un classifieur avec la pénalité L2
clf = SGDClassifier(loss='hinge', penalty='l2', alpha=0.05, max_iter=1000, tol=1e-3)

## Ajuster le modèle
clf.fit(X, y)

## Tracer la frontière de décision
plt.scatter(X[:, 0], X[:, 1], c=y)
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 201), np.linspace(ylim[0], ylim[1], 201))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5, linestyles=['--', '-', '--'])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
plt.title('Pénalité L2')
plt.show()

Application de la pénalité Elastic-Net

Nous allons maintenant appliquer la pénalité Elastic-Net sur nos données en utilisant SGDClassifier.

## Créer un classifieur avec la pénalité Elastic-Net
clf = SGDClassifier(loss='hinge', penalty='elasticnet', alpha=0.05, l1_ratio=0.15, max_iter=1000, tol=1e-3)

## Ajuster le modèle
clf.fit(X, y)

## Tracer la frontière de décision
plt.scatter(X[:, 0], X[:, 1], c=y)
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 201), np.linspace(ylim[0], ylim[1], 201))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5, linestyles=['--', '-', '--'])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
plt.title('Pénalité Elastic-Net')
plt.show()

Récapitulatif

Dans ce laboratoire, nous avons appris à appliquer les pénalités L1, L2 et Elastic-Net sur des données en utilisant SGDClassifier dans scikit-learn. Nous avons généré des données d'échantillonnage, appliqué les pénalités et tracé les frontières de décision. Ceci est un outil utile pour la régularisation dans les modèles d'apprentissage automatique, en particulier pour prévenir le surapprentissage.