Carregando
0xF0Lição 16 de 17

Aprendizado profundo com PyTorch

Mapeie tudo o que você construiu manualmente no PyTorch: tensores, autograd, módulos, otimizadores, carregadores de dados e ajuste fino.

30 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Traduza tensores numpy, seu mecanismo de autogradação e seu loop de treinamento para PyTorch
  • Defina modelos com nn.Module, treine-os com um otimizador e alterne entre os modos de treinamento e avaliação
  • Use GPUs, salve e carregue pesos e ajuste um modelo pré-treinado

Você construiu um aprendizado profundo do zero. Em projetos reais, você usa uma estrutura - geralmente PyTorch - que fornece as mesmas peças, rapidamente e em GPUs. A boa notícia: você já entende cada um deles.

Você construiuPyTorch
matrizes numpytorch.tensor (mesmo broadcasting, @, .shape)
o mecanismo de autogradação Valuerequires_grad=True e loss.backward()
Camadas x @ W + bnn.Linear, nn.Conv2d, nn.LSTM, nn.MultiheadAttention
ReLU, softmax + entropia cruzadann.ReLU, nn.CrossEntropyLoss (leva logits!)
SGD, impulso, atualizações de Adamtorch.optim.SGD, torch.optim.AdamW
dropout, norma da camadann.Dropout, nn.LayerNorm
minilotes embaralhadosDataLoader(dataset, batch_size=32, shuffle=True)

PyTorch não pode ser executado neste navegador, portanto, os exemplos desta lição não podem ser executados aqui - instale-o com pip install torch e experimente-os. Cada saída mostrada foi verificada em relação ao PyTorch 2.9.

autograd_in_pytorch.py
1import torch
2
3w = torch.tensor(0.5, requires_grad=True)
4x, b, y = torch.tensor(2.0), torch.tensor(-1.0, requires_grad=True), torch.tensor(1.0)
5p = torch.sigmoid(w * x + b)
6loss = (p - y) ** 2
7loss.backward()                      # your Value.backward(), on tensors
8print(f"loss={loss.item():.4f} dw={w.grad.item():.4f} db={b.grad.item():.4f}")
Saída
loss=0.2500 dw=-0.5000 db=-0.2500

Esses são exatamente os números do neurônio sigmóide do backprop stepper. Agora o ciclo de treinamento - as mesmas quatro etapas que as suas, com zero_grad() fazendo a redefinição do gradiente, você mesmo teve que se lembrar:

train_xor_pytorch.py
1import torch
2from torch import nn
3
4torch.manual_seed(0)
5X = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
6y = torch.tensor([0, 1, 1, 0])
7
8model = nn.Sequential(nn.Linear(2, 8), nn.Tanh(), nn.Linear(8, 2))
9loss_fn = nn.CrossEntropyLoss()                      # takes logits
10optimizer = torch.optim.Adam(model.parameters(), lr=0.05)
11
12model.train()
13for epoch in range(300):
14    optimizer.zero_grad()            # reset gradients
15    loss = loss_fn(model(X), y)      # forward + loss
16    loss.backward()                  # backward
17    optimizer.step()                 # update
18
19model.eval()
20with torch.no_grad():                # no graph needed for predictions
21    predictions = model(X).argmax(dim=1)
22print("predictions:", predictions.tolist(), f"loss: {loss.item():.3f}")
23print("parameters:", sum(p.numel() for p in model.parameters()))
Saída
predictions: [0, 1, 1, 0] loss: 0.000
parameters: 42

Para qualquer coisa maior do que nn.Sequential pode expressar, escreva uma classe:

1class DoodleNet(nn.Module):
2    def __init__(self):
3        super().__init__()
4        self.features = nn.Sequential(
5            nn.Conv2d(1, 16, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
6            nn.Conv2d(16, 32, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2))
7        self.classifier = nn.Sequential(nn.Flatten(), nn.Dropout(0.3), nn.Linear(32 * 7 * 7, 10))
8
9    def forward(self, x):            # x: (batch, 1, 28, 28)
10        return self.classifier(self.features(x))

E os fundamentos práticos:

  • GPU: device = "cuda" if torch.cuda.is_available() else "cpu", depois model.to(device) e batch.to(device).
  • Modos: model.train() ativa o comportamento de dropout e treinamento de norma em lote; model.eval() os desativa. Envolva a avaliação em torch.no_grad() para economizar memória.
  • Salvando: torch.save(model.state_dict(), "doodle.pt") e posterior model.load_state_dict(torch.load("doodle.pt")).
shapes_in_pytorch.py
1import torch
2from torch import nn
3
4features = nn.Sequential(
5    nn.Conv2d(1, 16, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
6    nn.Conv2d(16, 32, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2))
7batch = torch.zeros(8, 1, 28, 28)
8print(tuple(features(batch).shape))
9print(sum(p.numel() for p in features.parameters()))
Saída
(8, 32, 7, 7)
4800

Transferir aprendizagem

Treinar uma grande rede do zero requer enormes dados e computação. Normalmente você não faz isso: você começa com um modelo pré-treinado em um grande conjunto de dados (ImageNet para visão, texto da web para linguagem) e ajusta-o em sua tarefa. Os detectores de borda, textura e gramática das primeiras camadas transferem notavelmente bem.

1from torchvision import models
2model = models.resnet18(weights="IMAGENET1K_V1")      # pré-treinado
3for parameter in model.parameters():
4    parameter.requires_grad = False                    # congela todos os parâmetros...
5model.fc = nn.Linear(model.fc.in_features, 4)         # ...e cria uma nova camada de saída para 4 classes de rabiscos
6optimizer = torch.optim.AdamW(model.fc.parameters(), lr=1e-3)

Com um pouco mais de dados, descongele também as camadas posteriores e ajuste-as com uma taxa de aprendizado menor. Hugging Face hospeda milhares de modelos pré-treinados para isso.

Principais conclusões

  • Tensores PyTorch são matrizes numpy com suporte automático e GPU; loss.backward() é o seu Value.backward().

  • Os modelos são nn.Modules; o loop é zero_grad → avanço → perda → retrocesso → passo.

  • Use model.train()/model.eval(), torch.no_grad() para inferência e .to(device) para GPUs.

  • Ajuste modelos pré-treinados: congele as camadas iniciais, substitua a cabeça, treine com uma pequena taxa de aprendizado.

Quiz da aula

7 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: escreva código em Python

Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.

Exercício 1

Conte os parâmetros de um modelo

+25 XP

Cada linha de entrada é uma camada abreviada no estilo PyTorch: Linear in out, Conv2d in out kernel, LayerNorm features, Embedding vocabulary dim ou uma camada sem parâmetros como ReLU, Dropout ou MaxPool2d. Imprima a contagem de parâmetros de cada camada e depois o total, correspondendo ao que sum(p.numel() for p in model.parameters()) reportaria:

Linear 784 128: 100480
ReLU: 0
total: 100480

(LayerNorm tem uma escala aprendida e mudança por recurso; a incorporação tem um vetor por entrada de vocabulário e sem preconceitos.)

  • Um MLP
  • Uma pequena peça transformadora
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Orçamento de ajuste fino

+25 XP

A primeira linha de entrada lista os nomes das camadas a serem treinadas (o restante está congelado). Cada linha a seguir é layer_name parameter_count para um modelo pré-treinado. Imprima as contagens treináveis ​​e congeladas e a porcentagem treinável com 2 casas decimais: trainable 2052 of 11178564 (0.02%), frozen 11176512.

  • Somente cabeçote novo
  • Cabeça e último bloco
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…