PyTorch CNN Tutorial: Crie e treine redes neurais convolucionais em Python

As redes neurais convolucionais (CNNs) são a base da visão computacional moderna, permitindo aplicações como reconhecimento de imagens, detecção facial e carros autônomos. Essas redes são projetadas para extrair automaticamente padrões e recursos de imagens, o que as torna mais eficientes do que as técnicas tradicionais de aprendizado de máquina para tarefas visuais.

Neste tutorial, implementaremos uma CNN usando o PyTorch, uma estrutura de aprendizagem profunda que é fácil de usar e altamente eficiente para aplicações de pesquisa e produção.

Pré-requisitos: Aprendizagem profunda e PyTorch

Antes de entrar nos detalhes das CNNs, você deve estar familiarizado com o campo da aprendizagem profunda e com as bibliotecas Python que usaremos durante a configuração do nosso ambiente.

A aprendizagem profunda é um subconjunto da aprendizagem de máquina, em que a estrutura fundamental do modelo é uma rede de entradas, camadas ocultas e saídas. Essa rede pode ter uma ou várias camadas ocultas. A intuição original por trás da aprendizagem profunda era criar modelos inspirados na forma como o cérebro humano aprende: por meio de células interconectadas chamadas neurônios. É por isso que continuamos a chamar os modelos de aprendizagem profunda de redes "neurais". Essas estruturas de modelos em camadas exigem muito mais dados para aprender do que outros modelos de aprendizado supervisionado para derivar padrões de dados não estruturados. Normalmente, falamos de pelo menos centenas de milhares de pontos de dados.

Embora existam vários frameworks e pacotes para implementar algoritmos de aprendizagem profunda, vamos nos concentrar no PyTorch, um dos frameworks mais populares e bem mantidos. Além de ser usado por engenheiros de aprendizagem profunda no setor, o PyTorch é uma ferramenta favorita entre os pesquisadores. Muitos artigos de aprendizagem profunda são publicados usando o PyTorch. Ele foi projetado para ser intuitivo e fácil de usar, compartilhando muitos pontos em comum com a biblioteca NumPy do Python. 

Se você precisa de uma introdução a esses conceitos, considere a possibilidade de se inscrever no curso Aprendizagem profunda com PyTorch hoje mesmo. 

O que é uma rede neural convolucional (CNN)?

As redes neurais convolucionais, comumente chamadas de CNN ou ConvNet, são um tipo específico de rede neural profunda bem adequada para tarefas de visão computacional. A invenção das CNNs remonta à década de 1980. No entanto, eles só se tornaram populares na década de 2010, após os avanços na computação resultantes da implementação de unidades de processamento gráfico (GPUs). De fato, a rápida popularização das CNNs ajudou o campo das redes neurais a recuperar a proeminência, levando à chamada "terceira onda de redes neurais" que ainda estamos vivendo hoje.

As CNNs são inspiradas especificamente no córtex visual biológico. O córtex tem pequenas regiões de células que são sensíveis a áreas específicas do campo visual. Essa ideia foi ampliada por um experimento cativante realizado por Hubel e Wiesel em 1962. 

As CNNs tentam replicar esse recurso criando redes neurais complexas que são feitas de camadas diferentes e específicas para cada tarefa. As CNNs são chamadas de "feed-forward" porque as informações fluem diretamente pelo modelo. Não há conexões de feedback nas quais as saídas do modelo são realimentadas para ele mesmo, em comparação com outros modelos que usam técnicas como a retropropagação.

Em particular, uma CNN geralmente consiste nas seguintes camadas:

Camada convolucional

Esse é o primeiro bloco de construção de uma CNN. Como o nome sugere, a principal tarefa matemática realizada é chamada de convolução, que é a aplicação de uma função de janela deslizante a uma matriz de pixels que representa uma imagem. A função de deslizamento aplicada à matriz é chamada de kernel ou filtro. Na camada de convolução, vários filtros de tamanho igual são aplicados, e cada filtro é usado para reconhecer um padrão específico da imagem, como a curvatura dos dígitos, as bordas, a forma completa dos dígitos e muito mais. 

