Comparando Solucionadores Online para Classificação de Dígitos Manuscritos

Introdução

Neste laboratório, compararemos o desempenho de diferentes solucionadores online para a classificação de dígitos manuscritos. Utilizaremos a biblioteca scikit-learn para carregar e pré-processar os dados, bem como para treinar e testar os classificadores. O objetivo é observar como diferentes solucionadores se comportam sob diferentes proporções de dados de treino.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Às vezes, pode ser necessário esperar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar e pré-processar os dados

Começaremos carregando o conjunto de dados de dígitos manuscritos do scikit-learn e dividindo-o em conjuntos de treino e teste. Também escalaremos os dados para ter média zero e variância unitária.

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

## Carregar o conjunto de dados de dígitos
X, y = datasets.load_digits(return_X_y=True)

## Dividir os dados em conjuntos de treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Escalar os dados para ter média zero e variância unitária
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Definir os classificadores

Vamos definir vários solucionadores online para classificação, cada um com diferentes hiperparâmetros. Usaremos os seguintes classificadores:

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

Treinar e avaliar os classificadores

Treinaremos cada classificador em diferentes proporções dos dados de treino, variando de 1% a 95%, e avaliaremos seu desempenho no conjunto de teste. Repetimos este processo 10 vezes para obter uma estimativa mais precisa da taxa de erro de teste.

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("Treinando %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("Proporção dos dados de treino")
plt.ylabel("Taxa de erro de teste")
plt.show()

Interpretar os resultados

Podemos observar no gráfico que os classificadores SGDClassifier, Perceptron e Passive-Aggressive apresentam desempenhos semelhantes, sendo o classificador Passive-Aggressive II ligeiramente superior. O classificador LogisticRegression apresenta o melhor desempenho geral, com a menor taxa de erro de teste para todas as proporções de dados de treino.

Sumário

Neste laboratório, comparamos o desempenho de diferentes solucionadores online para a classificação de dígitos manuscritos. Observamos que o classificador LogisticRegression apresenta o melhor desempenho geral, e que os classificadores SGDClassifier, Perceptron e Passive-Aggressive apresentam desempenhos semelhantes. Esta comparação pode ajudar-nos a escolher o classificador mais apropriado para o nosso problema e conjunto de dados específicos.