Redes Neurais Artificiais e Deep Learning · Insper

Vision Transformers

O prior fraco, com o preço na etiqueta

Uma pergunta deliberadamente crua

A aula anterior construiu um encoder para sequências de tokens de texto.
O que acontece se você o alimentar, sem mudar nada, com uma imagem?

  • Primeiro problema: uma imagem não é uma sequência. Corte-a em patches e leia-os como palavras.
  • Dosovitskiy et al., An Image is Worth 16×16 Words (2021): com dados suficientes, um Transformer quase puro bate uma CNN em classificação.
  • O número importou menos que a demonstração: a arquitetura não precisa saber que está olhando para uma imagem.

Por que esta é a aula-ponte

Com o ViT na mão, estas coisas deixam de ser separadas:

  • a torre de imagem do CLIP e do SigLIP
  • o encoder de visão de todo modelo de visão-linguagem
  • o backbone do DiT — um ViT sobre patches latentes
  • as features do DINOv2, usadas congeladas em robótica e medicina

Um ViT é a forma padrão de transformar pixels em tokens para outra coisa.

O trade-off de viés indutivo

Convolução — um prior forte, barato e fixo: local e igual em toda parte.

Auto-atenção — nada disso: todo patch pode atender a todo patch desde a camada 1. "Vizinhos têm relação" precisa ser aprendido dos dados.

dados de pré-treino ViT vs. ResNet
ImageNet-1k (1,3M) o ViT perde
ImageNet-21k (14M) quase empatados
JFT-300M (300M) o ViT vence

O prior convolucional é um piso em escala pequena e um teto em escala grande.

Um patch, dois modelos

Um patch de uma grade 14 por 14, em dois modelos. À esquerda, convoluções 3 por 3 na grade: o campo receptivo cresce um patch de cada lado por camada e só alcança todos os patches na camada 7. À direita, auto-atenção: todo patch é alcançável desde a camada 1. As distâncias médias de atenção medidas num ViT-Ti/16 pré-treinado são 73, 84 e 13 pixels na camada 1 e 145, 142 e 145 pixels na camada 12. CNN · CONVOLUÇÕES 3 × 3 NA MESMA GRADE VIT · AUTO-ATENÇÃO 1 2 3

A tabela, modelo a modelo

Acurácia top-1 no ImageNet depois do ajuste fino, contra o tamanho do conjunto de pré-treino: ImageNet-1k, ImageNet-21k e JFT-300M. ResNet BiT R152x4: 81,3; 85,4; 87,5. ViT-B/32: 73,4; 81,3; 80,7. ViT-B/16: 77,9; 84,0; 84,2. ViT-L/32: 71,2; 81,0; 84,4. ViT-L/16: 76,5; 85,2; 87,1. ViT-H/14: 85,1 e 88,0 com os dois conjuntos maiores.

O limiar se moveu

"O ViT precisa de 300M de imagens" era quase sempre "o ViT precisa de uma receita de treino que ninguém tinha escrito ainda".

  • DeiT (2021): augmentation, regularização e um token de destilação — um ViT competitivo só com o ImageNet-1k.
  • Steiner et al.: a augmentation e a regularização certas, com mais computação, valem quase tanto quanto 10× mais dados.
  • ConvNeXt (2022): o mesmo argumento pelo outro lado — uma ResNet modernizada com a receita e as escolhas de projeto dos ViTs empata com o Swin, um ViT hierárquico.

A troca é real. O ponto de cruzamento de 2021 não era.

token de destilação: mais um token, treinado para imitar a previsão de uma CNN professora

Simulador · o pipeline

Patches, em símbolos

H × W pixels, C canais (3 no RGB) · P: lado do patch · N: nº de patches = nº de tokens · d: números por token · E: a projeção linear, P²C → d

Uma imagem RGB 224 × 224 com : quantos tokens e quantos números em cada patch achatado?

  • tokens
  • cada patch: números — igual ao do ViT-B por coincidência: esse veio do BERT-Base

Siga o tensor: ViT-B/16

ViT-B/16 = modelo Base (, blocos, 12 cabeças) com patch . Uma imagem:

passo formato parâmetros
entrada (canais × altura × largura) 3 × 224 × 224 —
patches, achatados (tokens × números) 196 × 768 —
projeção = Conv2d(3, 768, 16, stride=16) 196 × 768
prefixar o [CLS], somar as posições 197 × 768
12 blocos de encoder 197 × 768 M
LayerNorm final, ler a linha do [CLS] 768
cabeça linear 1000
total ≈ 86,6M

