Bruno Ferreira

Deep learning aprende representacoes em camadas:

A ideia central e ajustar parametros $𝜃$ para minimizar uma perda:

Notas rapidas:

• Dados viram tensores.
• O modelo produz predicoes.
• A loss mede o erro.
• O otimizador altera os pesos para reduzir a loss.
• Generalizar significa ir bem em dados nao vistos, nao apenas memorizar treino.

import torch

x = torch.randn(32, 10)      # batch com 32 exemplos e 10 atributos
y = torch.randint(0, 3, (32,))

print(x.shape, y.shape)

Um neuronio combina entrada, pesos e vies:

Depois aplica uma ativacao nao linear:

Sem nao linearidade, varias camadas viram apenas uma transformacao linear.

MLP:

Para classificacao multiclasse, usamos softmax:

Cross-entropy:

import torch
from torch import nn

model = nn.Sequential(
    nn.Linear(10, 64),
    nn.ReLU(),
    nn.Linear(64, 3)
)

x = torch.randn(32, 10)
y = torch.randint(0, 3, (32,))

logits = model(x)
loss = nn.CrossEntropyLoss()(logits, y)

loss.backward()
print(loss.item())

CNNs exploram estrutura espacial. Em vez de conectar tudo com tudo, filtros pequenos percorrem a imagem.

Convolucao 2D simplificada:

Intuicao:

• Filtros aprendem detectores locais: bordas, texturas, partes.
• O mesmo filtro e reutilizado em varias posicoes: compartilhamento de pesos.
• Isso reduz parametros e cria equivariancia a translacao.

Tamanho da saida em uma dimensao:

onde $𝐼$ e entrada, $𝑃$ padding, $𝐾$ kernel e $𝑆$ stride.

import torch
from torch import nn

cnn = nn.Sequential(
    nn.Conv2d(3, 16, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(16, 32, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d((1, 1)),
    nn.Flatten(),
    nn.Linear(32, 10)
)

x = torch.randn(8, 3, 64, 64)
logits = cnn(x)
print(logits.shape)  # torch.Size([8, 10])

Arquiteturas importantes:

• LeNet: CNN classica pequena para digitos.
• AlexNet: ReLU, GPU, dropout; marco em ImageNet.
• VGG: muitos filtros $3\times 3$, arquitetura simples e profunda.
• Inception/GoogLeNet: varios tamanhos de filtro em paralelo.
• ResNet: conexoes residuais facilitam redes muito profundas.

Bloco residual:

import torch
from torch import nn

class ResidualBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(channels, channels, 3, padding=1),
            nn.BatchNorm2d(channels),
            nn.ReLU(),
            nn.Conv2d(channels, channels, 3, padding=1),
            nn.BatchNorm2d(channels),
        )
        self.act = nn.ReLU()

    def forward(self, x):
        return self.act(self.net(x) + x)

Treinar e repetir:

1. forward: calcular $\widehat{𝑦}={𝑓}_{𝜃\left(𝑥\right)}$
2. loss: medir $\mathrm{ℒ︀}\left(\widehat{𝑦},𝑦\right)$
3. backward: calcular gradientes ${\nabla }_{𝜃}\mathrm{ℒ︀}$
4. update: alterar pesos

Atualizacao basica por gradiente descendente:

Mini-batch SGD aproxima o gradiente usando poucos exemplos:

Pontos praticos:

• Normalizar entradas ajuda a estabilizar treino.
• Inicializacao ruim pode matar gradientes.
• BatchNorm reduz sensibilidade a escala interna.
• Learning rate costuma importar mais que pequenos detalhes do modelo.

import torch
from torch import nn

model = nn.Sequential(nn.Linear(10, 64), nn.ReLU(), nn.Linear(64, 3))
opt = torch.optim.SGD(model.parameters(), lr=0.1)
loss_fn = nn.CrossEntropyLoss()

for step in range(100):
    x = torch.randn(32, 10)
    y = torch.randint(0, 3, (32,))

    opt.zero_grad()
    logits = model(x)
    loss = loss_fn(logits, y)
    loss.backward()
    opt.step()

Otimizacao pergunta: como reduzir a loss de treino?

Generalizacao pergunta: o modelo aprendeu padroes ou decorou?

Momentum suaviza atualizacoes:

Adam combina media de gradientes e de gradientes ao quadrado:

Regularizacao L2:

Dropout:

import torch
from torch import nn

model = nn.Sequential(
    nn.Linear(100, 256),
    nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(256, 10)
)

opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=50)

Checklist mental:

• loss de treino alta: underfitting, modelo fraco, LR ruim ou poucos epochs.
• treino bom e validacao ruim: overfitting.
• treino instavel: LR alto, dados mal escalados, batch pequeno ou inicializacao ruim.
• validacao melhorando: continue.
• validacao parou de melhorar: early stopping ou reduzir LR.

Segmentacao semantica classifica cada pixel.

Entrada:

Saida:

onde $𝐾$ e o numero de classes. Cada pixel recebe uma distribuicao sobre classes.

Loss por pixel:

IoU para uma classe:

Dice:

Arquiteturas comuns:

• FCN: troca camadas densas por convolucoes e gera mapa denso.
• U-Net: encoder comprime contexto, decoder recupera resolucao, skips preservam detalhe.
• DeepLab: convolucoes dilatadas aumentam campo receptivo sem perder tanta resolucao.

import torch
from torch import nn

class TinyUNet(nn.Module):
    def __init__(self, classes):
        super().__init__()
        self.enc = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(16, 16, 3, padding=1),
            nn.ReLU(),
        )
        self.pool = nn.MaxPool2d(2)
        self.dec = nn.Sequential(
            nn.ConvTranspose2d(16, 16, 2, stride=2),
            nn.ReLU(),
            nn.Conv2d(16, classes, 1)
        )

    def forward(self, x):
        h = self.enc(x)
        z = self.pool(h)
        return self.dec(z)

model = TinyUNet(classes=4)
x = torch.randn(2, 3, 128, 128)
y = torch.randint(0, 4, (2, 128, 128))

logits = model(x)
loss = nn.CrossEntropyLoss()(logits, y)
print(logits.shape, loss.item())