Vision Transformers

1. De sequência-para-sequência a imagem-para-sequência

O Capítulo 1 enquadrou o Transformer como um operador de sequências. Dados \(T\) tokens, cada um representado por um vetor de dimensão \(D\) organizados em um tensor de ativação de forma \((B, T, D)\), a pilha do encoder retorna uma sequência da mesma forma, com informação misturada entre posições por self-attention e entre canais de atributos pela rede feed-forward posicional. Nada nessa arquitetura é específico para linguagem; os únicos compromissos são que a entrada chegue como uma sequência unidimensional de vetores de dimensão equivalente e que alguma informação de posição seja fornecida para quebrar a equivariância de permutação da layer.

🔗 Conexão

O Capítulo 1 desenvolve o bloco do Transformer como um operador de sequências; este capítulo toma esse bloco como dado e constrói o front-end de patch embedding que o alimenta.

O Vision Transformer de Dosovitskiy et al. é a materialização mínima dessa observação para imagens [src_013]. Tome um Transformer encoder padrão estilo NLP, não mude nada dentro do bloco do encoder, e prefixe um pequeno front-end cuja única função é transformar uma imagem em uma sequência de vetores que o encoder pode consumir. Não há tronco convolucional, nem pirâmide de mapas de atributos, nem pooling espacial entre blocos; o encoder é o encoder do Capítulo 1, e os vieses indutivos que redes convolucionais clássicas embutem em cada layer (localidade, equivariância translacional, agregação hierárquica de atributos) deliberadamente não são incorporados. As convoluções reusam o mesmo filtro espacial pequeno em cada posição (localidade e equivariância translacional), e convoluções strided empilhadas ou layers de pooling comprimem atributos de granularidade fina em atributos mais grossos (agregação hierárquica); uma layer de self-attention não faz nenhuma dessas coisas por construção. A afirmação empírica central do paper do ViT é que esse port mínimo funciona, dado dados suficientes: pré-treinado em escala suficiente e transferido para benchmarks de reconhecimento de imagens, o ViT iguala ou excede as baselines mais fortes baseadas em redes residuais [src_013].

Que esse seja o enquadramento correto do ViT — um port de um encoder NLP para visão em vez de uma nova arquitetura de visão — é também como os livros-texto canônicos de 2024 o posicionam. Bishop e Bishop discutem vision Transformers como uma instância da mesma maquinaria Transformer coberta em seus capítulos sobre linguagem, e Foundations of Computer Vision de Torralba, Isola e Freeman coloca o ViT ao lado da pilha convolucional clássica como um backbone alternativo com um perfil de viés diferente [src_001, src_008]. O capítulo de 2023 de Courant et al. sobre Transformers visuais adota a mesma visão, tratando os fundamentos de attention, ViT, e extensões para dados pequenos como uma linhagem contínua em vez de desenvolvimentos separados [src_009].

Este capítulo segue esse enquadramento. A Seção 2 constrói o front-end de patch embedding e mostra a equivalência com um único Conv2d. A Seção 3 descreve o token [CLS] e o position embedding. A Seção 4 trabalha a aritmética de contagem de tokens explicitamente. A Seção 5 colapsa o encoder em uma única frase, já que o Capítulo 1 já cobriu a substância. As Seções 6 a 8 tratam da história de dados-e-computação que originalmente distinguiu o ViT de baselines convolucionais, do atalho do DeiT que suavizou o requisito de dados, e do Swin Transformer V2 como a re-introdução mais proeminente de priors convolucionais. A Seção 9 amplia o foco para o ViT em 2026, e a Seção 10 encerra apontando para a visão auto-supervisionada no Capítulo 6.

2. Patch embedding

Seja uma imagem de forma \(H \times W \times C\), com \(C = 3\) para entradas RGB padrão. Escolha um tamanho de patch \(P\) que divida tanto \(H\) quanto \(W\), e remodele a imagem em uma sequência de \(N = (H/P) \cdot (W/P) = HW/P^2\) patches achatados, cada um de forma \(P \times P \times C\) achatada em um vetor de comprimento \(P^2 \cdot C\). Uma única projeção linear treinável \(E \in \mathbb{R}^{(P^2 \cdot C) \times D}\) mapeia cada patch para um token de dimensão \(D\). A Equação (1) do paper do ViT captura exatamente essa construção [src_013]:

🎯 Intuição

