Scikit-Learn MLPClassifier: Estrategias de Aprendizaje Estocástico

Introducción

Esta práctica te guiará a través del proceso de uso del clasificador MLPClassifier de Scikit-learn para comparar el rendimiento de diferentes estrategias de aprendizaje estocástico, incluyendo SGD y Adam. El MLPClassifier es un clasificador de red neuronal que utiliza la retropropagación para optimizar los pesos de la red. El objetivo de esta práctica es mostrar cómo diferentes estrategias de aprendizaje estocástico pueden afectar las curvas de pérdida de entrenamiento del MLPClassifier. Usaremos varios conjuntos de datos pequeños para este ejemplo, aunque la tendencia general mostrada en estos ejemplos parece extenderse a conjuntos de datos más grandes.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haz clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tengas que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tienes problemas durante el aprendizaje, no dudes en preguntar a Labby. Proporciona retroalimentación después de la sesión y resolveremos rápidamente el problema para ti.

Importar las bibliotecas necesarias

En primer lugar, necesitamos importar las bibliotecas necesarias, incluyendo MLPClassifier, MinMaxScaler, datasets y matplotlib.pyplot. También importaremos ConvergenceWarning para ignorar las advertencias de convergencia durante el entrenamiento.

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

Definir diferentes estrategias de aprendizaje

A continuación, necesitamos definir las diferentes estrategias de aprendizaje que queremos comparar. Definiremos varios diferentes planes de tasa de aprendizaje y parámetros de impulso, incluyendo tasa de aprendizaje constante, constante con impulso, constante con impulso de Nesterov, tasa de aprendizaje de escalado inverso, escalado inverso con impulso, escalado inverso con impulso de Nesterov y adam. También definiremos etiquetas y argumentos de trazado para usarlos en nuestro trazado más adelante.

## diferentes planes de tasa de aprendizaje y parámetros de impulso
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 = [
    "tasa de aprendizaje constante",
    "constante con impulso",
    "constante con impulso de Nesterov",
    "tasa de aprendizaje de escalado inverso",
    "escalado inverso con impulso",
    "escalado inverso con impulso de Nesterov",
    "adam",
]

plot_args = [
    {"c": "rojo", "linestyle": "-"},
    {"c": "verde", "linestyle": "-"},
    {"c": "azul", "linestyle": "-"},
    {"c": "rojo", "linestyle": "--"},
    {"c": "verde", "linestyle": "--"},
    {"c": "azul", "linestyle": "--"},
    {"c": "negro", "linestyle": "-"},
]

Definir una función para trazar las curvas de aprendizaje

A continuación, necesitamos definir una función que trazará las curvas de aprendizaje para cada estrategia de aprendizaje en cada conjunto de datos. La función recibe el conjunto de datos (X, y), un eje para trazar y un nombre para el conjunto de datos. Usaremos MinMaxScaler para escalar los datos y MLPClassifier para entrenar la red neuronal. Entrenaremos la red usando cada estrategia de aprendizaje, ignorando las advertencias de convergencia, y trazaremos las curvas de aprendizaje para cada estrategia en la misma gráfica.

def plot_on_dataset(X, y, ax, name):
    ## para cada conjunto de datos, trazar el aprendizaje para cada estrategia de aprendizaje
    print("\naprendiendo en el conjunto de datos %s" % name)
    ax.set_title(name)

    X = MinMaxScaler().fit_transform(X)
    mlps = []
    if name == "digits":
        ## digits es más grande pero converge bastante rápidamente
        max_iter = 15
    else:
        max_iter = 400

    for label, param in zip(labels, params):
        print("entrenando: %s" % label)
        mlp = MLPClassifier(random_state=0, max_iter=max_iter, **param)

        ## algunas combinaciones de parámetros no convergerán como se puede ver en
        ## las gráficas, por lo que se ignoran aquí
        with warnings.catch_warnings():
            warnings.filterwarnings(
                "ignore", category=ConvergenceWarning, module="sklearn"
            )
            mlp.fit(X, y)

        mlps.append(mlp)
        print("Puntuación del conjunto de entrenamiento: %f" % mlp.score(X, y))
        print("Pérdida del conjunto de entrenamiento: %f" % mlp.loss_)
    for mlp, label, args in zip(mlps, labels, plot_args):
        ax.plot(mlp.loss_curve_, label=label, **args)

Cargar o generar conjuntos de datos pequeños

Ahora, necesitamos cargar o generar los conjuntos de datos pequeños que usaremos para este ejemplo. Usaremos el conjunto de datos iris, el conjunto de datos digits y dos conjuntos de datos generados usando las funciones make_circles y 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),
]

Trazar las curvas de aprendizaje para cada conjunto de datos

Finalmente, podemos trazar las curvas de aprendizaje para cada conjunto de datos usando la función plot_on_dataset. Crearemos una gráfica de 2x2 y trazaremos cada conjunto de datos en un eje separado.

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()

Resumen

En este laboratorio, usamos el MLPClassifier de Scikit-learn para comparar el rendimiento de diferentes estrategias de aprendizaje estocástico, incluyendo SGD y Adam, en varios conjuntos de datos pequeños. Definimos diferentes planes de tasa de aprendizaje y parámetros de impulso, y luego entrenamos el MLPClassifier usando cada estrategia. Trazamos las curvas de aprendizaje para cada estrategia en cada conjunto de datos y observamos cómo diferentes estrategias pueden afectar las curvas de pérdida de entrenamiento. Demostramos la importancia de elegir la estrategia de aprendizaje adecuada para el conjunto de datos y la tarea en cuestión.