Noções Básicas de PyTorch

10 exemplos para você começar com Deep Learning - 7 básicos e 3 intermediários.

Pré-requisitos

uv venv && source .venv/bin/activate
uv pip install "torch>=2.6" "torchvision>=0.21"
python -c "import torch; print(torch.__version__, torch.cuda.is_available())"

• Python 3.14.0 com PyTorch 2.6+.
• GPU CUDA opcional, mas recomendada para treinamento (CPU funciona para exemplos pequenos).

Exemplos Básicos

1. Criar um Tensor

Tensors são a estrutura de dados principal do PyTorch - como arrays NumPy com suporte a GPU.

import torch
 
x = torch.tensor([1.0, 2.0, 3.0])
matrix = torch.zeros(3, 4)
rand = torch.randn(2, 3, generator=torch.Generator().manual_seed(42))
print(x.shape, x.dtype, x.device)

• torch.tensor cria a partir de listas Python; torch.zeros/randn alocam memória.
• .shape, .dtype e .device descrevem os metadados do tensor.
• Defina uma semente de gerador para tensores aleatórios reproduzíveis.

Relacionado: Autograd - tensores rastreiam gradientes

2. Operações de Tensor

Operações elemento a elemento e de matriz funcionam como no NumPy.

a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
print(a + b)
print(a @ b.T)  # multiplicação de matrizes
print(a.mean(dim=0))

• @ é multiplicação de matrizes; * é elemento a elemento.
• dim=0 reduz ao longo das linhas (médias das colunas).
• Broadcasting aplica tensores menores em tensores maiores automaticamente.

3. Mover Tensores para a GPU

Acelere a computação colocando tensores em dispositivos CUDA.

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(1000, 1000, device=device)
y = x @ x.T
print(y.device)

• Sempre crie ou mova tensores para o dispositivo de destino antes das operações.
• Misturar tensores de CPU e GPU gera erros - mantenha tudo em um único dispositivo.
• torch.cuda.is_available() retorna False em máquinas apenas com CPU.

Relacionado: GPUs & Mixed Precision - CUDA e autocast

4. Converter NumPy e PyTorch

Faça a ponte entre ecossistemas com zero cópia quando possível.

import numpy as np
 
np_arr = np.array([1.0, 2.0, 3.0])
tensor = torch.from_numpy(np_arr)
back = tensor.numpy()

• from_numpy compartilha memória com o array NumPy (alterações in-place afetam ambos).
• .numpy() requer um tensor de CPU e pode copiar se gradientes estiverem anexados.
• Use .detach().cpu().numpy() para tensores com requires_grad=True.

5. Indexação e Remodelagem

Selecione, fatie e remodele as dimensões do tensor.

x = torch.arange(12).reshape(3, 4)
print(x[1, 2])       # elemento único
print(x[:, 1])       # coluna
print(x.view(2, 6))  # remodelar (contíguo)
print(x.unsqueeze(0).shape)  # adicionar dimensão de batch: (1, 3, 4)

• reshape e view alteram a forma; view requer memória contígua.
• unsqueeze/squeeze adicionam/removem dimensões de tamanho 1.
• A dimensão do batch é tipicamente a primeira: (batch, channels, height, width).

6. Habilitar Rastreamento de Gradiente

Tensores que precisam de gradientes definem requires_grad=True.

w = torch.tensor([2.0, 3.0], requires_grad=True)
loss = (w ** 2).sum()
loss.backward()
print(w.grad)  # tensor([4., 6.])

• .backward() calcula gradientes via autograd.
• .grad contém o gradiente após o backward.
• Envolva parâmetros em nn.Parameter para treinamento de modelo.

Relacionado: Autograd - grafos de computação

7. Construir uma Camada com nn.Module

torch.nn fornece blocos de construção diferenciáveis.

import torch.nn as nn
 
layer = nn.Linear(10, 5)
x = torch.randn(32, 10)  # batch de 32
out = layer(x)
print(out.shape)  # (32, 5)
print(layer.weight.shape)  # (5, 10)

• nn.Linear aplica y = xW^T + b.
• A primeira dimensão é sempre o tamanho do batch.
• Camadas são chamáveis: layer(x) executa a computação forward.

Relacionado: Construindo Modelos com nn.Module - modelos completos

Exemplos Intermediários

8. Etapa de Treinamento Simples

Forward, loss, backward e etapa do otimizador manuais.

import torch.nn as nn
import torch.optim as optim
 
model = nn.Linear(10, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)
loss_fn = nn.MSELoss()
 
x = torch.randn(32, 10)
y = torch.randn(32, 1)
 
optimizer.zero_grad()
pred = model(x)
loss = loss_fn(pred, y)
loss.backward()
optimizer.step()
print(f"loss: {loss.item():.4f}")

• zero_grad() limpa gradientes anteriores antes de cada etapa.
• loss.item() extrai um float Python de um tensor escalar.
• Este é o loop interno de toda execução de treinamento.

Relacionado: Loops de Treinamento - loops de época completos

9. Salvar e Carregar Checkpoints de Tensor

Persista o estado do modelo para uso posterior.

import torch.nn as nn
 
model = nn.Linear(10, 1)
torch.save(model.state_dict(), "linear.pt")
loaded = nn.Linear(10, 1)
loaded.load_state_dict(torch.load("linear.pt", weights_only=True))
loaded.eval()

• state_dict() salva apenas os parâmetros treináveis.
• weights_only=True (PyTorch 2.6+) evita carregamento inseguro de pickle.
• Chame .eval() antes da inferência para desativar o comportamento de dropout.

Relacionado: Salvando, Carregando e Exportando - padrões completos de checkpoint

10. Compilar um Modelo com torch.compile

PyTorch 2.x pode otimizar modelos via JIT para execução mais rápida.

import torch
import torch.nn as nn
 
model = nn.Sequential(nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))
model = torch.compile(model)
x = torch.randn(64, 784)
out = model(x)  # a primeira chamada compila; chamadas subsequentes são mais rápidas
print(out.shape)

• torch.compile funde operações via TorchInductor.
• A primeira passagem forward tem sobrecarga de compilação.
• Melhores ganhos em GPU com inferência repetida ou loops de treinamento.

Versões do Stack: Esta página foi escrita para Python 3.14.0 (estável 3.14, manutenção 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ e uv 0.6+.