[CLS]: token aprendido na frente dos patches, lido pela cabeça · Conv2d(canais de entrada, filtros, kernel, passo) · um bloco = 7 087 872 (o do GPT-2 small): 2 362 368 de atenção + 4 722 432 do MLP 768 → 3072 → 768 + 3 072 das LayerNorms

O comprimento da sequência nunca muda dentro do encoder e só a tabela de posições sabe o tamanho da imagem.

O patch embedding é uma convolução

  • Um kernel com passo lê cada patch exatamente uma vez.
  • Os seus canais de saída são as linhas de .
  • Toda implementação faz assim: uma operação que divide em patches e projeta.

, (o TinyViT do laboratório, CIFAR 32 × 32): quantos parâmetros?

  • Laboratório: Conv2d e Linear sobre patches achatados concordam até o arredondamento (no máximo 1e-6).

"Sem convoluções" tem um asterisco: há exatamente uma, na entrada. Só ela e a interpolação do slide 14 põem o arranjo 2-D à mão no modelo.

Por que as posições são necessárias

Embaralhe os patches de uma imagem do CIFAR como um quebra-cabeça. Um ViT sem embeddings posicionais percebe?

  • A atenção mistura tokens pelo conteúdo, não pelo lugar; o MLP e a LayerNorm agem em cada token sozinho.
  • Então o encoder é equivariante a permutações e a média esquece a ordem por completo.
  • Laboratório, TinyViT não treinado, maior mudança nos logits: 1e-7 (arredondamento) sem posições, 9e-3 com elas — pequena porque a tabela começa com desvio-padrão de 0,02, mas real.
  • Sem posições, a original e a embaralhada são a mesma imagem. Uma CNN nunca tem esse problema.

Simulador · um ViT, linha a linha

x · imagem 4 × 4, 1 canal (edite)

Uma nova resolução: a tabela de posições

A tabela de posições aprendida do ViT-B/16 numa nova resolução. Treinada em 224 pixels, ela tem uma linha para o token CLS e 14 por 14 linhas para os patches. Em 384 pixels a imagem tem 24 por 24 patches. As 196 linhas dos patches voltam para a grade 14 por 14 e são interpoladas para 24 por 24; cada nova posição é uma média ponderada de quatro antigas. A RoPE 2-D não tem tabela: ela gira queries e keys pela linha e pela coluna de cada patch. [CLS] [CLS] ?

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

Um patch vira um token antes de a atenção rodar. A atenção move informação entre patches, nunca dentro de um.

modelo o que consegue manter
ViT-B/16 tudo, em princípio ( é quadrada)
ViT-Ti/16 (Tiny, ) no máximo das direções
ViT-B/32 no máximo

Laboratório: reconstruir cada patch a partir do token de um ViT-Ti/16 pré-treinado (o melhor caminho linear de volta, a pseudoinversa de ) deixa um erro relativo de 0,37 — perdido antes da primeira camada de atenção.

Simulador · tamanho do patch e custo

O preço de um token

çõçãçõ

L blocos, N tokens, d números por token · por bloco, 12Nd² = 4Nd² das projeções Q, K, V e de saída + 8Nd² do MLP d → 4d → d · 2N²d = QK⊤ + a soma ponderada de V, N²d cada

ViT-B/16 em 224 px (, ). Que fração do custo é atenção?
Reduza o patch para 8: o custo cresce 4× ou 16×?

O preço de um token · resposta

ViT-B/16 (, ), em G (bilhões de) multiplicações-somas por imagem:

imagem / patch total atenção
224 / 16 16,65 0,71 17,36 4%
224 / 8 66,59 11,33 77,92 15%
448 / 8 266,36 181,27 447,62 40%
  • pela metade: × 4, o primeiro termo × 4 e o segundo × 16. Como o primeiro domina, o total vai × 4,5 (), não × 16.
  • A atenção só passa o resto quando , ou seja, = 4 608 tokens no ViT-B.

Então, na prática

  • 14 e 16 são os tamanhos de patch quase universais desde 2020.
  • Dobrar a resolução também quadruplica (): modelos de visão-linguagem (VLMs) de alta resolução ladrilham uma imagem grande em recortes de 224 ou 336 px em vez de uma grade enorme.
  • NaViT (patch-and-pack): imagens de resolução variável numa sequência, proporção nativa, sem os tokens de que não se precisa.

pequeno preserva detalhe e paga em tokens; grande é barato e joga detalhe fora antes da atenção. Não há mais nada num ViT com tanta alavancagem.

O que mudou desde 2021 (1/2)