Função de ativação

Normalmente, uma função de ativação ReLU é aplicada após cada operação de convolução. Essa função ajuda a rede a aprender relações não lineares entre os recursos da imagem, tornando a rede mais robusta para identificar padrões diferentes. Isso também ajuda a atenuar os problemas de gradiente decrescente. 

Camada de pooling

O objetivo da camada de agrupamento é extrair os recursos mais significativos da matriz convoluta. Isso é feito por meio da aplicação de algumas operações de agregação, que reduzem a dimensão do mapa de recursos (matriz convoluta), reduzindo assim a memória usada durante o treinamento da rede.  O agrupamento também é relevante para atenuar o ajuste excessivo.

Camadas totalmente conectadas

Essas camadas estão na última camada da rede neural convolucional, e suas entradas correspondem à matriz unidimensional achatada gerada pela última camada de agrupamento. As funções de ativação ReLU são aplicadas a eles para obter a não linearidade. 

Arquitetura da rede neural de convolução. Fonte: DataCamp

Você pode ler uma explicação mais detalhada da matemática por trás das CNNs em nosso tutorial, Convolutional Neural Networks in Python.

Por que usar CNNs para classificação de imagens?

As redes neurais convolucionais têm sido uma das inovações mais influentes no campo da visão computacional. Eles tiveram um desempenho muito melhor do que os modelos tradicionais de aprendizado de máquina, como SVMs e árvores de decisão, e produziram resultados de última geração. 

Além disso, as camadas convolucionais conferem às CNNs suas características invariantes de tradução, capacitando-as a identificar e extrair padrões e recursos dos dados, independentemente das variações de posição, orientação, escala ou tradução.


As CNNs provaram ser bem-sucedidas em muitos estudos de caso e aplicações reais diferentes, como:

• Classificação de imagens, detecção de objetos, segmentação, reconhecimento facial;
• Carros autônomos que utilizam sistemas de visão baseados em CNN;
• Classificação da estrutura cristalina usando uma rede neural convolucional;
• Sistemas de câmeras de segurança.

Além das tarefas de classificação de imagens, as CNNs são versáteis e podem ser aplicadas a uma série de outros domínios, como processamento de linguagem natural, análise de séries temporais e reconhecimento de fala.

Implementando uma CNN com o PyTorch

Agora que você já conhece a teoria das CNNs, estamos prontos para colocar a mão na massa. Nesta seção, criaremos e treinaremos uma CNN simples com o PyTorch. Nosso objetivo é criar um modelo para classificar dígitos em imagens. Para treinar e testar nosso modelo, usaremos o famoso conjunto de dados MNIST, uma coleção de 70.000 imagens em escala de cinza, 28x28, com dígitos escritos à mão.

1. Importação das bibliotecas necessárias

Abaixo você encontra as bibliotecas que usaremos neste tutorial. Basicamente, usaremos o PyTorch para criar nossa CNN e o módulo de visão computacional do PyTorch torchvision para fazer download e carregar o conjunto de dados MNIST. Por fim, também usaremos o site torchmetrics para avaliar o desempenho do nosso modelo.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. Carregamento e pré-processamento do conjunto de dados

O PyTorch também vem com um rico ecossistema de ferramentas e extensões, incluindo o torchvision, um módulo para visão computacional. O Torchvision inclui vários conjuntos de dados de imagens que podem ser usados para treinar e testar redes neurais. Em nosso tutorial, usaremos o conjunto de dados MNIST. 

Primeiro, faremos o download e converteremos o conjunto de dados MNIST em um tensor, a estrutura de dados principal do PyTorch, semelhante às matrizes do NumPy, mas com recursos de aceleração de GPU.