Cada patch de imagem \(16 \times 16 \times 3\) é achatado em um vetor de \(768\) elementos e passa por um único mapa linear compartilhado \(E\) para aterrissar em um espaço de tokens de \(768\) dimensões. A equação que segue diz apenas que empilhamos esses patch tokens em uma sequência, prefixamos um vetor [CLS] aprendível, e somamos um vetor de posição aprendível por slot. A equivalência com convolução e o bloco de código abaixo operacionalizam essa imagem; a equação ainda não faz nenhum trabalho que a prosa já não tenha feito.

\[z_0 = [x_{\text{class}}; \, x_p^1 E; \, x_p^2 E; \, \ldots; \, x_p^N E] + E_{\text{pos}}, \qquad E \in \mathbb{R}^{(P^2 \cdot C) \times D}, \quad E_{\text{pos}} \in \mathbb{R}^{(N+1) \times D}.\]

O termo \(x_{\text{class}}\) e a parcela \(E_{\text{pos}}\) são o token [CLS] e o position embedding, adiados para a Seção 3. O conteúdo substantivo aqui é a construção dos \(N\) patch tokens.

A observação-chave de implementação é que o achatar-e-projetar-linearmente patches \(P \times P \times C\) é matematicamente equivalente a uma única convolução 2D com tamanho de kernel \(P\) e stride \(P\), mapeando \(C\) canais de entrada para \(D\) canais de saída [src_001, src_008, src_013]. Com tamanho de kernel igual ao stride, a convolução vê cada patch exatamente uma vez, aplica o mesmo mapa linear compartilhado a todos os patches, e emite um mapa de atributos de \(D\) canais com forma espacial \((H/P) \times (W/P)\). Achatar as dimensões espaciais e transpor produz a sequência de tokens \(N \times D\) desejada. As duas formulações diferem apenas na forma como são escritas; elas realizam o mesmo conjunto de parâmetros e o mesmo mapa direto.

Essa equivalência é conveniente porque kernels Conv2d são extremamente bem otimizados em toda pilha moderna de GPU e TPU, enquanto um pipeline manual de unfold-then-linear não é. A implementação canônica em PyTorch se reduz a duas linhas:

import torch.nn as nn

# Patch embedding for ViT-B/16: P = 16, C = 3, D = 768
proj = nn.Conv2d(in_channels=3, out_channels=768, kernel_size=16, stride=16)

# image: (B, 3, 224, 224)
# proj(image):              (B, 768, 14, 14)
# .flatten(2):              (B, 768, 196)
# .transpose(1, 2):         (B, 196, 768)
tokens = proj(image).flatten(2).transpose(1, 2)

Lendo isso de fora para dentro: a convolução transforma a imagem em um mapa de atributos \((B, D, H/P, W/P)\); flatten(2) colapsa os eixos espaciais em um único eixo de comprimento \(N = HW/P^2\); transpose(1, 2) troca os eixos de canal e sequência de modo que o resultado tenha o layout padrão \((B, N, D)\). O mesmo efeito pode ser obtido com einops.rearrange(image, "b c (h p1) (w p2) -> b (h w) (p1 p2 c)") seguido por um \(\texttt{nn.Linear}(P^2 C, D)\) — essa é a forma explícita de projeção linear, e é mais próxima da eq. (1) do ViT lida literalmente — mas a forma de convolução é a que de fato chega às bases de código de produção [src_013].

A Figura fig_003 visualiza o pipeline.

O enquadramento da equivalência com convolução é também a ponte pedagógica natural da visão computacional clássica para o ViT. Bancos de filtros aplicados sobre uma grade espacial deslizante são exatamente o que convoluções implementam; o patch embedding do ViT é o caso especial em que o stride coincide com o kernel e não há sobreposição [src_001, src_008]. Dessa perspectiva, a única coisa arquiteturalmente nova sobre o front-end do ViT é que a grade espacial é então colapsada em uma sequência de tokens unidimensional e todo o processamento subsequente é equivariante por permutação a menos de position embeddings.

3. Token CLS e position embedding

Dois tokens de bookkeeping precisam ser adicionados à sequência de patches antes que ela possa entrar no encoder.

O primeiro é o token de classificação, escrito [class] ou [CLS]. Seguindo a convenção NLP do BERT, o ViT prefixa um único embedding aprendível à sequência de patches, de modo que a entrada tenha \(N + 1\) tokens cujas posições vão de \(0\) (o token [CLS]) a \(N\) (o último patch) [src_013].

🔗 Conexão

