Carregando
0xC0Lição 13 de 17

Redes convolucionais

Aplique filtros treináveis a imagens, combine os resultados e construa redes convolucionais.

32 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Explique por que as convoluções são adequadas às imagens: padrões locais, pesos compartilhados
  • Calcule saídas de convolução e tamanhos de saída com preenchimento e passada
  • Descrever como as camadas de conversão, ativação e pooling se acumulam em uma CNN e contar seus parâmetros

Alimente uma foto colorida de 224×224 para uma camada totalmente conectada com 1.000 neurônios e você precisará de 150 milhões de pesos – para uma camada. Pior ainda, um gato no canto superior esquerdo e um gato no canto inferior direito seriam aprendidos separadamente.

Uma camada convolucional corrige ambos os problemas com um pequeno kernel (filtro), digamos 3×3, que desliza pela imagem. Em cada posição, ele calcula uma soma ponderada dos pixels abaixo dela. O mesmo kernel - os mesmos 9 pesos - é usado em todos os lugares (compartilhamento de peso), e cada saída analisa apenas uma pequena vizinhança (localidade). A saída é um mapa de recursos mostrando onde o padrão do kernel aparece.

Os kernels não são projetados manualmente: a rede os aprende por backprop, assim como qualquer outro peso. As primeiras camadas acabam com detectores de bordas e cores muito parecidos com os clássicos abaixo.

Experimente

Até 15 XP

Deslize um kernel

Escolha um kernel e clique em qualquer pixel de saída para ver a multiplicação por trás dele. Os kernels de borda acendem onde o brilho muda; observe que um detector de borda vertical ignora completamente as bordas horizontais.

Entrada (clique em um pixel da saída)
Kernel
Edite qualquer peso para criar seu próprio filtro.
Saída (laranja = negativo)

Saída na linha 6, coluna 6 = soma de (pixel × peso) na janela destacada 3×3 (pixels fora da imagem valem 0):

220×-1 + 220×0 + 220×1 + 20×-2 + 20×0 + 20×2 + 20×-1 + 20×0 + 220×1 = 200

conv2d.py
1import numpy as np
2
3def conv2d(image, kernel, stride=1, padding=0):
4    image = np.pad(image, padding)
5    k = kernel.shape[0]
6    out_size = (image.shape[0] - k) // stride + 1
7    out = np.zeros((out_size, out_size))
8    for i in range(out_size):
9        for j in range(out_size):
10            patch = image[i * stride:i * stride + k, j * stride:j * stride + k]
11            out[i, j] = np.sum(patch * kernel)
12    return out
13
14doodle = np.array([[0, 0, 1, 1, 0],
15                   [0, 0, 1, 1, 0],
16                   [0, 0, 1, 1, 0],
17                   [0, 0, 1, 1, 0],
18                   [0, 0, 1, 1, 0]], dtype=float)
19vertical_edges = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
20print(conv2d(doodle, vertical_edges))
21print(conv2d(doodle, vertical_edges, padding=1).shape, conv2d(doodle, vertical_edges, stride=2).shape)
Saída
[[ 4.  4. -4.]
 [ 4.  4. -4.]
 [ 4.  4. -4.]]
(5, 5) (2, 2)

Valores positivos marcam onde o doodle passa de escuro para claro (da esquerda para a direita), negativos onde ele volta. (Estritamente, a “convolução” do aprendizado profundo não inverte o kernel – os matemáticos chamam isso de correlação cruzada – mas como os kernels são aprendidos, isso não importa.)

Tamanho de saída. Para largura de entrada WW, kernel KK, preenchimento PP e passo SS:

Wout=⌊W−K+2PS⌋+1W_{out} = \left\lfloor \frac{W - K + 2P}{S} \right\rfloor + 1

  • Padding adiciona uma borda de zeros; com P=(K−1)/2P = (K-1)/2 (preenchimento “mesmo”) o tamanho é preservado.
  • Passada pula posições: a passada 2 praticamente divide cada dimensão pela metade.
  • Canais: imagens reais possuem 3 canais (RGB) e as camadas produzem muitos mapas de recursos. Um kernel abrange todos os canais de entrada, portanto, uma camada com entradas CinC_{in}, saídas CoutC_{out} e kernels K×K possui parâmetros K⋅K⋅Cin⋅Cout+CoutK \cdot K \cdot C_{in} \cdot C_{out} + C_{out} – minúsculos em comparação com uma camada densa.

Pooling e a receita da CNN

Pooling reduz os mapas de recursos resumindo pequenas janelas - geralmente ocupando o máximo de cada bloco 2×2 (pooling máximo). Isso torna a representação menor e um pouco tolerante a pequenas mudanças: o recurso estava em algum lugar naquela janela.

Experimente

Até 15 XP

Agrupamento máximo

Percorra a janela 2×2 no mapa de características com passo 2. Cada saída mantém apenas a resposta mais forte em sua janela.

Mapa de características: 6 × 6
Após o pooling (2×2, stride 2): 3 × 3 - clique em uma célula

max(1, 3, 4, 2) = 4

Uma CNN clássica repete conv → ReLU → pool algumas vezes, então os mapas de recursos ficam menores, mas mais numerosos (mais canais), e cada neurônio vê uma região maior da imagem original - seu campo receptivo cresce camada por camada. Depois nivela o resultado e finaliza com camadas densas para classificar. LeNet (1998) lê dígitos manuscritos desta forma; AlexNet, VGG e ResNet ampliaram a mesma receita.

Imagem de entrada32×32×3
Convoluçãomapas de bordas e texturas
Poolingreduz e mantém o maior valor
Convoluçãomapas de formas e partes
Vetorização + camada densacombina as características
Saída"gato" 92%
Imagem de entrada32×32×3Convoluçãomapas de bordas e texturasPoolingreduz e mantém o maior valorConvoluçãomapas de formas e partesVetorização + camada densacombina as característicasSaída"gato" 92%
Uma rede neural convolucional passa a imagem por filtros que transformam pixels gradualmente em uma decisão.

Principais conclusões

  • As convoluções deslizam núcleos pequenos, compartilhados e aprendidos sobre a entrada; cada saída vê apenas um patch local.

  • Largura de saída = ⌊(W − K + 2P)/S⌋ + 1; O “mesmo” preenchimento preserva o tamanho, o passo o reduz.

  • Uma camada conv possui parâmetros K·K·C_in·C_out + C_out - muito menos que uma camada densa.

  • CNNs empilham conv → ReLU → pool, aumentando os canais e campos receptivos e, em seguida, classificam.

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

Escreva uma convolução

+25 XP

A primeira linha de entrada é stride padding; as linhas restantes são uma imagem quadrada. Implemente conv2d(image, kernel, stride, padding) (sem inversão de kernel, preenchimento zero) e aplique o kernel de borda horizontal [[-1, -2, -1], [0, 0, 0], [1, 2, 1]]. Imprima a forma de saída e, em seguida, suas linhas com valores inteiros separados por espaços.

  • Uma barra horizontal
  • Acolchoado e pisado
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

Trace as formas de uma CNN

+25 XP

A primeira linha de entrada é o formato de entrada channels height width. Cada linha a seguir é uma camada: conv out_channels kernel stride padding, pool size (pool máximo com passada = tamanho) ou flatten. Imprima a forma após cada camada e a contagem de parâmetros dessa camada e, em seguida, o total:

1conv 16 3 1 1 -> (16, 32, 32) params 448
2pool 2 -> (16, 16, 16) params 0
3flatten -> (4096,) params 0
4total params 448
  • Uma pequena CNN
  • Estilo LeNet
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…