Regularización del Perceptrón Multicapa

Introducción

Esta práctica demuestra cómo utilizar la regularización en la red neuronal multicapa (MLP, por sus siglas en inglés) para combatir el sobreajuste. Compararemos diferentes valores para el parámetro de regularización, alfa, y observaremos cómo cambian las funciones de decisión.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga 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 tenga 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 tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias para esta práctica. Utilizaremos scikit-learn para crear conjuntos de datos sintéticos, MLPClassifier para construir el modelo MLP, StandardScaler para estandarizar los datos y make_pipeline para crear una tubería de transformaciones y clasificador.

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

Definir alfas

Definiremos diferentes valores para el parámetro de regularización, alfa. Utilizaremos np.logspace para generar 5 valores espaciados logarítmicamente entre 0,1 y 10.

alphas = np.logspace(-1, 1, 5)

Crear clasificadores

Crearemos clasificadores MLP para cada valor de alfa. Crearemos una tubería que incluya StandardScaler para estandarizar los datos y MLPClassifier con diferentes valores de alfa. Estableceremos el resolutor en 'lbfgs', que es un optimizador de la familia de los métodos quasi-Newton. Estableceremos max_iter en 2000 y early_stopping en True para evitar el sobreajuste. Utilizaremos dos capas ocultas con 10 neuronas cada una.

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}")

Crear conjuntos de datos

Crearemos tres conjuntos de datos sintéticos utilizando las funciones make_classification, make_moons y make_circles de scikit-learn. Dividiremos cada conjunto de datos en conjuntos de entrenamiento y prueba utilizando 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
## iterate over datasets
for X, y in datasets:
    ## split into training and test part
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.4, random_state=42
    )

Graficar los conjuntos de datos

Graficaremos cada conjunto de datos y colorearemos los puntos de entrenamiento y prueba de manera diferente.

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

    ## just plot the dataset first
    cm = plt.cm.RdBu
    cm_bright = ListedColormap(["#FF0000", "#0000FF"])
    ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
    ## Plot the training points
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
    ## and testing points
    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

Ajustar los clasificadores y graficar los límites de decisión

Ajustaremos cada clasificador en cada conjunto de datos y graficaremos los límites de decisión. Utilizaremos contourf para graficar el límite de decisión y scatter para graficar los puntos de entrenamiento y prueba. También mostraremos la puntuación de precisión en cada gráfica.

    ## iterate over classifiers
    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)

        ## Plot the decision boundary. For that, we will assign a color to each
        ## point in the mesh [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]

        ## Put the result into a color plot
        Z = Z.reshape(xx.shape)
        ax.contourf(xx, yy, Z, cmap=cm, alpha=0.8)

        ## Plot also the training points
        ax.scatter(
            X_train[:, 0],
            X_train[:, 1],
            c=y_train,
            cmap=cm_bright,
            edgecolors="black",
            s=25,
        )
        ## and testing points
        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

Mostrar los gráficos

Finalmente, ajustaremos el diseño de los subgráficos y mostraremos los gráficos.

figure.subplots_adjust(left=0.02, right=0.98)
plt.show()

Resumen

En este laboratorio, aprendimos cómo utilizar la regularización en el perceptrón multicapa para combatir el sobreajuste. Comparamos diferentes valores del parámetro de regularización, alfa, y observamos cómo cambiaban las funciones de decisión. También aprendimos cómo crear conjuntos de datos sintéticos, estandarizar los datos, crear clasificadores MLP y graficar los límites de decisión.