A convenção do token [CLS] é emprestada do BERT (Capítulo 7), onde um único token no estilo register é prefixado à sequência de entrada e seu estado oculto final é lido como uma representação em nível de sentença. O estado oculto na posição \(0\) na saída do encoder serve como a representação da imagem, e uma pequena cabeça de classificação — um MLP de uma camada oculta no momento do pretraining, uma única camada linear no momento do fine-tuning — é anexada a esse estado oculto para produzir os logits de classe [src_013]. O token [CLS] não tem significado espacial; é um registrador que as layers de self-attention aprendem a popular com qualquer informação globalmente agregada de que a cabeça de classificação precise.

O segundo é o position embedding \(E_{\text{pos}} \in \mathbb{R}^{(N+1) \times D}\), somado ponto a ponto à sequência de \(N+1\) tokens como na eq. (1) acima [src_013]. O ViT usa position embeddings absolutos 1-D aprendíveis padrão: cada uma das \(N+1\) posições é associada a um vetor de dimensão \(D\) livremente aprendível, inicializado aleatoriamente e treinado conjuntamente com o resto do modelo. A escolha de position embeddings 1-D aprendíveis em vez de variantes cientes de 2-D (por exemplo pares sin-cos ao longo de \(H\) e \(W\), ou embeddings fatorizados de linha e coluna) é uma das pequenas surpresas do paper original: a ablação de Dosovitskiy et al. em seu Apêndice D.4 reporta que variantes cientes de 2-D dão ganho desprezível sobre a baseline 1-D em sua configuração, então o esquema mais simples foi mantido [src_013]. A interpretação do paper, apoiada por sua visualização de similaridade de posição, é que o modelo aprende a topologia 2-D da imagem a partir dos próprios patches: position embeddings treinados acabam com estrutura de linha-coluna visível em sua matriz de similaridade de cosseno, e patches mais próximos desenvolvem embeddings mais semelhantes [src_013].

Esse é um dos poucos lugares onde a pilha moderna decoder-only de LLM e a pilha clássica do ViT fizeram escolhas diferentes e mantiveram-nas. Modelos de linguagem modernos quase universalmente usam agora rotary position encoding (o tópico do Capítulo 2), que é mais barato de estender para contextos mais longos e se comporta melhor em extrapolação. O ViT clássico e a maioria de seus descendentes de 2020-2022 ficou com position embeddings absolutos aprendíveis, que são uma boa correspondência para resoluções de entrada fixas e uma má correspondência para resoluções variáveis. Uma consequência prática é que o fine-tuning do ViT em resolução mais alta requer uma interpolação 2-D dos position embeddings pré-treinados de acordo com sua localização na imagem original; este é o único lugar onde a estrutura 2-D da imagem é manualmente re-injetada no modelo após o treinamento [src_013].

4. Aritmética de contagem de tokens

A fórmula de patch embedding \(N = HW/P^2\) tem consequências numéricas diretas sempre que uma variante específica de ViT é nomeada. A configuração mais comum na literatura é o ViT-B/16: um modelo de tamanho Base (12 layers, \(D = 768\), 12 heads, 86M parâmetros pela Tabela 1 do paper do ViT) com tamanho de patch \(P = 16\), treinado na resolução de entrada padrão de 224 x 224 [src_013].

Substituindo os números: \(H = W = 224\), \(P = 16\), então \(N = (224/16)^2 = 14^2 = 196\) patches.

🤔 Pause e pense

Antes de seguir, preveja — para o ViT-L/14 com a mesma entrada \(224 \times 224\), qual é a contagem de patches \(N\) e a contagem total de tokens \(N + 1\)? Em seguida, preveja se o custo de self-attention por bloco escala linearmente ou quadraticamente no comprimento do lado da entrada. (Não olhe adiante — escreva a resposta ou diga em voz alta.)

Adicionar o token [CLS] traz a contagem total de tokens para \(N + 1 = 197\), que é o comprimento da sequência que o encoder de fato vê. O próprio paper do ViT enuncia a fórmula \(N = HW/P^2\) e nota a grade 14 x 14 (contra a imagem original 224 x 224) em sua ablação de position embedding, mas não escreve a aritmética explícita "197 tokens" em uma única frase; o exemplo trabalhado aqui torna isso concreto [src_013].

Esse comprimento concreto de sequência vale ter em mente. O ViT-B/16 a 224 x 224 vê uma sequência de comprimento 197, muito mais curta do que os contextos de muitos milhares de tokens familiares de modelos de linguagem, e o custo de self-attention por bloco — quadrático na contagem de tokens — é correspondentemente modesto. O ViT-L/16 tem o mesmo comprimento de sequência (a dimensão do modelo e a profundidade crescem, mas \(N\) é fixado pelos tamanhos da imagem e do patch); o ViT-L/14, a variante favorecida por muitas receitas de pretraining auto-supervisionado, tem \(N = (224/14)^2 = 16^2 = 256\) patches e portanto 257 tokens. Ir para resoluções mais altas explode a contagem rapidamente: o ViT-B/16 a \(384 \times 384\) tem \(N = 24^2 = 576\) patches e 577 tokens, com uma explosão de \(3\times\) no custo de attention em relação a 224.

