10. Convolutional

Uma camada convolucional é uma camada densa à qual duas coisas foram proibidas: ela não pode ligar um pixel a um pixel distante e não pode usar um peso diferente em um lugar diferente. Nada é acrescentado. Capacidade é retirada, de propósito.

Essa é a ideia inteira e vale enunciá-la como uma afirmação sobre o mundo, não sobre código: em uma imagem, o que importa é local e significa a mesma coisa onde quer que apareça. Uma borda no canto superior esquerdo é o mesmo evento que uma borda no canto inferior direito. Uma camada densa não sabe disso e precisa aprender — separadamente, em cada posição, a partir de exemplos. A convolução recebe isso de graça.

O capítulo de deep learning chamou as arquiteturas de priors expressos como restrições sobre os pesos. Este capítulo é essa frase desenvolvida por completo para um caso, seguida da contabilidade honesta de 2026 sobre onde o prior ainda se paga.

A restrição, com o preço na etiqueta

Abaixo há um kernel 3×3 deslizando sobre uma entrada 9×9. Aperte play e observe o que de fato acontece: os mesmos nove números são lidos em cada posição e cada célula de saída é um produto escalar.

A linha embaixo do painel é o argumento. Nove pesos produzem o mapa de ativação inteiro; a camada densa que liga as mesmas entradas às mesmas saídas precisa de milhares — e, o que importa mais do que a contagem de parâmetros, ela teria de redescobrir o detector de bordas em cada posição, a partir de dados que ela não tem.

Dois botões mudam o formato da saída e os dois aparecem o tempo todo na prática:

• Passo (stride) \(s\) — o quanto a janela pula. \(s = 2\) reduz a resolução pela metade e é a forma mais barata de downsampling; é também como o campo receptivo consegue crescer geometricamente (próxima seção).
• Preenchimento (padding) \(p\) — zeros inventados em volta da borda, para que a saída preserve o tamanho da entrada. padding = (k-1)/2 com \(k\) ímpar é o padding "same" e é o padrão que você deve assumir.

x = torch.zeros(1, 3, 224, 224)
for name, layer in model.features.named_children():
    x = layer(x); print(f"{name:16s} {tuple(x.shape)}")

Equivariância é o que você ganha; invariância é o que você queria

O compartilhamento de pesos dá uma propriedade precisa e demonstrável: desloque a entrada e o mapa de ativação se desloca na mesma medida. Isso é equivariância à translação e é exatamente o certo para um detector de features.

Não é o que um classificador precisa. Um classificador precisa de invariância — "gato" independentemente de onde o gato esteja. Equivariância só vira invariância quando você colapsa os eixos espaciais e há duas formas honestas de fazer isso:

O campo receptivo é o orçamento de verdade

Uma unidade no fundo da pilha não vê a imagem. Ela vê o que a alimentou, recursivamente. Esse conjunto é seu campo receptivo e o crescimento dele é a restrição que moldou toda arquitetura convolucional já projetada.

Mexa nos controles e três fatos aparecem:

1. Com passo 1, o alcance cresce linearmente. Cada camada 3×3 soma 2. Atravessar uma imagem de 224 pixels levaria mais de cem camadas — e é por isso que nenhuma arquitetura é construída assim.
2. O passo é o que faz o alcance crescer geometricamente. Cada camada com passo 2 dobra o salto de todas as camadas acima dela. É isto — não o custo computacional — o motivo pelo qual CNNs fazem downsampling: é a única rota acessível ao contexto global.
3. A dilatação compra alcance sem pesos e sem downsampling, lendo com buracos. É por isso que convoluções dilatadas dominaram a segmentação semântica, onde se precisa de contexto e de resolução plena⁶.

A aritmética, num lugar só

Para entrada \(X \in \mathbb{R}^{B \times C_{in} \times H \times W}\) e kernel \(W \in \mathbb{R}^{C_{out} \times C_{in} \times k \times k}\):

A passagem reversa é a mesma operação três vezes — a razão pela qual convoluções são rápidas em hardware construído para um único kernel:

A rotação não é um truque: derivar \(Y = W \star X\) em relação a \(X\) troca os papéis dos dois argumentos e trocá-los inverte a ordem dos índices. A visão im2col, que transforma tudo isso numa única multiplicação de matrizes, está no CS231n¹¹.

A mesma conta, com números

Uma entrada 3×3, um kernel 2×2 e viés 1, com passo 1 e sem preenchimento:

Cada posição da saída é uma janela multiplicada termo a termo e somada. A primeira vale \(1{\cdot}1 + 2{\cdot}0 + 4{\cdot}(-1) + 5{\cdot}1 + 1 = 3\). As quatro juntas dão

Agora suponha que a perda devolva \(\partial L/\partial Y = \begin{bmatrix} 0{,}5 & -0{,}5 \\ 1 & 0 \end{bmatrix}\). As três derivadas da tabela, nesses números:

• Viés — soma tudo: \(0{,}5 - 0{,}5 + 1 + 0 = 1\).
• Kernel — correlaciona a entrada com o gradiente. A primeira entrada é \(0{,}5{\cdot}1 - 0{,}5{\cdot}2 + 1{\cdot}4 + 0{\cdot}5 = 3{,}5\) e a matriz inteira fica \(\begin{bmatrix} 3{,}5 & 4{,}5 \\ 6{,}5 & 7{,}5 \end{bmatrix}\).
• Entrada — convolução full do gradiente com o kernel: \(\begin{bmatrix} 0{,}5 & -0{,}5 & 0 \\ 0{,}5 & 1 & -0{,}5 \\ -1 & 1 & 0 \end{bmatrix}\).

Repare no formato: o gradiente da entrada é 3×3, do tamanho de \(X\), enquanto o que chegou era 2×2. Cada pixel participou de tantas janelas quanto o kernel o alcançou — o canto entrou em uma, o centro entrou em quatro — e a convolução full é justamente a conta que soma as contribuições de todas elas. É por isso que ela precisa de \(k-1\) de preenchimento de cada lado, não \(k-1\) no total.

"""A passagem reversa de uma convolução, com números, conferida por diferenças finitas.

As três derivadas são convoluções — é isso que a página afirma e é isso que o print mostra.
"""
import numpy as np
from scipy.signal import correlate2d, convolve2d

def forward(X, K, b):
    return correlate2d(X, K, mode="valid") + b        # correlação cruzada: é o que as bibliotecas chamam de conv

def backward(dY, X, K):
    dX = convolve2d(dY, K, mode="full")               # full: dY cresce k-1 de CADA lado
    dK = correlate2d(X, dY, mode="valid")
    db = dY.sum()
    return dX, dK, db

X = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]])
K = np.array([[1., 0.], [-1., 1.]])
b = 1.0
dY = np.array([[0.5, -0.5], [1.0, 0.0]])              # gradiente que chega de cima

Y = forward(X, K, b)
dX, dK, db = backward(dY, X, K)

# Conferência: L = sum(dY * Y) tem gradiente exatamente dY, então dL/dX deve bater com dX.
eps, num = 1e-6, np.zeros_like(X)
for i in range(X.shape[0]):
    for j in range(X.shape[1]):
        Xp, Xm = X.copy(), X.copy()
        Xp[i, j] += eps; Xm[i, j] -= eps
        num[i, j] = ((dY * forward(Xp, K, b)).sum() - (dY * forward(Xm, K, b)).sum()) / (2 * eps)

np.set_printoptions(precision=2, suppress=True)
print("Y  =\n", Y)
print("dY =\n", dY)
print("dX =\n", dX)
print("dK =\n", dK)
print("db =", db)
print("erro máximo contra diferenças finitas:", f"{np.abs(num - dX).max():.1e}")

Y  =
 [[3. 4.]
 [6. 7.]]
dY =
 [[ 0.5 -0.5]
 [ 1.   0. ]]
dX =
 [[ 0.5 -0.5  0. ]
 [ 0.5  1.  -0.5]
 [-1.   1.   0. ]]
dK =
 [[3.5 4.5]
 [6.5 7.5]]
db = 1.0
erro máximo contra diferenças finitas: 5.1e-10

A última linha é uma conferência por diferenças finitas: sem ela, um erro de preenchimento como o descrito acima passa despercebido, porque a saída continua com um formato plausível.

Pooling: o que ele descarta e para onde o gradiente volta

Uma camada de pooling não tem um único peso. Ela resume cada janela num número e a escolha do resumo decide quem recebe gradiente:

Na volta, o max não reparte nada. A janela inteira recebe zero, menos a posição que venceu, que recebe o gradiente inteiro:

O average troca esse indicador por \(1/k^2\), que é a mesma conta com o crédito dividido igualmente. O painel mostra as duas, com um gradiente de 1 em cada posição da saída, para que o número que aparece na volta seja literalmente em quantas janelas aquela célula venceu.

Na configuração padrão — janela 2×2, passo 2 — 27 das 36 células da entrada não recebem nada. Elas não influenciaram saída nenhuma, então a perda não se move se elas mudarem um pouco. Três consequências que valem a pena carregar:

• O max pooling é um roteador, não um filtro. Ele escolhe um caminho por janela e o gradiente só desce por ele. Trocar para average faz todas as células receberem \(1/k^2\) — mais estável, menos seletivo.
• A rota muda durante o treino. O vencedor de hoje pode não ser o de amanhã, porque ele depende dos valores, não dos índices. É por isso que o max pooling não é uma operação fixa como parece.
• Com passo menor que a janela as janelas se sobrepõem e uma célula pode acumular o gradiente de várias. Arraste o passo para 1 e veja o número subir.

"""Max pooling: a ida guarda o índice do vencedor, a volta devolve o gradiente só para ele."""
import numpy as np

