Redes Neurais Convolucionais (CNN): convolução, filtros e invariâncias em visão

Por que convolução funciona tão bem em imagens

Imagens têm uma estrutura espacial: pixels vizinhos costumam estar relacionados (bordas, texturas, cantos). Em vez de conectar cada pixel a cada neurônio (como em camadas densas), uma CNN aplica uma operação local repetida pela imagem inteira para extrair padrões. Essa operação é a convolução, que pode ser entendida como um “detector de padrões” que varre a imagem.

A ideia central é: um pequeno conjunto de pesos (um filtro/kernel) é aplicado em várias regiões da imagem. Isso cria um mapa de ativação (feature map) que indica onde aquele padrão aparece com força.

Extração local de padrões

Em uma convolução 2D, o kernel olha apenas para uma vizinhança (por exemplo, 3×3) e calcula uma combinação ponderada dos pixels daquela janela. Isso favorece a detecção de padrões locais como bordas horizontais/verticais, texturas repetitivas e pequenos cantos.

Compartilhamento de pesos: menos parâmetros, melhor generalização

O mesmo kernel (mesmos pesos) é usado em todas as posições. Isso traz dois efeitos práticos:

• Redução drástica de parâmetros: um kernel 3×3 tem 9 pesos (ou 9×C em imagens com C canais), independentemente do tamanho da imagem. Em uma camada densa, o número de pesos cresce com largura×altura.
• Equivariança à translação: se um padrão se desloca na imagem, o mapa de ativação também se desloca de forma correspondente. Assim, a rede aprende “o que é” o padrão sem precisar reaprender “onde ele está”.

Componentes essenciais de uma camada convolucional

Filtros/Kernels

Um kernel é uma matriz pequena de pesos (ex.: 3×3). Cada kernel aprende um tipo de padrão. Uma camada convolucional geralmente possui vários kernels, gerando vários mapas de ativação (um por kernel).

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

Em imagens RGB, o kernel tem profundidade igual ao número de canais. Ex.: kernel 3×3 em RGB tem formato 3×3×3; ele combina informações dos três canais ao mesmo tempo.

Stride (passo)

Stride define de quantos pixels a janela do kernel “anda” a cada aplicação.

• Stride = 1: varredura mais detalhada, mapas maiores.
• Stride = 2: reduz a resolução do mapa (downsampling), economiza computação e pode aumentar invariância a pequenas variações, mas perde detalhe fino.

Padding (preenchimento)

Padding adiciona bordas (geralmente zeros) ao redor da imagem antes da convolução.

• Sem padding (“valid”): o mapa de ativação fica menor, porque o kernel não cabe nas bordas.
• Com padding (“same”): escolhe-se padding para manter (aproximadamente) a mesma largura/altura do mapa em relação à entrada quando stride=1.

Mapas de ativação (feature maps)

O resultado da convolução com um kernel é um mapa de ativação: uma matriz onde cada posição indica a resposta do kernel naquela região da imagem. Com vários kernels, obtemos uma pilha de mapas (um “volume” de features).

Exemplo prático: aplicando um kernel em uma imagem pequena

Vamos usar uma imagem em tons de cinza (um único canal) 4×4 e um kernel 2×2, com stride=1 e sem padding. Para simplificar, vamos calcular apenas a convolução (na prática, normalmente há uma não linearidade depois, mas aqui o foco é o mapa de ativação).

1) Defina a imagem (entrada) e o kernel

Imagem X (4x4):            Kernel K (2x2):
[ 1  2  0  1 ]             [ 1  0 ]
[ 3  1  2  2 ]             [ 0 -1 ]
[ 0  1  3  1 ]
[ 2  2  1  0 ]

Interpretação do kernel: ele compara diagonalmente (canto superior esquerdo com canto inferior direito), respondendo forte quando há contraste nessa direção.

2) Calcule a primeira posição do mapa (topo-esquerda)

Pegue a janela 2×2 da imagem no canto superior esquerdo:

Janela X(0:2,0:2) =
[ 1  2 ]
[ 3  1 ]

Multiplique elemento a elemento e some:

Saída(0,0) = 1*1 + 2*0 + 3*0 + 1*(-1)
          = 1 + 0 + 0 - 1
          = 0

3) Desloque a janela (stride=1) e repita