💡 Resultado-chave

O ViT-B/16 a \(224 \times 224\) vê \(197\) tokens; o custo de self-attention por bloco cresce quadraticamente no número de patches, então dobrar o lado da entrada multiplica o custo de attention por aproximadamente quatro.

5. O encoder é o encoder do Capítulo 1

Com patch tokens, token [CLS] e position embeddings em mãos, o resto do ViT é exatamente o Transformer encoder do Capítulo 1 [src_013].

🔗 Conexão

O bloco encoder reusado aqui — ordenação pre-LN, multi-head self-attention, MLP de duas camadas, duas conexões residuais — é definido no Capítulo 1; o resto deste capítulo assume isso como contexto inicial.

As Equações (2)–(4) do paper do ViT são reproduzidas abaixo, na própria notação do paper, para completude:

\[z'_\ell = \mathrm{MSA}(\mathrm{LN}(z_{\ell-1})) + z_{\ell-1}, \qquad \ell = 1, \ldots, L,$$ $$z_\ell = \mathrm{MLP}(\mathrm{LN}(z'_\ell)) + z'_\ell, \qquad \ell = 1, \ldots, L,$$ $$y = \mathrm{LN}(z_0^L).\]

🎯 Intuição

O bloco do ViT de 2020 e o bloco do ViT moderno de 2024 diferem apenas em suas escolhas de componentes drop-in:

Componente	ViT 2020	ViT moderno (estilo Llama) 2024
Norm	LayerNorm, pre-LN	RMSNorm, pre-LN
Não-linearidade da FFN	MLP GELU	FFN SwiGLU
Posição	Absoluto aprendível (1-D)	(Opcional) RoPE-2D / RoPE axial

O bloco do encoder permanece inalterado; apenas os três componentes acima são trocados, exatamente como o lado dos modelos de linguagem evoluiu de GPT-2 para Llama.

Lendo essas em notação do livro: cada bloco aplica uma LayerNorm, uma multi-head self-attention, e uma conexão residual; em seguida outra LayerNorm, um MLP de duas camadas com uma não-linearidade GELU, e outra conexão residual [src_013]. A LayerNorm é colocada antes de cada sub-layer em vez de depois, a configuração pre-LN agora padrão que o Capítulo 1 introduziu como uma correção de estabilidade sobre o post-LN do Transformer original de 2017. A cabeça de classificação lê \(z_0^L\), o estado oculto do token [CLS] na saída do bloco final, após uma LayerNorm final.

🤔 Pause e pense

Por que o pre-LN substituiu o post-LN no bloco Transformer moderno? Que problema de estabilidade a arquitetura post-LN exibia em profundidade que o pre-LN resolve, e como o residual stream atravessa cada formulação de forma diferente? (Não olhe adiante — recupere a resposta do Capítulo 1, ou verifique a referência cruzada abaixo.)

Duas consequências se seguem. Primeiro, todos os upgrades de componentes modernos que os Capítulos 2–4 cobrem — RoPE, RMSNorm, SwiGLU/GeGLU, FlashAttention — são substituições drop-in no nível do bloco do ViT exatamente como são no nível do bloco do modelo de linguagem. Variantes modernas do ViT em 2026 rotineiramente trocam LayerNorm por RMSNorm e o MLP GELU por uma FFN SwiGLU; o bloco do encoder permanece um bloco Transformer de residual stream, e a diferença em relação ao ViT de 2020 é exatamente a diferença entre um bloco GPT-2 de 2020 e um bloco Llama de 2024. Segundo, todas as ferramentas de análise que se aplicam a Transformers de linguagem (linearidade do residual stream, visualização de padrões de attention, distância média de attention) também se aplicam ao ViT, e a Seção 4.5 do paper original explora a segunda destas explicitamente: alguns heads atendem globalmente mesmo nas layers mais baixas, enquanto outros permanecem altamente localizados, e os heads localizados de baixa layer comportam-se como as primeiras layers convolucionais de uma CNN [src_013].

🔄 Recapitulação

