Redes convolucionais
Aplique filtros treináveis a imagens, combine os resultados e construa redes convolucionais.
- 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 XPDeslize 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.
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
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)[[ 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 , kernel , preenchimento e passo :
- Padding adiciona uma borda de zeros; com (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 , saídas e kernels K×K possui parâmetros – 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 XPAgrupamento 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.
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.
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.
Escreva uma convolução
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
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.
Trace as formas de uma CNN
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
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…