def forward(X, k=2, s=2):
    H, W = X.shape
    Y = np.zeros((H // s, W // s))
    arg = np.zeros_like(Y, dtype=int)                 # índice achatado do vencedor de cada janela
    for i in range(0, H - k + 1, s):
        for j in range(0, W - k + 1, s):
            win = X[i:i + k, j:j + k]
            arg[i // s, j // s] = np.argmax(win)       # empate: argmax escolhe o primeiro
            Y[i // s, j // s] = win.flat[arg[i // s, j // s]]
    return Y, arg

def backward(dY, arg, shape, k=2, s=2):
    dX = np.zeros(shape)
    for i in range(dY.shape[0]):
        for j in range(dY.shape[1]):
            di, dj = divmod(arg[i, j], k)
            dX[i * s + di, j * s + dj] = dY[i, j]      # o resto da janela fica em zero
    return dX

X = np.arange(1., 17.).reshape(4, 4)
dY = np.array([[0.5, -0.5], [1.0, 0.0]])

Y, arg = forward(X)
dX = backward(dY, arg, X.shape)

np.set_printoptions(precision=2, suppress=True)
print("X  =\n", X)
print("Y  =\n", Y)
print("dY =\n", dY)
print("dX =\n", dX)
print("gradiente que chegou:", dY.sum(), "· gradiente distribuído:", dX.sum(),
      "· posições que receberam algo:", int((dX != 0).sum()), "de", X.size)

X  =
 [[ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]
 [ 9. 10. 11. 12.]
 [13. 14. 15. 16.]]
Y  =
 [[ 6.  8.]
 [14. 16.]]
dY =
 [[ 0.5 -0.5]
 [ 1.   0. ]]
dX =
 [[ 0.   0.   0.   0. ]
 [ 0.   0.5  0.  -0.5]
 [ 0.   0.   0.   0. ]
 [ 0.   1.   0.   0. ]]
gradiente que chegou: 1.0 · gradiente distribuído: 1.0 · posições que receberam algo: 3 de 16

Flatten: a ponte para a cabeça densa

Entre a última convolução e uma camada densa é preciso desmanchar o tensor \((B, C, H, W)\) em um vetor \((B,\; C \cdot H \cdot W)\). Isso é o flatten: ele não tem parâmetro, não faz conta nenhuma e a passagem reversa é só remontar o formato original. O que ele tem é um custo escondido — é ele que transforma o mapa inteiro em entrada de uma matriz densa gigantesca — era daí que vinha a maior parte dos parâmetros da AlexNet e da VGG. A substituição por global average pooling, na tabela acima, eliminou esse custo de uma vez.

Como a arquitetura ganhou o formato que tem

Quinze anos de pesquisa em visão — da LeNet-5¹ à AlexNet² — deixaram um punhado de movimentos que continuam em todo modelo e uma pilha maior que não. Vale saber qual é qual.

ConvNeXt: o experimento de controle

É tentador concluir de 2020–2021 que atenção venceu convolução. O ConvNeXt⁸ é o experimento que testa isso direito: pegue uma ResNet-50 e mude só as coisas que não são atenção — a receita de treino (AdamW, 300 épocas, augmentation pesada), as proporções entre estágios, um kernel 7×7 depthwise, LayerNorm no lugar de BatchNorm, GELU no lugar de ReLU, menos normalizações por bloco. Nenhuma atenção em lugar nenhum.

O resultado empata com o Swin Transformer em todas as escalas. A leitura honesta não é "convoluções vencem" — é que boa parte da vantagem reportada dos ViTs era a receita de treino, não a arquitetura e que as duas famílias convergiram para o mesmo desenho de bloco vindo de direções opostas. Onde as arquiteturas de fato ainda diferem é na escala de dados: veja o capítulo 13.

Onde as convoluções realmente vivem em 2026

Elas perderam a tarefa de manchete e mantiveram quase todo o resto. Isso importa para as escolhas do seu projeto:

Pontos principais

1. Uma convolução é uma camada densa com localidade e compartilhamento de pesos impostos. É capacidade retirada, não acrescentada e as duas restrições são afirmações sobre imagens.
2. Compartilhar pesos dá equivariância à translação. Invariância vem do pooling global e da augmentation — e nada dá invariância a rotação ou escala de graça.
3. O campo receptivo é o orçamento de projeto. O passo é o que o faz crescer geometricamente; a dilatação compra alcance sem downsampling.
4. Duas camadas 3×3 ganham de uma 5×5 — menos pesos, mais não linearidade. É por isso que 3×3 é o padrão.
5. A passagem reversa são três convoluções; usada para frente, a do gradiente da entrada é a convolução transposta e ela produz xadrez. Prefira upsample + convolução.
6. Da arquitetura clássica, sobreviveram pilhas 3×3, residuais, normalização, global average pooling, separáveis em profundidade e convoluções 1×1. As cabeças densas gigantes, a LRN e os kernels grandes de entrada, não.
7. O ConvNeXt mostra que boa parte da vantagem dos ViTs era a receita de treino. As famílias convergiram.
8. As convoluções perderam a corrida de backbones do ImageNet e mantiveram os autoencoders latentes, a segmentação médica, a visão em dispositivo e o patch stem — que é a maior parte dos pixels em produção no mundo.