Convolution

A convolução é a operação de deslizar uma pequena grelha de pesos, chamada kernel ou filtro, sobre uma entrada e calcular uma soma ponderada em cada posição. Em visão computacional (CV), a entrada é uma imagem ou uma pilha de mapas de características, e cada kernel produz um mapa de saída com valores elevados onde o seu padrão aparece: uma borda vertical, uma região de textura ou, mais profundamente numa rede, parte de uma roda ou de um rosto. Há muito que se usam kernels concebidos manualmente no processamento de imagens para desfocar, aumentar a nitidez e fazer a deteção de bordas. Numa rede neural convolucional (CNN), os valores do kernel são pesos do modelo aprendidos durante o treino, por isso a rede descobre os seus próprios detetores de características.

Como funciona a convolução#

Em cada posição, o kernel é colocado sobre uma região da entrada, cada peso do kernel é multiplicado pelo valor de entrada correspondente, e os produtos são somados, juntamente com um termo de viés, para gerar um valor de saída. Deslocar o kernel por toda a altura e largura produz um mapa de saída bidimensional. As entradas reais têm vários canais, como os canais vermelho, verde e azul de uma imagem, por isso cada kernel abrange todos os canais de entrada: um kernel de 3×3 numa entrada com 64 canais contém 3 × 3 × 64 = 576 pesos e continua a produzir um único canal de saída. Uma camada convolucional aplica muitos kernels desse tipo, e o número de kernels define o número de canais de saída; assim, uma camada que passa de 64 para 128 canais, com kernels de 3×3, tem 3 × 3 × 64 × 128 = 73.728 pesos.

O mesmo kernel é reutilizado em todas as posições, razão pela qual as camadas convolucionais precisam de muito menos parâmetros do que as camadas totalmente conectadas e por que um padrão aprendido num canto da imagem é reconhecido em qualquer outro lugar. Deslocar a entrada desloca a saída na mesma medida, uma propriedade chamada equivariância à translação. Cada valor de saída depende apenas de uma pequena região da entrada, e o empilhamento de camadas alarga o campo recetivo resumido por um valor de saída profundo, de alguns píxeis até à maior parte da imagem.

As bibliotecas de aprendizagem profunda calculam, na verdade, a correlação cruzada: a convolução matemática inverte o kernel antes de o deslizar, mas o Conv2d do PyTorch não o faz. Como o kernel é aprendido, a rede aprende simplesmente os pesos invertidos, e, na prática, as duas operações são intercambiáveis. As bibliotecas para GPU, como cuDNN, costumam reformular a convolução como uma grande multiplicação de matrizes ou usar algoritmos Winograd ou baseados em FFT, que calculam o mesmo resultado mais depressa do que deslizar literalmente o kernel.

Passo, preenchimento, dilatação e grupos#

Quatro hiperparâmetros controlam a forma da saída de uma convolução e o custo do seu cálculo:

• Passo (stride): A distância entre as posições do kernel. Um passo de 2 ignora uma posição em cada duas e reduz para metade a altura e a largura da saída, o que permite a muitas CNNs modernas reduzir a resolução.
• Preenchimento (padding): Valores adicionais, geralmente zeros, adicionados em redor da borda da entrada. Um preenchimento de 1 mantém a saída de uma convolução 3×3 do mesmo tamanho que a entrada quando o passo é 1.
• Dilatação: Afasta os elementos do kernel entre si; assim, um kernel 3×3 com dilatação 2 cobre uma área de 5×5 com os mesmos nove pesos, aumentando o campo recetivo sem custo adicional.
• Grupos: Divide os canais em grupos independentes. Com um grupo por canal, uma convolução em profundidade filtra cada canal separadamente, e uma convolução pontual 1×1 seguinte mistura os canais. Este par é chamado convolução separável em profundidade e foi popularizado pelos MobileNets para hardware móvel.

Para uma entrada de tamanho n, tamanho de kernel k, preenchimento p, passo s e dilatação d, o tamanho da saída é ⌊(n + 2p − d(k − 1) − 1) / s⌋ + 1. O trecho abaixo aplica quatro camadas, cada uma transformando um mapa de características de 64 canais e 80×80 em 128 canais:

import torch
from torch import nn

x = torch.randn(1, 64, 80, 80)  # a 64-channel, 80x80 feature map

# Four ways to map 64 input channels to 128 output channels
layers = {
    "standard 3x3": nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
    "stride 2": nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
    "dilation 2": nn.Conv2d(64, 128, kernel_size=3, padding=2, dilation=2, bias=False),
    "depthwise separable": nn.Sequential(
        nn.Conv2d(64, 64, kernel_size=3, padding=1, groups=64, bias=False),  # one 3x3 filter per channel
        nn.Conv2d(64, 128, kernel_size=1, bias=False),  # 1x1 convolution mixes channels
    ),
}
for name, layer in layers.items():
    params = sum(p.numel() for p in layer.parameters())
    print(f"{name}: output {tuple(layer(x).shape)}, {params:,} weights")

A camada padrão produz uma saída (1, 128, 80, 80) com 73.728 pesos. O passo 2 reduz a saída para (1, 128, 40, 40) com os mesmos pesos, e a dilatação 2 mantém as dimensões 80×80 e os 73.728 pesos, enquanto cada saída abrange uma área de 5×5. O par separável em profundidade produz a mesma saída (1, 128, 80, 80) com apenas 8.768 pesos, cerca de 8,4 vezes menos. O YOLO26 usa as duas ideias: cinco convoluções 3×3 com passo 2 reduzem uma imagem de 640×640 à grelha de 20×20 do mapa de características mais profundo do seu backbone, e o ramo de classificação da sua cabeça de deteção combina convoluções 3×3 em profundidade e 1×1 pontuais para reduzir o cálculo.

Convolução noutras dimensões#

• Convolução 1D: Desliza ao longo de um único eixo, para formas de onda de áudio, sinais de sensores e séries temporais.
• Convolução 3D: Acrescenta um eixo de profundidade ou temporal, para clipes de vídeo e exames volumétricos, como CT e MRI, na análise de imagens médicas.
• Convolução transposta: Distribui cada valor de entrada por uma saída maior, aumentando a resolução dos mapas de características em modelos de segmentação como o U-Net. Recupera o tamanho espacial reduzido por uma convolução com passo, usando os seus próprios pesos aprendidos.

Convolução em comparação com operações relacionadas#

• Camada totalmente conectada: Liga cada entrada a cada saída com um peso próprio. Uma convolução é uma camada totalmente conectada restrita a regiões locais, com pesos partilhados entre posições.
• Pooling: Desliza uma janela como a convolução, mas aplica uma regra fixa, como escolher o valor máximo, sem pesos aprendidos.
• Autoatenção: Calcula pesos dependentes dos dados entre cada par de posições, relacionando partes distantes de uma imagem numa única camada. Uma convolução aplica o mesmo kernel fixo em todo o lado e só vê uma janela local, o que mantém o seu custo linear em relação ao número de píxeis.
• Filtragem de imagens: Os filtros clássicos, como o desfoque gaussiano e o detetor de bordas Sobel, são convoluções com kernels fixos, concebidos manualmente. O filter2D do OpenCV também calcula correlações, tal como as bibliotecas de aprendizagem profunda; inverter o kernel transforma essa operação numa convolução verdadeira.