Agora a janela começa na coluna 1:

Janela X(0:2,1:3) =
[ 2  0 ]
[ 1  2 ]

Saída(0,1) = 2*1 + 0*0 + 1*0 + 2*(-1)
          = 2 - 2
          = 0

Próxima janela (coluna 2):

Janela X(0:2,2:4) =
[ 0  1 ]
[ 2  2 ]

Saída(0,2) = 0*1 + 1*0 + 2*0 + 2*(-1)
          = -2

4) Forme o mapa de ativação completo

Como a entrada é 4×4 e o kernel é 2×2, sem padding e com stride=1, o mapa terá tamanho (4-2+1)×(4-2+1) = 3×3.

Mapa de ativação A (3x3):
[  0   0  -2 ]
[  2  -2   1 ]
[ -2   0   2 ]

Leitura do mapa: valores altos (positivos ou negativos, dependendo do padrão do kernel) indicam regiões onde o padrão “bateu” forte. Se aplicarmos uma não linearidade que zere valores negativos (como ReLU), o mapa destacaria apenas evidências positivas do padrão.

5) E se usarmos padding ou stride maior?

• Padding: permitiria calcular respostas também nas bordas, mantendo mais informação espacial e controlando o tamanho do mapa.
• Stride maior: reduziria o tamanho do mapa, fazendo uma amostragem mais espaçada das respostas do kernel.

Pooling: reduzindo resolução e ganhando invariância

Pooling é uma operação que resume pequenas regiões do mapa de ativação, reduzindo a dimensão espacial. O mais comum é max pooling (pega o maior valor de cada janela), mas também existe average pooling.

Max pooling (exemplo conceitual)

Se aplicarmos max pooling 2×2 com stride=2 em um mapa, cada bloco 2×2 vira um único número: o máximo. Isso ajuda a:

• Diminuir custo computacional nas camadas seguintes.
• Aumentar invariância a pequenas translações: se uma ativação forte se desloca um pouco dentro da janela, o máximo tende a permanecer.

Observação importante: pooling não é obrigatório em arquiteturas modernas; muitas redes usam convoluções com stride para downsampling, mas o objetivo (reduzir resolução e aumentar robustez) é semelhante.

Hierarquia de features: de bordas a partes e objetos

Empilhando camadas convolucionais, a rede constrói uma hierarquia:

• Camadas iniciais: detectam padrões simples (bordas, gradientes, texturas).
• Camadas intermediárias: combinam padrões simples em formas maiores (cantos, curvas, padrões repetidos).
• Camadas profundas: representam composições mais abstratas (partes de objetos e configurações globais).

Essa composição funciona bem porque cada camada “enxerga” um campo receptivo efetivo maior: mesmo com kernels pequenos, várias camadas em sequência fazem a informação se combinar em regiões cada vez mais amplas da imagem.

Como CNNs são configuradas para classificação e detecção (visão conceitual)

Classificação de imagens

Em classificação, o objetivo é produzir uma probabilidade por classe para a imagem inteira. Um arranjo típico:

• Blocos convolucionais (Conv + não linearidade, possivelmente normalização) para extrair features.
• Downsampling (pooling ou conv com stride) para reduzir resolução e aumentar robustez.
• Agregação global: pode ser flatten seguido de camadas densas, ou global average pooling (média por canal) para transformar mapas em um vetor.
• Camada final que produz um score por classe (logits) a partir do vetor de features.

Intuição: as convoluções transformam a imagem em um conjunto de mapas que indicam “o que aparece e onde”; a agregação global transforma isso em “o que aparece na imagem” para decidir a classe.

Detecção de objetos

Em detecção, além de dizer quais classes existem, é preciso dizer onde (caixas delimitadoras). Conceitualmente, CNNs para detecção fazem:

• Backbone convolucional: extrai mapas de features em diferentes escalas (resoluções).
• Cabeças de predição sobre os mapas: para cada posição (ou para regiões propostas), a rede prevê classe e parâmetros de caixa (ex.: centro, largura, altura).
• Multi-escala: objetos pequenos e grandes são melhor tratados usando features em diferentes resoluções.

Intuição: a detecção explora o fato de que mapas de ativação preservam informação espacial. Em vez de colapsar tudo para um vetor cedo demais, a rede mantém uma grade de features para associar previsões a posições na imagem.