• Complete: Escreva a contagem de tokens \(N + 1\) para o ViT-B/16 com resolução de entrada \(384 \times 384\).
• Explique: Por que o ViT usa position embeddings 1-D aprendíveis em vez de variantes cientes de 2-D (sin-cos ao longo de \(H\) e \(W\), ou embeddings fatorizados de linha/coluna)?
• Compare: Como o bloco do encoder do ViT se relaciona com o Transformer encoder do Capítulo 1? Nomeie o que é preservado (arquitetura, pre-LN, conexões residuais) e o que é adicionado por cima (front-end de patch, token [CLS], position embedding absoluto aprendível).

6. O resultado de fome de dados

A afirmação experimental do paper do ViT não é que a arquitetura é nova; quase tudo sobre ela já tinha aparecido em algum lugar na literatura. A afirmação é que escala — dados de pretraining mais computação de pretraining — é o que torna Transformers puros competitivos em visão, e que com escala suficiente eles não são apenas competitivos, mas melhores.

Os números de destaque da Seção 4.2 do paper [src_013]: o ViT-L/16 pré-treinado em JFT-300M alcança 87,76% de top-1 no ImageNet em fine-tuning, contra 87,54% do BiT-L (Big Transfer; uma baseline ResNet152x4 muito forte pré-treinada no mesmo dataset JFT-300M, Kolesnikov et al. 2020), enquanto requer substancialmente menos computação de pretraining (0,68k TPUv3-core-days contra 9,9k para o BiT-L). O ViT-H/14 maior alcança 88,55% no ImageNet a 2,5k TPUv3-core-days, batendo Noisy-Student EfficientNet-L2 e BiT-L no ImageNet, CIFAR-100, e na suíte VTAB de 19 tarefas [src_013].

O outro lado, tornado explícito na Seção 4.3 [src_013]: quando o pretraining é restrito ao ImageNet-1k apenas, o ViT-Large fica abaixo do ViT-Base, e ambos ficam abaixo de baselines ResNet comparáveis.

🎯 Intuição

Com dados suficientes, a variância que o viés controlaria é controlada pelos dados, e a inflexibilidade do viés agora custa mais do que economiza. Com poucos dados, o viés de localidade da CNN é um regularizador gratuito; com muitos dados, é uma restrição que impede o modelo de aprender padrões que os próprios dados já fornecem.

A interpretação do paper é que o ViT carrega menos viés indutivo específico de imagem do que uma CNN — sem localidade embutida fora da grade de patches, sem equivariância translacional fora dos MLPs — então em datasets menores ele faz overfitting onde uma CNN generalizaria [src_013]. Mover o pretraining para o ImageNet-21k (≈14M imagens) fecha o gap, e somente com o JFT-300M modelos ViT maiores manifestam seu pleno potencial [src_013]. A Figura 4 do paper plota isso como uma transição de fase: com menos de ~30M amostras de pretraining do JFT, ResNets BiT dominam; passados ~100M, o ViT-L/16 ultrapassa [src_013].

A leitura pedagógica honesta é que a vitória do ViT não foi elegância arquitetural, mas um resultado de sistemas: a arquitetura é favorável à escala porque toma emprestado o perfil de computação amigável a aceleradores do Transformer NLP, e em escala o déficit de viés indutivo torna-se uma virtude em vez de um passivo. Essa história está por trás de uma grande parte do programa de pesquisa em visão pós-2020, incluindo os métodos auto-supervisionados do Capítulo 6.

💡 Resultado-chave

Em escala de pretraining suficiente (JFT-300M e além), Transformers puros igualam ou excedem as baselines convolucionais mais fortes em reconhecimento de imagens enquanto usam menos computação de pretraining, mas em escalas menores de pretraining o déficit de viés indutivo machuca e CNNs vencem.

7. DeiT e eficiência de dados

O resultado de fome de dados levantou uma pergunta prática imediata: modelos da classe ViT podem ser treinados em orçamentos de imagem de tamanho acadêmico, isto é, ImageNet-1k apenas, sem os corpora privados de 300M imagens do paper original? A receita DeiT (Data-efficient image Transformers) de Touvron et al. é a resposta mais influente [src_050]. O DeiT pareia uma arquitetura ViT-Base com forte augmentation (RandAugment, Mixup, CutMix, random erasing — quatro estratégias-padrão de augmentation de imagem, com detalhes fora do escopo deste capítulo) e uma agenda de treinamento de 300 epochs no ImageNet-1k apenas, e adiciona um token de destilação — um segundo token no estilo register (um token aprendível não-imagem em que o encoder pode escrever; o token [CLS] é o exemplo canônico), ao lado do [CLS], que aprende a casar as predições de um teacher CNN via attention; o teacher padrão no paper é o RegNetY-16GF (84M de parâmetros, 82,9% top-1) [src_050]. O DeiT-B alcança 83,1% top-1 sem destilação e 85,2% com ela, em um único nó em dois a três dias, tornando o modelo resultante competitivo com baselines convnet fortes a menor computação de pretraining [src_050].

