Introduction
Ce laboratoire vous guidera dans le processus d'utilisation du MLPClassifier de Scikit-learn pour comparer les performances de différentes stratégies d'apprentissage stochastique, y compris SGD et Adam. Le MLPClassifier est un classifieur de réseau de neurones qui utilise la rétropropagation pour optimiser les poids du réseau. L'objectif de ce laboratoire est de montrer comment différentes stratégies d'apprentissage stochastique peuvent affecter les courbes de perte d'entraînement du MLPClassifier. Nous utiliserons plusieurs petits jeux de données pour cet exemple, bien que la tendance générale montrée dans ces exemples semble se transposer à des jeux de données plus grands.
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ésoudrons rapidement le problème pour vous.
Importez les bibliothèques nécessaires
Tout d'abord, nous devons importer les bibliothèques nécessaires, y compris MLPClassifier, MinMaxScaler, datasets et matplotlib.pyplot. Nous importerons également ConvergenceWarning pour ignorer les avertissements de convergence pendant l'entraînement.
import warnings
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import MinMaxScaler
from sklearn import datasets
from sklearn.exceptions import ConvergenceWarning
Définissez différentes stratégies d'apprentissage
Ensuite, nous devons définir les différentes stratégies d'apprentissage que nous voulons comparer. Nous définirons plusieurs programmes de taux d'apprentissage différents et des paramètres de momentum, y compris un taux d'apprentissage constant, constant avec momentum, constant avec le momentum de Nesterov, taux d'apprentissage à mise à l'échelle inverse, à mise à l'échelle inverse avec momentum, à mise à l'échelle inverse avec le momentum de Nesterov et adam. Nous définirons également des étiquettes et des arguments de tracé à utiliser dans notre tracé plus tard.
## différents programmes de taux d'apprentissage et paramètres de momentum
params = [
{
"solver": "sgd",
"learning_rate": "constant",
"momentum": 0,
"learning_rate_init": 0.2,
},
{
"solver": "sgd",
"learning_rate": "constant",
"momentum": 0.9,
"nesterovs_momentum": False,
"learning_rate_init": 0.2,
},
{
"solver": "sgd",
"learning_rate": "constant",
"momentum": 0.9,
"nesterovs_momentum": True,
"learning_rate_init": 0.2,
},
{
"solver": "sgd",
"learning_rate": "invscaling",
"momentum": 0,
"learning_rate_init": 0.2,
},
{
"solver": "sgd",
"learning_rate": "invscaling",
"momentum": 0.9,
"nesterovs_momentum": True,
"learning_rate_init": 0.2,
},
{
"solver": "sgd",
"learning_rate": "invscaling",
"momentum": 0.9,
"nesterovs_momentum": False,
"learning_rate_init": 0.2,
},
{"solver": "adam", "learning_rate_init": 0.01},
]
labels = [
"taux d'apprentissage constant",
"constant avec momentum",
"constant avec le momentum de Nesterov",
"taux d'apprentissage à mise à l'échelle inverse",
"à mise à l'échelle inverse avec momentum",
"à mise à l'échelle inverse avec le momentum de Nesterov",
"adam",
]
plot_args = [
{"c": "rouge", "linestyle": "-"},
{"c": "vert", "linestyle": "-"},
{"c": "bleu", "linestyle": "-"},
{"c": "rouge", "linestyle": "--"},
{"c": "vert", "linestyle": "--"},
{"c": "bleu", "linestyle": "--"},
{"c": "noir", "linestyle": "-"},
]
Définissez une fonction pour tracer les courbes d'apprentissage
Ensuite, nous devons définir une fonction qui tracera les courbes d'apprentissage pour chaque stratégie d'apprentissage sur chaque ensemble de données. La fonction prend en entrée l'ensemble de données (X, y), un axe sur lequel tracer et un nom pour l'ensemble de données. Nous utiliserons MinMaxScaler pour mettre à l'échelle les données et MLPClassifier pour entraîner le réseau de neurones. Nous entraînerons le réseau en utilisant chaque stratégie d'apprentissage, en ignorant les avertissements de convergence, et tracerons les courbes d'apprentissage pour chaque stratégie sur le même graphique.
def plot_on_dataset(X, y, ax, name):
## pour chaque ensemble de données, trace l'apprentissage pour chaque stratégie d'apprentissage
print("\napprentissage sur l'ensemble de données %s" % name)
ax.set_title(name)
X = MinMaxScaler().fit_transform(X)
mlps = []
if name == "digits":
## digits est plus grand mais converge assez rapidement
max_iter = 15
else:
max_iter = 400
for label, param in zip(labels, params):
print("entraînement: %s" % label)
mlp = MLPClassifier(random_state=0, max_iter=max_iter, **param)
## certaines combinaisons de paramètres ne convergeront pas comme on peut le voir sur les
## graphiques, donc elles sont ignorées ici
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", category=ConvergenceWarning, module="sklearn"
)
mlp.fit(X, y)
mlps.append(mlp)
print("Score de l'ensemble d'entraînement: %f" % mlp.score(X, y))
print("Perte de l'ensemble d'entraînement: %f" % mlp.loss_)
for mlp, label, args in zip(mlps, labels, plot_args):
ax.plot(mlp.loss_curve_, label=label, **args)
Chargez ou générez de petits ensembles de données
Maintenant, nous devons charger ou générer les petits ensembles de données que nous utiliserons pour cet exemple. Nous utiliserons l'ensemble de données iris, l'ensemble de données digits et deux ensembles de données générés à l'aide des fonctions make_circles et make_moons.
iris = datasets.load_iris()
X_digits, y_digits = datasets.load_digits(return_X_y=True)
data_sets = [
(iris.data, iris.target),
(X_digits, y_digits),
datasets.make_circles(noise=0.2, factor=0.5, random_state=1),
datasets.make_moons(noise=0.3, random_state=0),
]
Tracez les courbes d'apprentissage pour chaque ensemble de données
Enfin, nous pouvons tracer les courbes d'apprentissage pour chaque ensemble de données en utilisant la fonction plot_on_dataset. Nous créerons un graphique 2x2 et tracerons chaque ensemble de données sur un axe séparé.
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
for ax, data, name in zip(
axes.ravel(), data_sets, ["iris", "digits", "circles", "moons"]
):
plot_on_dataset(*data, ax=ax, name=name)
fig.legend(ax.get_lines(), labels, ncol=3, loc="upper center")
plt.show()
Sommaire
Dans ce laboratoire, nous avons utilisé le MLPClassifier de Scikit-learn pour comparer les performances de différentes stratégies d'apprentissage stochastique, y compris SGD et Adam, sur plusieurs petits ensembles de données. Nous avons défini différents programmes de taux d'apprentissage et des paramètres de momentum, puis avons entraîné le MLPClassifier en utilisant chaque stratégie. Nous avons tracé les courbes d'apprentissage pour chaque stratégie sur chaque ensemble de données et avons observé comment différentes stratégies peuvent affecter les courbes de perte d'entraînement. Nous avons démontré l'importance de choisir la bonne stratégie d'apprentissage pour l'ensemble de données et la tâche à l'étude.