Classificar Dígitos Manuscritos com o Classificador MLP

Introdução

Este tutorial mostrará como criar um classificador MLPClassifier usando o Scikit-learn para classificar dígitos manuscritos do conjunto de dados MNIST. Também visualizaremos os pesos da primeira camada do MLP para obter insights sobre o comportamento de aprendizagem.

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 praticar.

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

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

Importar Bibliotecas

Começaremos importando as bibliotecas necessárias para este projeto.

import warnings
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_openml
from sklearn.exceptions import ConvergenceWarning
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split

Carregar Dados

Em seguida, carregaremos o conjunto de dados MNIST usando a função fetch_openml do Scikit-learn.

X, y = fetch_openml(
    "mnist_784", version=1, return_X_y=True, as_frame=False, parser="pandas"
)

Pré-processar Dados

Normalizaremos os dados dividindo o valor de cada pixel por 255.0, que é o valor máximo do pixel.

X = X / 255.0

Dividir Dados

Dividiremos o conjunto de dados em um conjunto de treinamento e um conjunto de teste usando a função train_test_split.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0, test_size=0.7)

Treinar MLPClassifier

Criaremos um classificador MLPClassifier com uma única camada oculta contendo 40 neurônios. Treinaremos o MLP por apenas 8 iterações devido a restrições de recursos. Também capturaremos o ConvergenceWarning que será lançado porque o modelo não convergirá dentro do número limitado de iterações.

mlp = MLPClassifier(
    hidden_layer_sizes=(40,),
    max_iter=8,
    alpha=1e-4,
    solver="sgd",
    verbose=10,
    random_state=1,
    learning_rate_init=0.2,
)

with warnings.catch_warnings():
    warnings.filterwarnings("ignore", category=ConvergenceWarning, module="sklearn")
    mlp.fit(X_train, y_train)

Avaliar o Modelo

Avaliaremos o MLPClassifier calculando sua precisão nos conjuntos de treinamento e teste.

print("Score do conjunto de treinamento: %f" % mlp.score(X_train, y_train))
print("Score do conjunto de teste: %f" % mlp.score(X_test, y_test))

Visualizar Pesos

Finalmente, visualizaremos os pesos da primeira camada do MLP. Criaremos uma grade de 4x4 de subplots e exibiremos cada peso como uma imagem em escala de cinza de 28x28 pixels.

fig, axes = plt.subplots(4, 4)
vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()
for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()):
    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=0.5 * vmin, vmax=0.5 * vmax)
    ax.set_xticks(())
    ax.set_yticks(())

plt.show()

Resumo

Neste tutorial, aprendemos a criar um classificador MLPClassifier usando o Scikit-learn para classificar dígitos manuscritos do conjunto de dados MNIST. Também visualizamos os pesos da primeira camada do MLP para obter insights sobre o comportamento de aprendizado.