O DeiT importa aqui porque é a primeira demonstração amplamente adotada de que a arquitetura ViT não é intrinsecamente faminta por dados; o resultado de fome de dados é sobre uma receita particular de treinamento. Com augmentation suficiente e um teacher CNN para destilar, o mesmo ViT-B que falha no ImageNet-1k a partir do zero treina com sucesso. Isso afrouxou a expectativa de que corpora em escala JFT são obrigatórios para vision Transformers e preparou o palco para os métodos de pretraining auto-supervisionado do Capítulo 6 — MAE, DINOv2 — que descartaram inteiramente o teacher CNN.

🔗 Conexão

O Capítulo 6 retoma as receitas de pretraining auto-supervisionado — MAE (autoencoders de patches mascarados), DINOv2 (auto-destilação sem supervisão de texto), CLIP / SigLIP (contrastivo imagem-texto), e SAM-2 (modelo fundacional de segmentação) — que seguem naturalmente do arco de fome de dados / eficiência de dados que este capítulo acabou de desenvolver.

8. Swin Transformer V2: priors convolucionais retornam

O ViT apostou que escalar dados poderia substituir viés indutivo. Uma linha paralela de pesquisa apostou o oposto: que re-introduzir estrutura de estilo convolucional no Transformer encoder compensaria em tarefas de predição densa (detecção de objetos, segmentação semântica) e em altas resoluções, onde a attention global de custo quadrático do ViT vanilla torna-se proibitiva. O Swin Transformer de Liu et al. é a instância canônica dessa linha, e o Swin Transformer V2 é seu sucessor escalado [src_042].

Os dois movimentos arquiteturais do Swin são hierarquia e localidade. Em vez da sequência plana do ViT de \(N\) patches em uma única resolução, o Swin constrói uma pirâmide de atributos: tokens são fundidos entre estágios de modo que a resolução espacial cai pela metade e a dimensão do canal dobra, mimetizando o downsampling estágio-por-estágio de um ResNet. Dentro de cada estágio, self-attention é computada apenas dentro de janelas não sobrepostas de tamanho fixo, e blocos consecutivos alternam entre partições de janela regulares e deslocadas para que a informação eventualmente se propague entre janelas.

🎯 Intuição

Imagine uma grade \(4 \times 4\) de janelas ladrilhando a imagem no bloco \(N\); no bloco \(N+1\) a grade é deslocada por metade de uma janela em cada dimensão, de modo que cada nova janela atravessa quatro janelas antigas. Após dois blocos consecutivos, cada janela "viu" alguma informação de cada um de seus vizinhos diagonais, ainda que nenhum bloco individual compute attention entre janelas.

O Transformer encoder vanilla é recuperado como o limite de uma janela cobrindo toda a imagem; a window attention do Swin é o compromisso de engenharia que devolve localidade e equivariância translacional ao orçamento de viés indutivo [src_042].

O Swin V2 mira especificamente em escala. Três mudanças carregam o peso: uma configuração residual-post-norm combinada com scaled cosine attention para controlar amplitudes de ativação em profundidade (modelos grandes do Swin V1 exibiam o crescimento de magnitude de ativação entre layers que motiva muitos resgates post-norm na literatura); um log-spaced continuous position bias que torna modelos pré-treinados transferíveis entre tamanhos de janela sem o hack de interpolação bicúbica; e um estágio de pretraining auto-supervisionado SimMIM que reduz o requisito de dados rotulados [src_042]. O resultado agregado é um modelo de visão denso de 3 bilhões de parâmetros treinado a 1.536 x 1.536 de resolução, que os autores descrevem como o maior modelo de visão denso de seu tempo e que estabeleceu recordes então-correntes em classificação ImageNet-V2, detecção COCO, segmentação ADE20K, e reconhecimento de ação Kinetics-400 [src_042]. Pedagogicamente, o Swin V2 é melhor lido como a demonstração de que a aposta do ViT não é o único ponto na curva de design: re-introduzir estrutura compensa em reconhecimento de granularidade fina e alta resolução, onde o trade-off dados-viés se desloca.

🔄 Recapitulação