Em seguida, também usaremos o DataLoader para lidar com o agrupamento e o embaralhamento dos conjuntos de dados de treinamento e teste. Um PyTorch DataLoader pode ser criado a partir de um Dataset para carregar dados, dividi-los em lotes e realizar transformações nos dados, se desejado. Em seguida, ele produz uma amostra de dados pronta para treinamento. No código abaixo, carregamos os dados e os salvamos em DataLoaders com um tamanho de lote de 60 imagens:

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

Opcionalmente, o conjunto de dados de treinamento pode ser dividido em duas partições de treinamento e validação. A validação é uma técnica usada na aprendizagem profunda para avaliar o desempenho do modelo durante o treinamento. Ele ajuda a detectar possíveis superajustes e subajustes de nossos modelos, e é particularmente útil para otimizar os hiperparâmetros. No entanto, para simplificar, não usaremos a validação neste tutorial. Se quiser saber mais sobre validação, você pode conferir uma explicação completa em nosso curso Introdução à aprendizagem profunda com PyTorch.

Agora que temos nossos dados, vamos ver como fica um lote aleatório de dígitos:

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# get some random training images
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# show images
imshow(torchvision.utils.make_grid(images))

3. Definição da arquitetura da CNN

Para resolver o problema de classificação, usaremos a classe nn.Module, o bloco de construção do PyTorch para criar intuitivamente arquiteturas de rede neural sofisticadas. 

No código abaixo, criamos uma classe chamada CNN, que herda as propriedades da classe nn.Module. A classe CNN será o modelo de uma CNN com duas camadas convolucionais, seguidas de uma camada totalmente conectada. 

No PyTorch, usamos o endereço nn.Conv2d para definir uma camada convolucional. Passamos a ele o número de mapas de recursos de entrada e saída. Também definimos alguns dos parâmetros para que a camada convolucional funcione, incluindo o tamanho do kernel ou do filtro e o preenchimento. 

Em seguida, adicionamos uma camada de pooling máximo com nn.MaxPool2d. ​Nela, deslizamos uma janela não sobreposta sobre a saída da camada convolucional anterior. Em cada posição, selecionamos o valor máximo da janela para passar adiante. Essa operação reduz as dimensões espaciais dos mapas de recursos, reduzindo o número de parâmetros e a complexidade computacional da rede. Por fim, adicionamos uma camada linear totalmente conectada. 

A função forward() define como as diferentes camadas são conectadas, adicionando várias funções de ativação ReLU após cada camada convolucional.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # 1st convolutional layer
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling layer
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2nd convolutional layer
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Fully connected layer
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # Apply first convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = F.relu(self.conv2(x))  # Apply second convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x

Depois de definir a classe CNN, podemos criar nosso modelo e movê-lo para o dispositivo onde ele será treinado e executado. 

As redes neurais, inclusive as CNNs, apresentam melhor desempenho quando executadas em GPUs, mas esse pode ser o caso do seu computador. Portanto, executaremos o modelo em uma GPU somente quando disponível; caso contrário, usaremos uma CPU comum.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. Treinamento do modelo CNN

Agora que temos nosso modelo, é hora de treiná-lo. Para isso, primeiro precisamos determinar como mediremos o desempenho do modelo. Como estamos lidando com um problema de classificação multiclasse, usaremos a função de perda de entropia cruzada, disponível no PyTorch como nn.CrossEntropyLoss. Também usaremos o Adam Optimizer, um dos algoritmos de otimização mais populares. 

# Define the loss function
criterion = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

Vamos iterar em dez épocas e lotes de treinamento para treinar o modelo e executar a sequência usual de etapas para cada lote, conforme mostrado abaixo.

num_epochs=10
for epoch in range(num_epochs):
 # Iterate over training batches
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()

Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. Avaliação do modelo

