13. Vision Transformers

O capítulo anterior construiu um encoder para sequências de tokens de texto. Em 2021, Dosovitskiy et al. fizeram uma pergunta deliberadamente crua: e se você alimentar esse mesmo encoder, sem mudar nada, com uma imagem?¹ A resposta — "An Image is Worth 16×16 Words" — foi que, com dados suficientes, um Transformer quase puro bate uma CNN em classificação de imagens, sem nenhuma convolução em lugar nenhum.

O resultado importou menos como número de classificação e mais como demonstração: a arquitetura não precisa saber que está olhando para uma imagem. É por isso que o ViT é o capítulo-ponte. Uma vez que você o tenha, os encoders de imagem dentro do CLIP, dentro de todo modelo de visão-linguagem, dentro do Stable Diffusion e do DiT deixam de ser coisas separadas a aprender.

O trade-off de viés indutivo, com o preço certo

O capítulo 10 chamou a convolução de um prior forte, barato e fixo. Uma camada de auto-atenção não tem nada disso: cada patch pode atender a qualquer outro patch desde a primeira camada e qualquer noção de que pixels vizinhos têm relação precisa ser aprendida dos dados.

Isso é uma troca, não uma melhoria e o artigo original mediu os dois lados dela:

Leia a tabela como uma única frase: o prior convolucional é um piso em escala pequena e um teto em escala grande. Abaixo de um certo limiar de dados, ele dá de graça o que o Transformer precisa comprar; acima dele, proíbe relações que o Transformer fica livre para descobrir.

O pipeline

O único mecanismo genuinamente novo é o primeiro passo. Tudo depois dele é o encoder que você já conhece.

Uma imagem \(x \in \mathbb{R}^{H \times W \times C}\) é cortada em patches \(P \times P\) sem sobreposição, cada um achatado e projetado por uma única camada linear compartilhada:

Para \(224 \times 224\) e \(P = 16\), são \(N = 196\) tokens. Embeddings posicionais são somados, porque a atenção sozinha não distingue o patch do canto superior esquerdo do canto inferior direito e a sequência atravessa \(L\) blocos de encoder pré-norm padrão.

O tamanho do patch é toda a decisão de projeto

\(P\) controla duas coisas ao mesmo tempo, em direções opostas e não há mais nada num ViT com tanta alavancagem.

Tudo que está dentro de um patch é comprimido em um vetor de dimensão \(d\) antes de a atenção sequer rodar. Nenhuma camada posterior recupera o que a projeção descartou. Arraste o tamanho do patch até 32 e veja um rosto desaparecer dentro de quatro tokens.

Puxe para o outro lado e a contagem explode: reduzir \(P\) pela metade quadruplica \(N\) e o termo de atenção cresce com \(N^2\). Dobrar a resolução faz o mesmo. Essa única quadrática é a razão pela qual:

• 14 e 16 são os tamanhos de patch quase universais, há cinco anos;
• modelos de visão-linguagem em alta resolução ladrilham uma imagem grande em vários recortes de 224 ou 336 pixels em vez de alimentar o encoder com uma grade enorme;
• o patch-and-pack no estilo NaViT⁹ existe — empacotar imagens de resolução variável numa única sequência, manter a proporção nativa e pular os tokens de que não se precisa.

O que mudou desde 2021

O ViT de 2021 ainda é reconhecível, mas um modelo que você baixaria hoje difere em cinco pontos e todos valem a pena porque aparecem no encoder de visão de todo modelo multimodal.

Para que serve um ViT, de fato, em 2026

Muito pouco do uso em produção é "classifique esta imagem em 1000 classes". O ViT venceu ao se tornar a forma padrão de transformar pixels em tokens para outra coisa:

CNN vs. ViT, atualizado

Referência de implementação

import torch, torch.nn as nn

class PatchEmbed(nn.Module):
    """Imagem -> sequência de tokens de patch. Um Conv2d faz patchify E projeção."""
    def __init__(self, patch=16, in_ch=3, dim=768):
        super().__init__()
        self.proj = nn.Conv2d(in_ch, dim, kernel_size=patch, stride=patch)

    def forward(self, x):                    # (B, C, H, W)
        x = self.proj(x)                     # (B, dim, H/p, W/p)
        return x.flatten(2).transpose(1, 2)  # (B, N, dim)

class ViT(nn.Module):
    """Registros no lugar do token CLS, mean pooling no lugar da cabeça no CLS."""
    def __init__(self, dim=768, depth=12, heads=12, n_classes=1000,
                 n_patches=196, n_registers=4):
        super().__init__()
        self.patch_embed = PatchEmbed(dim=dim)
        self.reg = nn.Parameter(torch.zeros(1, n_registers, dim))
        self.pos = nn.Parameter(torch.zeros(1, n_patches, dim))
        layer = nn.TransformerEncoderLayer(dim, heads, dim * 4, activation='gelu',
                                           norm_first=True, batch_first=True)
        self.encoder, self.norm = nn.TransformerEncoder(layer, depth), nn.LayerNorm(dim)
        self.head = nn.Linear(dim, n_classes)
        self.n_reg = n_registers

    def forward(self, x):
        x = self.patch_embed(x) + self.pos
        x = torch.cat([self.reg.expand(x.size(0), -1, -1), x], dim=1)
        x = self.encoder(x)[:, self.n_reg:]      # descarta os registros; eram rascunho
        return self.head(self.norm(x).mean(dim=1))

import timm
# um ViT supervisionado, ajustado para suas classes
model = timm.create_model('vit_base_patch16_224', pretrained=True, num_classes=10)

# features do DINOv2, congeladas — em geral a opção mais forte quando há poucos rótulos
dino = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14')
feats = dino.forward_features(img)['x_norm_patchtokens']   # (B, N, 768)

Pontos principais

1. Um ViT é o encoder de texto aplicado a patches de imagem. A única parte nova é o patchify — e isso é uma convolução com passo.
2. O prior convolucional é um piso em escala pequena e um teto em escala grande. É toda a troca.
3. O limiar de dados de 2021 era em grande parte um problema de receita. DeiT e ConvNeXt fecharam o buraco pelos dois lados.
4. O tamanho do patch é a decisão de projeto: a informação dentro de um patch é destruída antes de a atenção rodar, e \(N\) cresce quadraticamente quando \(P\) encolhe ou a resolução sobe. 14–16 é onde o meio-termo cai.
5. Um encoder atual usa pooling no lugar do [CLS], RoPE 2-D no lugar de posições aprendidas e tokens de registro para absorver os artefatos de atenção.
6. ViTs venceram porque emitem tokens, que é o que um modelo de linguagem come. A pontuação de classificação nunca foi o ponto.
7. Em produção, um ViT costuma ser o encoder de visão de outra coisa: um VLM, CLIP/SigLIP, features do DINOv2, ou um backbone de difusão.