• Explique: Que mecanismo faz o resultado dados-supera-viés disparar em escala JFT-300M e não no ImageNet-1k? Use o trade-off viés-variância em sua resposta.
• Preveja: Dado um corpus ImageNet-21k de 14M imagens e ViT-Base, augmentation no estilo DeiT (RandAugment, Mixup, CutMix, random erasing, token de destilação) ainda seria necessária para igualar uma baseline CNN nesse tamanho de corpus?
• Compare: Para uma tarefa de predição densa em alta resolução (segmentação semântica a \(1{.}024 \times 1{.}024\)), você preferiria o ViT-L/14 puro ou um encoder Swin V2, e por quê? Enquadre a resposta em termos de assimetria de custo de attention e oferta de viés indutivo.

9. ViT em 2026

Cinco anos depois, o quadro se clarificou. ViT vanilla — patch embedding, token [CLS], position embedding absoluto aprendível, Transformer encoder vanilla — permanece o backbone CV dominante para pretraining auto-supervisionado e para o lado de visão de modelos multimodais, e as variantes arquiteturais que re-introduzem estrutura convolucional ocupam um nicho complementar em vez de deslocá-lo. O survey de 2023 de Courant et al. trata essa convergência como o estado estacionário do campo: encoders da classe ViT absorveram a maior parte do momentum de pesquisa em aprendizado de representação, enquanto encoders da classe Swin retêm uma vantagem em predição densa de alta resolução [src_009].

Os impulsionadores da persistência do ViT vanilla são pragmáticos. Métodos auto-supervisionados que operam por patch masking, em particular o MAE (o tópico do Capítulo 6), são mais fáceis de formular sobre uma sequência plana de patches; o design assimétrico de encoder–decoder que torna o MAE eficiente depende do encoder ver apenas um subconjunto de tokens, o que um backbone hierárquico no estilo Swin torna mais difícil. Modelos multimodais visão-linguagem — SigLIP, CLIP, e os encoders de visão usados dentro dos VLMs de pesos abertos de 2024–2026 — quase universalmente tokenizam uma imagem como uma sequência plana de patches e alimentam o token [CLS] ou um conjunto agrupado de patch tokens em uma projeção alinhada com texto. E na fronteira da escalabilidade de dados de pretraining, ViT-L/14 ou ViT-G/14 puros com corpora de pretraining maiores consistentemente batem variantes arquiteturais espertas treinadas em corpora menores; a história dados-supera-viés do paper original, se algo, fortaleceu-se a cada ano subsequente.

🔗 Conexão

CLIP, SigLIP, e os VLMs de pesos abertos de 2024–2026 nomeados aqui são desenvolvidos no Capítulo 6; este capítulo os usa apenas como exemplos do padrão ViT-puro-como-encoder-de-visão. VLMs (modelos visão-linguagem) em si estão fora do escopo deste livro.

Duas qualificações. Primeiro, o bloco encoder no ViT vanilla moderno não é mais o bloco LayerNorm-e-GELU de 2020; receitas modernas rotineiramente trocam LayerNorm por RMSNorm e a FFN GELU por SwiGLU, exatamente como em LLMs decoder-only modernos. O front-end de patch, token [CLS], position embedding absoluto aprendível, e esqueleto geral de residual stream permanecem inalterados. Segundo, o gap de position embedding entre o ViT e LLMs decoder-only começou a fechar pelo lado dos LLMs: variantes rotativas para visão existem (RoPE-2D, RoPE axial) e estão lentamente deslocando embeddings absolutos aprendíveis em código de pesquisa, particularmente quando modelos precisam operar em resoluções variáveis.

⚠️ Armadilha

RoPE-2D e RoPE axial são extensões 2-D do rotary position encoding (Capítulo 2). Eles não são cobertos em detalhe em nenhum lugar deste livro; a menção na §9 é um ponteiro adiante, não uma definição. Um leitor implementando-os hoje deve consultar os papers primários relevantes.

A partir de 2026 essa transição ainda não é universal, e uma implementação ViT baseline ainda pode usar com segurança o esquema aprendível original.

⚠️ Armadilha

Quando este capítulo diz "ViT vanilla" significa o front-end de patch / [CLS] / position embedding absoluto aprendível / esqueleto de residual stream — NÃO necessariamente o bloco encoder LayerNorm-e-GELU de 2020. Na prática moderna (2024–2026) o bloco encoder é RMSNorm + SwiGLU + (opcionalmente) RoPE-2D, exatamente como em LLMs decoder-only modernos.

10. Resumo e ponteiro adiante

