Introduction
Ce laboratoire montre comment utiliser la régularisation dans le perceptron multicouche (MLP) pour lutter contre le surapprentissage. Nous comparerons différentes valeurs pour le paramètre de régularisation, alpha, et observerons comment les fonctions de décision changent.
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 des commentaires après la session, et nous résoudrons rapidement le problème pour vous.
Importation des bibliothèques
Nous commencerons par importer les bibliothèques nécessaires pour ce laboratoire. Nous utiliserons scikit-learn pour créer des jeux de données synthétiques, MLPClassifier pour construire le modèle MLP, StandardScaler pour standardiser les données et make_pipeline pour créer un pipeline de transformations et de classifieur.
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
Définition des valeurs d'alpha
Nous allons définir différentes valeurs pour le paramètre de régularisation, alpha. Nous utiliserons np.logspace pour générer 5 valeurs espacées logarithmiquement entre 0,1 et 10.
alphas = np.logspace(-1, 1, 5)
Création de classifieurs
Nous allons créer des classifieurs MLP pour chaque valeur d'alpha. Nous allons créer un pipeline qui inclut StandardScaler pour standardiser les données et MLPClassifier avec différentes valeurs d'alpha. Nous allons définir le solveur sur 'lbfgs', qui est un optimiseur dans la famille des méthodes quasi-Newton. Nous allons définir max_iter sur 2000 et early_stopping sur True pour éviter le surapprentissage. Nous utiliserons deux couches cachées avec 10 neurones chacune.
classifiers = []
names = []
for alpha in alphas:
classifiers.append(
make_pipeline(
StandardScaler(),
MLPClassifier(
solver="lbfgs",
alpha=alpha,
random_state=1,
max_iter=2000,
early_stopping=True,
hidden_layer_sizes=[10, 10],
),
)
)
names.append(f"alpha {alpha:.2f}")
Création de jeux de données
Nous allons créer trois jeux de données synthétiques en utilisant les fonctions make_classification, make_moons et make_circles de scikit-learn. Nous allons diviser chaque jeu de données en ensembles d'entraînement et de test en utilisant train_test_split.
X, y = make_classification(
n_features=2, n_redundant=0, n_informative=2, random_state=0, n_clusters_per_class=1
)
rng = np.random.RandomState(2)
X += 2 * rng.uniform(size=X.shape)
linearly_separable = (X, y)
datasets = [
make_moons(noise=0.3, random_state=0),
make_circles(noise=0.2, factor=0.5, random_state=1),
linearly_separable,
]
figure = plt.figure(figsize=(17, 9))
i = 1
## itère sur les jeux de données
for X, y in datasets:
## divise en parties d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.4, random_state=42
)
Tracer les jeux de données
Nous allons tracer chaque jeu de données et colorier différemment les points d'entraînement et de test.
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
## juste tracer le jeu de données d'abord
cm = plt.cm.RdBu
cm_bright = ListedColormap(["#FF0000", "#0000FF"])
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
## Trace les points d'entraînement
ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
## et les points de test
ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
i += 1
Ajuster les classifieurs et tracer les limites de décision
Nous allons ajuster chaque classifieur sur chaque jeu de données et tracer les limites de décision. Nous utiliserons contourf pour tracer la limite de décision et scatter pour tracer les points d'entraînement et de test. Nous afficherons également le score d'exactitude sur chaque tracé.
## itère sur les classifieurs
for name, clf in zip(names, classifiers):
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
## Trace la limite de décision. Pour cela, nous allons attribuer une couleur à chaque
## point dans la grille [x_min, x_max] x [y_min, y_max].
if hasattr(clf, "decision_function"):
Z = clf.decision_function(np.column_stack([xx.ravel(), yy.ravel()]))
else:
Z = clf.predict_proba(np.column_stack([xx.ravel(), yy.ravel()]))[:, 1]
## Place le résultat dans un tracé en couleur
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=cm, alpha=0.8)
## Trace également les points d'entraînement
ax.scatter(
X_train[:, 0],
X_train[:, 1],
c=y_train,
cmap=cm_bright,
edgecolors="black",
s=25,
)
## et les points de test
ax.scatter(
X_test[:, 0],
X_test[:, 1],
c=y_test,
cmap=cm_bright,
alpha=0.6,
edgecolors="black",
s=25,
)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
ax.set_title(name)
ax.text(
xx.max() - 0.3,
yy.min() + 0.3,
f"{score:.3f}".lstrip("0"),
size=15,
horizontalalignment="right",
)
i += 1
Afficher les tracés
Enfin, nous allons ajuster la disposition des sous-graphiques et afficher les tracés.
figure.subplots_adjust(left=0.02, right=0.98)
plt.show()
Sommaire
Dans ce laboratoire, nous avons appris à utiliser la régularisation dans le perceptron multicouche pour lutter contre le surapprentissage. Nous avons comparé différentes valeurs du paramètre de régularisation, alpha, et avons observé comment les fonctions de décision ont changé. Nous avons également appris à créer des jeux de données synthétiques, à standardiser les données, à créer des classifieurs MLP et à tracer les limites de décision.