Clasificación de dígitos con características de RBM

Introducción

Esta práctica se centra en el uso de la Máquina de Boltzmann Restringida de Bernoulli (RBM, por sus siglas en inglés) para la clasificación de dígitos manuscritos. El extractor de características RBM se combina con un clasificador de regresión logística para predecir los dígitos. El conjunto de datos utilizado es un conjunto de datos de imágenes en escala de grises donde los valores de los píxeles se pueden interpretar como grados de oscuridad sobre un fondo blanco.

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

Preparación de los datos

En este paso, preparamos los datos para el entrenamiento y la prueba. Utilizamos la función load_digits de sklearn.datasets para obtener el conjunto de datos. Luego, generamos artificialmente más datos etiquetados perturbando los datos de entrenamiento con desplazamientos lineales de 1 píxel en cada dirección. Escalamos los datos entre 0 y 1.

import numpy as np
from scipy.ndimage import convolve
from sklearn import datasets
from sklearn.preprocessing import minmax_scale
from sklearn.model_selection import train_test_split

def nudge_dataset(X, Y):
    """
    Esta función produce un conjunto de datos 5 veces más grande que el original,
    desplazando las imágenes de 8x8 en X 1 píxel hacia la izquierda, derecha, abajo o arriba
    """
    direction_vectors = [
        [[0, 1, 0], [0, 0, 0], [0, 0, 0]],
        [[0, 0, 0], [1, 0, 0], [0, 0, 0]],
        [[0, 0, 0], [0, 0, 1], [0, 0, 0]],
        [[0, 0, 0], [0, 0, 0], [0, 1, 0]],
    ]

    def shift(x, w):
        return convolve(x.reshape((8, 8)), mode="constant", weights=w).ravel()

    X = np.concatenate(
        [X] + [np.apply_along_axis(shift, 1, X, vector) for vector in direction_vectors]
    )
    Y = np.concatenate([Y for _ in range(5)], axis=0)
    return X, Y

X, y = datasets.load_digits(return_X_y=True)
X = np.asarray(X, "float32")
X, Y = nudge_dataset(X, y)
X = minmax_scale(X, feature_range=(0, 1))  ## 0-1 scaling

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)

Definición del modelo

En este paso, definimos el flujo de clasificación con un extractor de características BernoulliRBM y un clasificador de regresión logística. Utilizamos las clases BernoulliRBM y LogisticRegression de los módulos sklearn.neural_network y sklearn.linear_model respectivamente. Luego, creamos un objeto de tubo rbm_features_classifier para combinar los dos modelos.

from sklearn import linear_model
from sklearn.neural_network import BernoulliRBM
from sklearn.pipeline import Pipeline

logistic = linear_model.LogisticRegression(solver="newton-cg", tol=1)
rbm = BernoulliRBM(random_state=0, verbose=True)

rbm_features_classifier = Pipeline(steps=[("rbm", rbm), ("logistic", logistic)])

Entrenamiento

En este paso, entrenamos el modelo de tubo definido en el paso anterior. Establecemos los hiperparámetros del modelo (tasa de aprendizaje, tamaño de la capa oculta, regularización), y luego ajustamos los datos de entrenamiento al modelo.

from sklearn.base import clone

## Hiper-parámetros. Estos fueron establecidos por validación cruzada,
## utilizando un GridSearchCV. Aquí no estamos realizando validación cruzada para
## ahorrar tiempo.
rbm.learning_rate = 0.06
rbm.n_iter = 10

## Más componentes tienden a dar un mejor rendimiento de predicción, pero mayor
## tiempo de ajuste
rbm.n_components = 100
logistic.C = 6000

## Entrenamiento del Pipeline RBM-Logística
rbm_features_classifier.fit(X_train, Y_train)

Evaluación

En este paso, evaluamos el rendimiento del modelo en el conjunto de datos de prueba. Utilizamos la función classification_report del módulo sklearn.metrics para generar el informe de clasificación tanto para el modelo de tubo como para el modelo de regresión logística.

from sklearn import metrics

Y_pred = rbm_features_classifier.predict(X_test)
print(
    "Regresión logística utilizando características de RBM:\n%s\n"
    % (metrics.classification_report(Y_test, Y_pred))
)

## Entrenando el clasificador de regresión logística directamente en los píxeles
raw_pixel_classifier = clone(logistic)
raw_pixel_classifier.C = 100.0
raw_pixel_classifier.fit(X_train, Y_train)

Y_pred = raw_pixel_classifier.predict(X_test)
print(
    "Regresión logística utilizando características de píxeles brutos:\n%s\n"
    % (metrics.classification_report(Y_test, Y_pred))
)

Graficado

En este paso, graficamos los 100 componentes extraídos por la RBM. Utilizamos el módulo matplotlib.pyplot para graficar las imágenes.

import matplotlib.pyplot as plt

plt.figure(figsize=(4.2, 4))
for i, comp in enumerate(rbm.components_):
    plt.subplot(10, 10, i + 1)
    plt.imshow(comp.reshape((8, 8)), cmap=plt.cm.gray_r, interpolation="nearest")
    plt.xticks(())
    plt.yticks(())
plt.suptitle("100 componentes extraídos por RBM", fontsize=16)
plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)

plt.show()

Resumen

En este laboratorio, aprendimos cómo utilizar la Máquina de Boltzmann Restringida Bernoulli (RBM) con regresión logística para la clasificación de dígitos manuscritos. También aprendimos cómo evaluar el rendimiento del modelo utilizando el informe de clasificación y cómo graficar los componentes extraídos por la RBM.