Depois que o modelo é treinado, podemos avaliar seu desempenho no conjunto de dados de teste. Usaremos a precisão, uma métrica popular para problemas de classificação. A precisão mede a proporção de casos classificados corretamente em relação ao número total de objetos no conjunto de dados. Ele é calculado dividindo-se o número de previsões corretas pelo número total de previsões feitas pelo modelo. 

Primeiro, configuramos a métrica de precisão da torchmetrics. Em seguida, usamos o método .eval do modelo para colocá-lo no modo de avaliação, porque algumas camadas nos modelos PyTorch se comportam de forma diferente nos estágios de treinamento e teste. Também adicionamos um contexto Python com torch.no_grad, indicando que não realizaremos o cálculo do gradiente.

Em seguida, iteramos sobre exemplos de teste sem cálculo de gradiente. Para cada lote de teste, obtemos os resultados do modelo, pegamos a classe mais provável e a passamos para a função de precisão junto com os rótulos. Por fim, calculamos as métricas e imprimimos os resultados. Obtivemos uma pontuação de precisão de 0,98, o que significa que nosso modelo classificou corretamente 98% dos dígitos. Nada mal!

# Set up of multiclass accuracy metric
acc = Accuracy(task="multiclass",num_classes=10)

# Iterate over the dataset batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Get predicted probabilities for test data batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

#Compute total test accuracy
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Você também pode usar outras métricas de classificação populares, incluindo recall e precisão. Contamos a você tudo sobre essas métricas com exemplos práticos em nosso curso Intermediate Deep Learning with PyTorch.

Melhorando o desempenho do modelo

Embora nosso modelo CNN tenha alcançado um bom desempenho, há várias estratégias que podemos usar para aumentar ainda mais sua precisão, robustez e generalização para novos dados. 

Nesta seção, exploraremos técnicas importantes, como aumento de dados, ajuste de hiperparâmetros e aprendizagem por transferência para otimizar o desempenho do nosso modelo.

Técnicas de aumento de dados

O aumento de dados é uma técnica usada para melhorar a precisão do nosso modelo por meio da criação aleatória de novos dados de treinamento. Por exemplo, durante o carregamento, é possível aplicar transformações às imagens de treinamento, como redimensionamento, inversão horizontal ou vertical, rotação aleatória e assim por diante. Dessa forma, você pode criar imagens aumentadas e atribuir a elas o mesmo rótulo da imagem original, aumentando assim o tamanho do conjunto de treinamento.

A adição de transformações aleatórias às imagens originais nos permite gerar mais dados e, ao mesmo tempo, aumentar o tamanho e a diversidade do conjunto de treinamento. Isso torna o modelo mais resistente a variações e distorções comumente encontradas em imagens do mundo real e reduz o excesso de ajuste, pois o modelo aprende a ignorar as transformações aleatórias. 

No entanto, é importante ter cuidado com o aumento de dados, pois às vezes ele pode prejudicar o processo de treinamento. Por exemplo, em nosso problema, se aplicarmos a inversão vertical ao número "6", ele se parecerá com o número "9". Se você passá-lo para o modelo rotulado como "6", o modelo ficará confuso e dificultará o treinamento. Esses exemplos mostram que, às vezes, aumentos específicos podem afetar o rótulo.

Ajuste de hiperparâmetros

Outra estratégia para melhorar o desempenho do nosso modelo é alterar os valores dos hiperparâmetros envolvidos nas diferentes camadas do modelo. Esse ajuste de hiperparâmetros requer um profundo conhecimento da matemática por trás das redes neurais e do significado dos diferentes hiperparâmetros. 

Por exemplo, você pode ajustar as camadas da CNN alterando o tamanho dos filtros ou aumentando o preenchimento. Você também pode definir um valor diferente para os pesos iniciais dos neurônios. 

Como não saberemos de antemão os valores ideais dos hiperparâmetros, será necessário um certo grau de tentativa e erro. Isso normalmente é feito por meio de uma técnica conhecida como pesquisa de grade, que permite que você avalie sistematicamente um modelo em uma grade de valores de parâmetros. 