Vision Transformers transformam uma imagem em uma sequência de tokens cortando-a em patches não sobrepostos, projetando linearmente cada patch para um vetor de dimensão \(D\), prefixando um token [CLS] aprendível, e adicionando um position embedding absoluto aprendível. O patch embedding é matematicamente equivalente a um único Conv2d com tamanho de kernel e stride ambos iguais ao tamanho do patch \(P\), e essa equivalência é o que código de produção usa. O encoder downstream é o Transformer encoder do Capítulo 1 sem modificações específicas para visão.

A afirmação substantiva do paper original do ViT foi empírica: em escala suficiente de pretraining (corpora da classe JFT-300M), Transformers puros igualam ou excedem as baselines convolucionais mais fortes em reconhecimento de imagens enquanto usam menos computação de pretraining, apesar de carregarem menos viés indutivo específico de imagem [src_013]. Em escalas menores de pretraining o gap de viés machuca e CNNs vencem; o resultado de fome de dados é a afirmação pedagógica que sustenta o argumento, não a elegância arquitetural. O DeiT mostrou posteriormente que o requisito de dados era um artefato da receita de pretraining supervisionado em vez da arquitetura, e o Swin Transformer V2 mostrou que re-introduzir priors convolucionais compensa em alta resolução e em tarefas de predição densa [src_042].

O Capítulo 6 retoma onde este capítulo termina. Uma vez que a arquitetura está estabelecida, a questão é como pré-treiná-la sem rótulos. O MAE reconstrói a receita de predição mascarada estilo BERT sobre patches. O DINOv2 treina discriminativamente sem supervisão de texto e iguala atributos da classe CLIP. O SigLIP substitui o softmax contrastivo por uma loss sigmoid e desacopla a loss do batch global. O SAM-2 toma um encoder da classe ViT e o transforma em um modelo fundacional de segmentação de vídeo. Todos os quatro situam-se sobre a arquitetura que este capítulo construiu.

🔄 Recapitulação

• Complete: Em uma frase, enuncie o que é preservado e o que é trocado entre um ViT vanilla de 2020 e um ViT vanilla moderno de 2026.
• Explique: Por que o ViT vanilla permanece o backbone CV dominante para pretraining auto-supervisionado e para o lado de visão de modelos multimodais, apesar das vantagens do Swin em tarefas de predição densa em alta resolução?
• Preveja: Se uma equipe de pesquisa em 2026 escolhe o ViT-L/14 puro em vez do Swin V2 para uma nova execução de pretraining auto-supervisionado em um corpus de 1B imagens, qual é a razão mais provável — liste pelo menos dois dos impulsionadores pragmáticos que o capítulo nomeou.
• Gere: Em suas próprias palavras, escreva um parágrafo enunciando a afirmação central do capítulo sobre o ViT — cobrindo o front-end de patch / reuso do encoder do Cap.1 / fome de dados / DeiT / contraponto Swin e o escopo do bloco ViT moderno.

Referências

• [src_001] Bishop, C. M., & Bishop, H. (2024). Deep Learning: Foundations and Concepts. Springer. https://www.bishopbook.com/
• [src_008] Torralba, A., Isola, P., & Freeman, W. T. (2024). Foundations of Computer Vision. MIT Press. https://visionbook.mit.edu/
• [src_009] Courant, R., Edberg, M., Dufour, N., & Kalogeiton, V. (2023). Transformers and Visual Transformers. In Machine Learning for Brain Disorders (Humana/Springer). https://doi.org/10.1007/978-1-0716-3195-9_6
• [src_013] Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., Uszkoreit, J., & Houlsby, N. (2020). An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale. arXiv:2010.11929. https://arxiv.org/pdf/2010.11929
• [src_042] Liu, Z., Hu, H., Lin, Y., Yao, Z., Xie, Z., Wei, Y., Ning, J., Cao, Y., Zhang, Z., Dong, L., Wei, F., & Guo, B. (2022). Swin Transformer V2: Scaling Up Capacity and Resolution. arXiv:2111.09883. https://arxiv.org/pdf/2111.09883
• [src_048] Krig, S. (2025). Computer Vision Metrics — Ch. 11: Attention, Transformers, Hybrids, and DDNs. Springer. Survey supplement; cited as a taxonomy pointer for further reading. https://doi.org/10.1007/978-981-99-3393-8_11
• [src_050] Touvron, H., Cord, M., Douze, M., Massa, F., Sablayrolles, A., & Jégou, H. (2021). Training data-efficient image transformers & distillation through attention. arXiv:2012.12877 (ICML 2021). https://arxiv.org/pdf/2012.12877