[CLS] → pooling

  • Ler a classe de um token especial era um hábito do BERT.
  • Muitos encoders tiram a média dos tokens de patch ou usam uma cabeça de attention-pooling (a do SigLIP: uma query aprendida faz atenção sobre os patches).
  • Num VLM não há cabeça: os tokens de patch vão para o LLM.

posições aprendidas → RoPE 2-D

  • Uma tabela aprendida precisa ser interpolada quando a resolução muda, com custo em acurácia.
  • RoPE 2-D: a rotação da aula de atenção, em linhas e colunas. Relativa, sem tabela para interpolar.
  • Qwen2-VL, DINOv3.

O que mudou desde 2021 (2/2)

tokens de registro

  • ViTs grandes e bem treinados despejam atenção em alguns patches de fundo sem significado — rascunho.
  • Isso destrói os mapas de atenção e prejudica tarefas densas (uma resposta por pixel: segmentação, profundidade).
  • Acrescente alguns tokens sem uso e descarte-os na saída. Os artefatos somem (Darcet et al., 2024).

hierarquia, onde precisa

  • Um ViT simples mantém uma resolução do começo ao fim — desperdício para detecção e segmentação.
  • Swin: atenção em janelas e uma pirâmide.
  • ViTDet: um ViT simples com uma pirâmide de features por cima.

Para que serve um ViT em 2026

uso o que o ViT fornece
modelos de visão-linguagem o encoder de imagem: tokens de patch, projetados, prefixados ao texto
CLIP / SigLIP a torre de imagem, treinada contra uma torre de texto
features auto-supervisionadas DINOv2/v3: features densas sem rótulos, usadas congeladas
backbones generativos DiT, MMDiT: um ViT sobre patches latentes
pré-treino mascarado MAE: mascare 75%, codifique só os 25% visíveis

Muito pouco disso é "classifique em 1000 classes".

A razão pela qual ele venceu não é acurácia

Um ViT e uma ConvNet moderna pontuam quase igual no ImageNet. Por que o ViT está em toda parte?

  • Ele emite uma sequência de tokens, no formato que o texto usa.
  • Concatenar tokens de patch com tokens de palavra e rodar um Transformer sobre os dois é trivial.
  • Fazer o mesmo com um mapa de features convolucional não é.

O argumento é multimodalidade, não classificação.

CNN vs. ViT, atualizado

CNN ViT
operação central convolução: local, fixa auto-atenção: global, aprendida
viés indutivo forte fraco — comprado com dados
campo receptivo cresce com a profundidade global na camada 1
custo +
poucos dados vence precisa de pré-treino ou de receita
dados em escala web acompanha com a mesma receita onde o pré-treino acontece
uso multimodal desajeitado nativo

Medido: o piso em escala pequena

CIFAR-10, mesmo orçamento (600 passos com lotes de 128 imagens, AdamW, recorte + espelhamento). Acurácia de teste:

imagens de treino CNN pequena (289 mil parâmetros) TinyViT (546 mil) CNN − ViT
1 000 0,58 0,43 0,15
5 000 0,68 0,51 0,17
20 000 0,71 0,51 0,20
ViT-Ti/16 pré-treinado, sonda linear, 1 000 rótulos 0,89
  • A CNN vence em todos os tamanhos, por 15, 17 e 20 pontos, com metade dos parâmetros — e com esse orçamento a diferença não fecha.
  • O prior pode ser comprado em outro lugar: pré-treinado em 14M de imagens (ImageNet-21k), um ViT congelado mais uma regressão logística sobre as suas 192 features (a sonda linear) bate os dois. Pesos aleatórios, mesma arquitetura: 0,33.

Medido: parte da diferença é a receita

As mesmas 5 000 imagens, sem recorte e espelhamento:

com augmentation sem perda
CNN pequena 0,68 0,68 0,001
TinyViT 0,51 0,47 0,04

As acurácias estão arredondadas na segunda casa; a perda é a diferença antes do arredondamento.

A augmentation ensina ao ViT parte do que a CNN recebe pronto. É a lição do DeiT, em escala pequena.

O que o ViT aprendeu no lugar do prior

Dentro do ViT-Ti/16 pré-treinado (, 12 camadas de 3 cabeças, grade de 14 × 14 patches):

Posições. 196 = 14 × 14 vetores livres; nada diz qual fica ao lado de qual.

  • similaridade de cosseno com os 4 vizinhos: 0,85
  • a distância ≥ 8 patches na grade: −0,17
  • a grade 2-D, recuperada dos dados