No entanto, tenha cuidado ao usar essa técnica, pois normalmente ela é cara do ponto de vista computacional, especialmente quando você lida com redes neurais complexas e grandes conjuntos de dados de treinamento.

Da mesma forma, você pode aumentar a complexidade do seu modelo adicionando mais camadas convolucionais e lineares. No entanto, tenha cuidado ao adicionar novas camadas, pois o número de neurônios pode aumentar drasticamente, resultando em tempos de treinamento mais longos e possíveis ajustes excessivos.

Você pode saber mais sobre o ajuste de hiperparâmetros em nosso curso Introdução à aprendizagem profunda com PyTorch.

Uso de modelos pré-treinados

O treinamento de modelos de aprendizagem profunda a partir do zero é um processo longo e tedioso e, normalmente, requer muitos dados de treinamento. Em vez disso, muitas vezes podemos usar modelos pré-treinados, ou seja, modelos que já foram treinados em alguma tarefa. 

Às vezes, podemos reutilizar diretamente um modelo pré-treinado se ele já puder resolver a tarefa que nos interessa. Em outras ocasiões, talvez seja necessário ajustar o modelo pré-treinado para se adequar à nova tarefa. Isso é conhecido como aprendizagem por transferência.

Usar modelos pré-treinados no PyTorch é bastante fácil. O Torchvision oferece uma coleção de modelos pré-treinados para várias tarefas relacionadas a imagens. Esses modelos são pré-treinados em conjuntos de dados de imagens em grande escala e estão facilmente disponíveis. Confira nosso curso Deep Learning for Images with PyTorch para aprender tudo o que você precisa saber sobre eles.

Implementação do modelo CNN

Depois de treinar seu modelo de classificação altamente preciso no PyTorch, agora você pode salvar o modelo e seus pesos pré-treinados para uso futuro e compartilhá-lo com sua equipe, certificando-se de que eles possam carregá-lo sem problemas.

Para salvar um modelo, podemos usar torch.save. Uma extensão de arquivo comum para modelos de tochas é pt ou pth. Para salvar os pesos do modelo, passamos model.state_dict para torch.save fornecendo o nome do arquivo de saída, por exemplo, MulticlassCNN.pth.

Para carregar um modelo salvo, inicializamos um novo modelo com a mesma arquitetura. Em seguida, usamos o método load state dict junto com torch.load para carregar os parâmetros do novo modelo.

# Save the model
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Create a new model
loaded_model = CNN(in_channels=1, num_classes=10)

# Load the saved model
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

Conclusão

Apresentamos uma visão geral completa das CNNs, fornecendo detalhes sobre cada camada da arquitetura da CNN. Além disso, fornecemos um guia sobre como implementar uma CNN no PyTorch, abrangendo as principais etapas, desde o carregamento de dados e o design do modelo até o treinamento e a avaliação do modelo. Por fim, também analisamos várias estratégias para melhorar o desempenho do nosso modelo. Aplicamos todos esses conjuntos de habilidades a um cenário do mundo real relacionado a uma tarefa de classificação multiclasse. 

Há muito o que aprender sobre aprendizagem profunda, sem dúvida um dos campos mais empolgantes e exigentes da IA. Felizmente, a DataCamp está aqui para ajudar. Confira nossos materiais e cursos dedicados e torne-se um especialista em redes neurais:

• Uma introdução às redes neurais convolucionais: Um guia abrangente para CNNs na aprendizagem profunda 
• Redes neurais convolucionais em Python com Keras
• Tutorial de redes neurais convolucionais (CNN) Python com TensorFlow
• Introdução às funções de ativação em redes neurais 
• Curso Master Deep Learning for Text com PyTorch
• Aprendizagem profunda em Python
• Como aprender a aprendizagem profunda em 2025: Um guia completo
• Curso intermediário de aprendizagem profunda com PyTorch
• Um guia para certificações e certificados do PyTorch