Comparación de solvers en línea para la clasificación de dígitos manuscritos

Introducción

En este laboratorio, compararemos el rendimiento de diferentes solvers en línea para la clasificación de dígitos manuscritos. Utilizaremos la biblioteca scikit-learn para cargar y preprocesar los datos, así como para entrenar y probar los clasificadores. El objetivo es observar cómo se comportan diferentes solvers con diferentes proporciones de datos de entrenamiento.

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.

Cargar y preprocesar los datos

Comenzaremos cargando el conjunto de datos de dígitos manuscritos de scikit-learn y dividiéndolo en conjuntos de entrenamiento y prueba. También escalaremos los datos para que tengan media cero y varianza unitaria.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

## Cargar el conjunto de datos de dígitos
X, y = datasets.load_digits(return_X_y=True)

## Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Escalar los datos para que tengan media cero y varianza unitaria
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Definir los clasificadores

Definiremos varios solvers en línea para la clasificación, cada uno con diferentes hiperparámetros. Utilizaremos los siguientes clasificadores:

• SGDClassifier
• Perceptron
• PassiveAggressiveClassifier
• LogisticRegression

from sklearn.linear_model import SGDClassifier, Perceptron, PassiveAggressiveClassifier, LogisticRegression

classifiers = [
    ("SGD", SGDClassifier(max_iter=1000)),
    ("Perceptron", Perceptron(max_iter=1000)),
    ("Passive-Aggressive I", PassiveAggressiveClassifier(max_iter=1000, loss="hinge", C=1.0, tol=1e-4)),
    ("Passive-Aggressive II", PassiveAggressiveClassifier(max_iter=1000, loss="squared_hinge", C=1.0, tol=1e-4)),
    ("LogisticRegression", LogisticRegression(max_iter=1000))
]

Entrenar y evaluar los clasificadores

Entrenaremos cada clasificador con diferentes proporciones de los datos de entrenamiento, que van desde el 1% hasta el 95%, y evaluaremos su rendimiento en el conjunto de prueba. Repetiremos este proceso 10 veces para obtener una estimación más precisa de la tasa de error de prueba.

heldout = [0.01, 0.05, 0.25, 0.5, 0.75, 0.9, 0.95]
rounds = 10
xx = 1.0 - np.array(heldout)

for name, clf in classifiers:
    print("Training %s" % name)
    yy = []
    for i in heldout:
        yy_ = []
        for r in range(rounds):
            X_train_, X_test_, y_train_, y_test_ = train_test_split(X_train, y_train, test_size=i, random_state=r)
            clf.fit(X_train_, y_train_)
            y_pred = clf.predict(X_test_)
            yy_.append(1 - np.mean(y_pred == y_test_))
        yy.append(np.mean(yy_))
    plt.plot(xx, yy, label=name)

plt.legend(loc="upper right")
plt.xlabel("Proportion of training data")
plt.ylabel("Test error rate")
plt.show()

Interpretar los resultados

Podemos observar a partir de la gráfica que los clasificadores SGDClassifier, Perceptron y Passive-Aggressive se comportan de manera similar, con el clasificador Passive-Aggressive II teniendo un rendimiento ligeramente mejor. El clasificador LogisticRegression tiene el mejor rendimiento en general, con la tasa de error de prueba más baja para todas las proporciones de datos de entrenamiento.

Resumen

En este laboratorio, comparamos el rendimiento de diferentes solvers en línea para la clasificación de dígitos manuscritos. Observamos que el clasificador LogisticRegression tiene el mejor rendimiento en general, y que los clasificadores SGDClassifier, Perceptron y Passive-Aggressive se comportan de manera similar. Esta comparación puede ayudarnos a elegir el clasificador más adecuado para nuestro problema y conjunto de datos específicos.