PyTorch na Prática: Deep Learning do Zero ao Primeiro Modelo

O que é o PyTorch?

O PyTorch é um framework de deep learning open-source desenvolvido pelo laboratório de IA do Facebook (Meta AI). Ele combina a flexibilidade de bibliotecas numéricas como NumPy com aceleração por GPU e um sistema de diferenciação automática chamado autograd. Diferente de outros frameworks que usam grafos computacionais estáticos, o PyTorch adota grafos dinâmicos — o que significa que você pode depurar o código linha por linha como faria com qualquer programa Python comum. Essa abordagem define-by-run tornou o PyTorch o framework mais popular entre pesquisadores e, cada vez mais, também na indústria.

Instalação e Primeiros Passos

A instalação é simples com o pip. No site oficial (pytorch.org) há um seletor que gera o comando exato para seu sistema operacional e configuração de CUDA:

pip install torch torchvision torchaudio

Com PyTorch instalado, seu primeiro passo é entender os tensores — a estrutura de dados fundamental do framework. Tensores são como arrays multidimensionais (similares aos do NumPy), mas com a capacidade de serem processados em GPUs:

import torch

# Criando um tensor 2x3
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(x.shape)  # torch.Size([2, 3])
print(x.dtype)  # torch.int64

# Movendo para GPU (se disponível)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
x_gpu = x.to(device)

Autograd: O Coração do Aprendizado

O sistema autograd é o que torna o PyTorch tão poderoso para deep learning. Ele registra automaticamente todas as operações realizadas em tensores e constrói um grafo computacional, permitindo calcular gradientes com uma única chamada de .backward():

x = torch.tensor([2.0], requires_grad=True)
y = x ** 2 + 3 * x + 1
y.backward()
print(x.grad)  # tensor([7.0]) — derivada de y em x=2

Isso elimina a necessidade de calcular derivadas manualmente — você define a arquitetura do modelo e a função de perda, e o PyTorch cuida de todo o cálculo dos gradientes para a retropropagação.

Construindo seu Primeiro Modelo: um Classificador de Imagens

Vamos construir uma rede neural simples para classificar dígitos escritos à mão usando o dataset MNIST, que vem integrado ao torchvision. Primeiro, carregamos e preparamos os dados:

from torch.utils.data import DataLoader
from torchvision import datasets, transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_dataset = datasets.MNIST(
    root='./data', train=True,
    download=True, transform=transform
)
train_loader = DataLoader(
    train_dataset, batch_size=64, shuffle=True
)

O DataLoader gerencia o carregamento em lotes, o embaralhamento e a paralelização — sem precisar escrever loops manuais. Agora definimos a arquitetura da rede:

import torch.nn as nn
import torch.nn.functional as F

class ClassificadorMNIST(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)          # Achata a imagem 28x28
        x = F.relu(self.fc1(x))         # Ativação ReLU
        x = F.relu(self.fc2(x))
        x = self.fc3(x)                 # Saída: 10 classes
        return x

Perceba que herdamos de nn.Module — a classe base para todos os modelos em PyTorch. O método forward define o fluxo dos dados, e a inicialização dos pesos é feita automaticamente.

O Loop de Treinamento

Diferente de frameworks de alto nível como Keras, no PyTorch você escreve o loop de treinamento explicitamente — o que dá controle total sobre cada etapa:

modelo = ClassificadorMNIST().to(device)
otimizador = torch.optim.SGD(modelo.parameters(), lr=0.01)
funcao_perda = nn.CrossEntropyLoss()

for epoca in range(5):
    for imagens, rotulos in train_loader:
        imagens, rotulos = imagens.to(device), rotulos.to(device)

        # Forward: calcula a saída e a perda
        saida = modelo(imagens)
        perda = funcao_perda(saida, rotulos)

        # Backward: calcula os gradientes
        otimizador.zero_grad()
        perda.backward()

        # Atualiza os pesos
        otimizador.step()

    print(f'Época {epoca+1}: perda = {perda.item():.4f}')

Cada época percorre todo o dataset em lotes. O padrão zero_grad → forward → backward → step é o ciclo fundamental de todo treinamento com PyTorch. Após 5 épocas, o modelo já atinge cerca de 97% de acurácia no MNIST — impressionante para uma rede tão simples!

Dicas Práticas para o Dia a Dia

Aqui estão alguns conselhos que economizam horas de debugging:

Sempre use model.train() e model.eval(): Algumas camadas (Dropout, BatchNorm) se comportam diferente durante treino e inferência. Alternar entre esses modos evita surpresas.
Gerencie a semente aleatória: torch.manual_seed(42) garante reprodutibilidade — essencial para debugging e experimentos.
Prefira with torch.no_grad(): na inferência: Desativa o cálculo de gradientes, reduzindo consumo de memória e acelerando a execução.
Use TensorBoard ou o próprio wandb: Visualizar as curvas de perda, acurácia e distribuição dos gradientes ajuda a diagnosticar problemas como overfitting ou gradientes explosivos.

Conclusão

PyTorch oferece o equilíbrio ideal entre flexibilidade e produtividade. Neste artigo, você aprendeu desde os conceitos fundamentais — tensores e autograd — até a implementação completa de um classificador de imagens funcional. O ecossistema PyTorch inclui ainda ferramentas como torchvision (visão computacional), torchtext (NLP) e PyTorch Lightning (que abstrai loops de treinamento para projetos maiores), além do Hugging Face Transformers, que roda sobre PyTorch e dá acesso a modelos como BERT, GPT e Llama com poucas linhas de código. Se você está começando em deep learning, PyTorch é sem dúvida a melhor escolha — e a comunidade ativa garante que você sempre encontrará suporte e exemplos para seguir em frente.

Entrar em contato

Entre em contato