Classificador de Dígitos Manuscritos com PyTorch | by VINICIUS MOREIRA | Apr, 2024

Neste artigo, vamos explorar a importância da importação de bibliotecas e como preparar e treinar uma rede neural para reconhecimento de dígitos utilizando a biblioteca PyTorch. Abordaremos desde a importação das bibliotecas necessárias até a definição do modelo de rede neural, a preparação dos dados, o treinamento do modelo e a validação dos resultados.

Se você quiser conferir o código enquanto seguimos este artigo, pode encontrá-lo aqui no GitHub.

Importação de Bibliotecas

A primeira etapa para começar a desenvolver qualquer projeto em Python é importar as bibliotecas necessárias. Para este projeto, vamos utilizar o NumPy, PyTorch, Matplotlib e torchvision. Aqui está como fazemos a importação dessas bibliotecas:

import numpy as np
import torch
import torch.nn.helpful as F
import torchvision
import matplotlib.pyplot as plt
from time import time
from torchvision import datasets, transforms
from torch import nn, optim

Preparação dos Dados de Treinamento e Validação

Após a importação das bibliotecas, é importante preparar os dados que serão utilizados para treinar e validar o modelo. Neste exemplo, estamos utilizando o conjunto de dados MNIST, que consiste em imagens de dígitos manuscritos. Aqui está como preparamos os dados:

rework = transforms.ToTensor() #define conversão imagem
trainset = datasets.MNIST('./MNIST_data/', receive=True, apply=True, rework=rework) # carrega a parte do treino
trainload = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True) # cria buffer dos dados
valset = datasets.MNIST('./MNIST_data/', receive=True, apply=False, rework=rework) # carrega a validação
valloader = torch.utils.data.DataLoader(valset, batch_size=64, shuffle=True)# cria buffer

Definição do Modelo de Rede Neural

A próxima etapa é definir a arquitetura do modelo de rede neural que será utilizado para realizar o reconhecimento dos dígitos. Neste exemplo, vamos criar um modelo simples com duas camadas ocultas. Aqui está a definição do modelo:

class Modelo(nn.Module):
def __init__(self):
super(Modelo, self).__init__()
self.linear1 = nn.Linear(28*28, 128)
self.linear2 = nn.Linear(128, 64)
self.linear3 = nn.Linear(64, 10)
def forward(self, X):
X = F.relu(self.linear1(X))
X = F.relu(self.linear2(X))
X = self.linear3(X)
return F.log_softmax(X, dim=1)

Treinamento do Modelo

Após a definição do modelo, é hora de treiná-lo utilizando os dados de treinamento que preparamos anteriormente. Aqui está como implementamos a função de treinamento do modelo:

def treino(modelo, trainloader, system):
otimizador = optim.SGD(modelo.parameters(), lr=0.01, momentum=0.5)
inicio = time()
criterio = nn.NLLLoss()
EPOCHS = 10
modelo.apply()
for epoch in range(EPOCHS):
perda_acumulada = 0
for imagens, etiquetas in trainloader:
imagens = imagens.view(imagens.kind[0], -1)
otimizador.zero_grad()
output = modelo(imagens.to(system))
perda_instantanea = criterio(output, etiquetas.to(system))
perda_instantanea.backward()
otimizador.step()
perda_acumulada += perda_instantanea.merchandise()
else:
print("Epoch {} - Perda resultante: {}".format(epoch+1, perda_acumulada/len(trainloader)))
print("nTempo de treino (em minutos) = ",(time()-inicio)/60)

Validação do Modelo

Por fim, após o treinamento do modelo, é importante validar sua effectivity utilizando os dados de validação que separamos anteriormente. Aqui está a implementação da função de validação do modelo:

def validacao(modelo, valloader, system):
conta_corretas, conta_todas = 0, 0
for imagens, etiquetas in valloader:
for i in range(len(etiquetas)):
img = imagens[i].view(1, 784)
with torch.no_grad():
logps = modelo(img.to(system))
ps = torch.exp(logps)
probab = guidelines(ps.cpu().numpy()[0])
etiqueta_pred = probab.index(max(probab))
etiqueta_certa = etiquetas.numpy()[i]
if(etiqueta_certa == etiqueta_pred):
conta_corretas += 1
conta_todas += 1
print("Entire de imagens testadas =", conta_todas)
print("nPrecisão do modelo = {}%".format(conta_corretas*100*conta_todas))

Instanciação do Modelo e Configuração do Dispositivo

Por fim, vamos instanciar o modelo que definimos anteriormente e configurar o dispositivo que será utilizado para o treinamento (CPU ou GPU, caso disponível):

modelo = Modelo()
system = torch.system("cuda" if torch.cuda.is_available() else "cpu")
modelo.to(system)

Com todas essas etapas concluídas, estamos prontos para treinar e validar nosso modelo de rede neural para reconhecimento de dígitos utilizando a biblioteca PyTorch.