Distância de atenção: quão longe um patch olha, em média pesada pela atenção (1 patch = 16 px):

  • camada 1, três cabeças: 73, 84, 13
  • camada 12: 145, 142, 145
  • uma cabeça do começo é um filtro local aprendido; as outras já olham longe. A profundidade deixa todas globais.

Laboratório · o prior fraco, medido

Notebook no Colab, ~2 h, CIFAR-10, GPU T4 (menos de 15 min de computação). Cada seção termina num checkpoint.

  1. patches, à mão
  2. o patch embedding é uma conv com passo — e o que 768 → 192 mantém
  3. sem posições: um saco de patches
  4. o preço de um token
  5. a fome de dados: CNN × ViT
  1. parte da diferença é a receita
  2. um prior comprado em outro lugar: sonda linear
  3. o que o ViT pré-treinado aprendeu
  4. o seu ViT para poucos dados: ≤ 600 000 parâmetros, 5 000 imagens

abrir no Colab →

Pontos principais

  1. Um ViT é o encoder de texto aplicado a patches de imagem. A única parte nova é dividir em patches — uma convolução com passo.
  2. Sem posições, a atenção vê um saco de patches.
  3. O tamanho do patch é a decisão: nada abaixo da grade de patches é visto a não ser por ; reduzir pela metade quadruplica . A atenção só domina quando .
  4. O prior convolucional é um piso em escala pequena e um teto em escala grande; receita e pré-treino movem o cruzamento.
  5. Encoders atuais: pooling no lugar do [CLS], RoPE 2-D, registros.
  6. ViTs venceram porque emitem tokens — o que um modelo de linguagem come.

Roteiro: (1) a pergunta e o trade-off de viés indutivo; (2) o pipeline: patches, patch embedding, posições; (3) o tamanho do patch: o que um token guarda e quanto custa; (4) o que mudou desde 2021 e para que serve um ViT; (5) o que o laboratório mediu. Fecha com o laboratório no Colab.

Seis passos numa grade 14 × 14. Camada 1: o kernel 3×3 vê 9 de 196, a atenção vê os 196. Camada 3: 7 × 7 = 49. Camada 7: a grade inteira (uma CNN real reduz a resolução e chega antes, mas as primeiras camadas continuam locais). Antes do passo 5, pergunte: na camada 1 de um ViT treinado, as cabeças olham perto ou longe? Laboratório, ViT-Ti/16: 73, 84 e 13 px; camada 12: 145, 142 e 145 px, mais longe que uma atenção uniforme (116 px).

Tabela 5 do artigo do ViT e a ResNet-152x4 do BiT, todos ajustados no ImageNet. Aponte primeiro o ImageNet-1k: todo ViT abaixo da ResNet e o L/16 (76,5) abaixo do B/16 (77,9). Passe o mouse no L/16 e siga a linha: empata no 21k, quase no topo no JFT. O H/14 passa a ResNet no JFT (88,04 contra 87,54) com cerca de um quarto do compute de pré-treino (2,5k contra 9,9k TPUv3-core-days).

Avance passo a passo. O único passo novo é o primeiro (patches + projeção linear); de "Encoder Transformer" em diante é a aula anterior. O [CLS] + cabeça MLP é o ViT de 2021; encoders atuais em geral tiram a média dos tokens de patch.

Uma imagem 4×4, P = 2, d = 3: todo número confere à mão. Avance com a barra vertical: o patchify dá quatro linhas de quatro números, E guarda a média e duas bordas, o [CLS] atende com pesos 0,273; 0,243; 0,162; 0,193 e 0,129 e a cabeça diz vertical (0,436). Na última linha, aponte o quebra-cabeça: 0,393, diferente por causa das posições. Depois "sem posições": os dois dão 0,414, o saco de patches do slide anterior. Por fim o xadrez: perdido = 1 em todo patch e os tokens são iguais aos de um cinza uniforme.

Seis passos. A tabela do ViT-B/16 é 197 × 768. Em 384 px há 576 patches e só 196 linhas. Volte as linhas para a grade 14 × 14, estique para 24 × 24 (cada linha nova é uma média ponderada de quatro antigas: 0,27; 0,44; 0,11 e 0,18 para a linha 6, coluna 10), mantenha o [CLS]: 577 × 768. Depois, ajuste fino. Último passo: RoPE 2-D, sem tabela nenhuma. Passe o mouse nas células.

Arraste P até 32 em 224 px: o rosto vira ~9 tokens e 75% das dimensões de cada patch se perdem no ViT-B. Depois P = 8: 784 tokens. Peça a razão de custo antes de ler (próximo slide).