Construção e treinamento de CNNs com PyTorch
nn.Conv2d, nn.MaxPool2d, nn.Linear, ciclo de treinamento, otimizador, perda e acompanhamento da precisão.
Construção e treinamento de CNNs com PyTorch é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
Por que usar CNNs para imagens?
As redes neurais convolucionais aprendem padrões espaciais: bordas, texturas, depois formas e objetos. As convoluções compartilham pesos por toda a imagem, tornando as CNNs eficientes e capazes de reconhecer padrões independentemente de sua posição, além de serem a base da visão computacional.
import torch
import torch.nn as nnA classe base nn.Module
Os modelos herdam de nn.Module. Você define as camadas em __init__ e o fluxo de dados em forward. O PyTorch acompanha parâmetros e gradientes automaticamente.
class CNN(nn.Module):
def __init__(self):
super().__init__()Camadas de convolução
nn.Conv2d(in_channels, out_channels, kernel_size) desliza filtros treináveis pela imagem para produzir mapas de características. A primeira convolução recebe 3 canais (RGB) e produz mais canais que capturam características diferentes.
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)Camadas de agrupamento
nn.MaxPool2d reduz os mapas de características mantendo o maior valor em cada janela. Isso diminui o tamanho espacial, reduz o custo computacional e acrescenta um pouco de invariância à translação.
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)Camadas totalmente conectadas
Após as convoluções, achate as características e passe-as pelas camadas nn.Linear para produzir pontuações das classes. A camada Linear final produz um valor para cada classe.
self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.fc2 = nn.Linear(128, 10) # 10 classesO método forward
O método forward define como os dados fluem: convolução, ReLU, agrupamento, repetidamente; depois, achata os dados e os encaminha para as camadas lineares. F.relu adiciona a não linearidade que permite à rede aprender padrões complexos.
import torch.nn.functional as F
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(x.size(0), -1) # flatten
x = F.relu(self.fc1(x))
return self.fc2(x)Perda e otimizador
Para classificação, use CrossEntropyLoss. Um otimizador como Adam atualiza os pesos usando gradientes. Passe os parâmetros do modelo e uma taxa de aprendizagem.
model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)O ciclo de treinamento: zerando os gradientes
Cada etapa começa limpando os gradientes antigos com optimizer.zero_grad(). Se você ignorar isso, os gradientes se acumularão entre os lotes, corrompendo suas atualizações.
for images, labels in loader:
optimizer.zero_grad()Passagem direta e perda
Execute o lote no modelo para obter previsões e, em seguida, calcule a perda comparando as previsões com os rótulos verdadeiros. A perda é um único número que mede o quanto o modelo está errado.
outputs = model(images)
loss = criterion(outputs, labels)Retropropagação e atualização
loss.backward() calcula os gradientes por meio da diferenciação automática, e optimizer.step() ajusta os pesos para reduzir a perda. Juntos, eles formam uma etapa de aprendizagem.
loss.backward()
optimizer.step()Acompanhando a precisão
Acompanhe o progresso contando as previsões corretas. Use o argmax das saídas para obter as classes previstas, compare-as com os rótulos e divida o número de acertos pelo total.
preds = outputs.argmax(dim=1)
correct = (preds == labels).sum().item()
acc = correct / labels.size(0)
print("batch acc:", acc)Verificação rápida
Teste seu conhecimento sobre o ciclo de treinamento.
Recapitulação: construindo e treinando CNNs
Você criou uma CNN herdando de nn.Module, com camadas nn.Conv2d, nn.MaxPool2d e nn.Linear, além de um método forward. Treinou-a com o ciclo: zero_grad, passagem direta, loss.backward(), optimizer.step(), e acompanhou a precisão por meio de argmax.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 53
- Aulas
- 225
Perguntas Frequentes
A aula “Construção e treinamento de CNNs com PyTorch” é grátis?
Sim — o texto completo de “Construção e treinamento de CNNs com PyTorch” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “Construção e treinamento de CNNs com PyTorch”?
nn.Conv2d, nn.MaxPool2d, nn.Linear, ciclo de treinamento, otimizador, perda e acompanhamento da precisão. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Construção e treinamento de CNNs com PyTorch”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Tensores PyTorch e Autograd
- Conjuntos de dados e DataLoaders personalizados
- Construção e treinamento de CNNs com PyTorch
- Detecção de objetos com YOLOv8