Transformer (aprendizado profundo) 📖 Wikipedia

Este artigo ou parte dele incorpora textos gerados por inteligência artificial.

No aprendizado profundo, o transformer ou transformador é uma arquitetura de rede neural artificial baseada no mecanismo de atenção multicabeça (multi-head), em que o texto é convertido em representações numéricas chamadas tokens, e cada token é convertido num vetor através da procura numa tabela de embedding de palavras.^[1] Em cada camada, cada token é então contextualizado dentro do escopo da janela de contexto com outros tokens (não mascarados) através de um mecanismo de atenção multicabeça paralelo, permitindo que o sinal dos tokens-chave seja amplificado e o dos tokens menos importantes seja diminuído.

Os transformers têm a vantagem de não terem unidades recorrentes, necessitando por isso de menos tempo de treinamento do que as arquiteturas neurais recorrentes (RNNs) anteriores, como a LSTM.^[2] Variações posteriores têm sido amplamente adotadas para o treinamento de grandes modelos de linguagem (LLMs) em grandes conjuntos de dados (de linguagem).^[3]

A versão moderna do transformer foi proposta no artigo de 2017 "Attention Is All You Need" por investigadores da Google.^[1] Os antecessores dos transformers foram desenvolvidos como uma melhoria em relação às arquiteturas anteriores para tradução automática,^[4][5] mas desde então têm encontrado muitas aplicações. São utilizados no processamento de linguagem natural em larga escala, em visão computacional (Transformer de Visão), na aprendizagem por reforço,^[6][7] em áudio,^[8] na aprendizagem multimodal, na robótica,^[9] e para jogar xadrez.^[10] Também levaram ao desenvolvimento de sistemas pré-treinados, tais como os transformers pré-treinados generativos (GPTs)^[11] e o BERT^[12] (representações de codificador bidirecional de transformers).

Durante muitos anos, a modelagem e geração de sequências foi feita usando redes neurais recorrentes (RNNs) simples. Um exemplo inicial muito citado foi a Rede de Elman (1990). Em teoria, a informação de um token pode propagar-se arbitrariamente ao longo da sequência, mas, na prática, o problema do desvanecimento do gradiente deixa o estado do modelo, no final de uma frase longa, sem informações precisas e extraíveis sobre os tokens anteriores.

Um avanço fundamental foi a LSTM (1995),^{[nota 1]} uma RNN que utilizou várias inovações para superar o problema do desvanecimento do gradiente, permitindo a aprendizagem eficiente na modelagem de sequências longas. Uma inovação fundamental foi o uso de um mecanismo de atenção que utilizava neurônios que multiplicam as saídas de outros neurônios, as chamadas unidades multiplicativas.^[13] Redes neurais usando unidades multiplicativas foram mais tarde chamadas de redes sigma-pi^[14] ou redes de ordem superior.^[15] A LSTM tornou-se a arquitetura padrão para modelagem de sequências longas até à publicação dos transformers em 2017. No entanto, a LSTM ainda usava processamento sequencial, como a maioria das outras RNNs.^{[nota 2]} Especificamente, as RNNs operam um token de cada vez, do primeiro ao último; elas não podem operar em paralelo sobre todos os tokens de uma sequência.

Os transformers modernos superam este problema, mas, ao contrário das RNNs, exigem um tempo de computação que é uma função quadrática do tamanho da janela de contexto. O controlador de pesos rápidos de escala linear (1992) aprende a calcular uma matriz de pesos para processamento adicional, dependendo da entrada.^[16] Uma das suas duas redes tem "pesos rápidos" ou "links dinâmicos" (1981).^[17][18][19] Uma rede neural lenta aprende por descida de gradiente a gerar chaves e valores para calcular as mudanças de peso da rede neural rápida que calcula respostas a consultas.^[16] Mais tarde, demonstrou-se que isso era equivalente ao transformer linear não normalizado.^[20][21]

A ideia de transdução de sequência codificador-decodificador foi desenvolvida no início da década de 2010; comumente citados como os originadores que produziram seq2seq estão dois artigos publicados simultaneamente em 2014.^[22][23]

Um modelo de 380 milhões de parâmetros para tradução automática utiliza duas memórias curtas de longo prazo (LSTM).^[23] A sua arquitetura consiste em duas partes. O codificador é uma LSTM que recebe uma sequência de tokens e transforma-a num vetor. O decodificador é outra LSTM que converte o vetor numa sequência de tokens. Da mesma forma, outro modelo de 130 milhões de parâmetros utilizou unidades recorrentes bloqueadas (GRU) em vez de LSTM.^[22] Pesquisas posteriores mostraram que as GRUs não são nem melhores nem piores do que as LSTMs para seq2seq.^[24][25]

Estes primeiros modelos seq2seq não possuíam mecanismo de atenção e o vetor de estado só é acessível após o processamento da última palavra do texto de origem. Embora, em teoria, esse vetor retenha a informação sobre toda a frase original, na prática a informação é mal preservada. Isso ocorre porque a entrada é processada sequencialmente por uma rede recorrente num vetor de saída de tamanho fixo, que é então processado por outra rede recorrente numa saída. Se a entrada for longa, o vetor de saída não seria capaz de conter todas as informações relevantes, degradando a saída. Como evidência, a inversão da frase de entrada melhorou a tradução seq2seq.^[26]

O modelo RNN search introduziu um mecanismo de atenção ao seq2seq para a tradução automática, a fim de resolver o problema de estrangulamento (bottleneck) (do vetor de saída de tamanho fixo), permitindo ao modelo processar dependências de longa distância com mais facilidade. O nome deve-se ao fato de que ele "emula a pesquisa através de uma frase de origem durante a decodificação de uma tradução".^[4]

Os desempenhos relativos foram comparados entre as arquiteturas do modelo de atenção global (a do RNN search) e local (janela deslizante) para tradução automática, concluindo-se que a atenção mista apresentava maior qualidade do que a atenção global, ao passo que a atenção local reduzia o tempo de tradução.^[27]

Em 2016, o Google Tradutor foi remodelado para a Tradução Automática Neural do Google, o que substituiu o modelo anterior baseado na tradução automática estatística. O novo modelo era um modelo seq2seq em que o codificador e o decodificador eram ambos compostos por 8 camadas de LSTM bidirecional.^[28] Demorou nove meses a ser desenvolvido, e superou a abordagem estatística, que demorou dez anos a ser desenvolvida.^[29]

Os modelos seq2seq com atenção (incluindo a autoatenção) continuavam a sofrer do mesmo problema das redes recorrentes: são difíceis de paralelizar, o que os impedia de serem acelerados em GPUs. Em 2016, a atenção decomponível aplicou um mecanismo de autoatenção às redes feedforward, que são fáceis de paralelizar, e alcançou um resultado no estado da arte em implicação textual com uma ordem de grandeza de parâmetros menor do que as LSTMs.^[30] Um de seus autores, Jakob Uszkoreit, suspeitava que a atenção sem recorrência seria suficiente para a tradução de idiomas, daí o título "a atenção é tudo o que você precisa".^[31] Essa hipótese ia contra o conhecimento convencional da época, e até o seu pai, Hans Uszkoreit, um linguista computacional conhecido, estava cético.^[31] No mesmo ano, propôs-se a autoatenção (chamada intra-atenção ou atenção intra-frase) para LSTMs.^[32]

Em 2017, o modelo original codificador-decodificador de transformer (de tamanho 100M) foi proposto no artigo "Attention Is All You Need". Na altura, o foco da pesquisa incidia sobre a melhoria da seq2seq para a tradução automática, removendo a sua recorrência para processar todos os tokens em paralelo, mas preservando o seu mecanismo de atenção de produto escalar (dot-product) para manter o seu desempenho no processamento de texto.^[1] Isso levou à introdução de um modelo de atenção multicabeça (multi-head) que era mais fácil de paralelizar devido ao uso de cabeças independentes e à ausência de recorrência. A sua capacidade de paralelização foi um fator importante para o seu uso generalizado em grandes redes neurais.^[33]

Já na primavera de 2017, mesmo antes de o pré-print "Attention is all you need" ser publicado, um dos coautores aplicou a variação "somente-decodificador" (decoder-only) da arquitetura para gerar artigos fictícios da Wikipédia.^[34] A arquitetura Transformer é agora usada juntamente com muitos modelos generativos que contribuem para o atual boom da IA.

Na modelagem de linguagem, o ELMo (2018) era uma LSTM bidirecional que produzia embeddings de palavras contextualizados, melhorando a linha de pesquisa a partir de saco de palavras e word2vec. Foi seguido pelo BERT (2018), um modelo transformer apenas de codificador.^[35] Em outubro de 2019, o Google começou a utilizar o BERT para processar consultas de pesquisa.^[36] Em 2020, o Google Tradutor substituiu o modelo anterior de codificador RNN-decodificador RNN por um modelo codificador transformer-decodificador RNN.^[37]

A partir de 2018, a série GPT da OpenAI, de transformers apenas decodificadores, tornou-se o estado da arte em geração de linguagem natural. No final de 2022, um chatbot baseado no GPT-3, o ChatGPT, tornou-se inesperadamente^[38] popular, desencadeando um boom em torno de grandes modelos de linguagem.^[39][40]

Desde 2020, os transformers têm sido aplicados em modalidades além do texto, incluindo o transformer de visão,^[41] reconhecimento de fala,^[42] robótica^[6] e de forma multimodal.^[43] O transformer de visão, por sua vez, estimulou novos desenvolvimentos nas redes neurais convolucionais.^[44] Geradores de imagem e vídeo como DALL-E (2021), Stable Diffusion 3 (2024)^[45] e Sora (2024), usam transformers para analisar dados de entrada (como prompts de texto) ao dividi-los em "tokens" e, em seguida, calculando a relevância entre cada token usando autoatenção, o que ajuda o modelo a compreender o contexto e os relacionamentos dentro dos dados.

A arquitetura transformer simples tinha dificuldade em convergir. No artigo original,^[1] os autores recomendaram o uso de aquecimento (warmup) da taxa de aprendizagem. Ou seja, a taxa de aprendizagem deve aumentar linearmente de 0 até ao valor máximo durante a primeira parte do treinamento (geralmente recomendado como sendo **2%** do número total de passos de treinamento), antes de decair novamente.

Um artigo de 2020 descobriu que o uso de normalização de camada antes (em vez de depois) da atenção multicabeça e das camadas feedforward estabiliza o treinamento, não exigindo o aquecimento da taxa de aprendizagem.^[46] Este é o "Transformer pre-LN" e é mais comumente usado, em comparação com o original "Transformer post-LN".

Os transformers são normalmente pré-treinados primeiro por aprendizagem autosupervisionada num grande conjunto de dados genérico, seguido por um ajuste fino supervisionado num pequeno conjunto de dados específico da tarefa. O conjunto de dados de pré-treinamento é normalmente um grande corpus não rotulado, como The Pile. As tarefas para pré-treinamento e ajuste fino incluem frequentemente:

• Modelagem de linguagem^[12]
• Previsão da frase seguinte^[12]
• Resposta a perguntas^[3]
• Compreensão de leitura
• Análise de sentimento^[1]
• Parafraseamento^[1]

O relatório do transformer T5^[47] documenta um grande número de tarefas de pré-treinamento em linguagem natural. Alguns exemplos são:

• restauração ou reparação de texto incompleto ou corrompido. Por exemplo, a entrada, "Obrigado ___ mim para a sua festa ___ semana", poderia gerar a saída, "Obrigado por convidar-mim para a sua festa na última semana".
• tradução entre linguagens naturais (tradução automática)
• julgar a aceitabilidade pragmática da linguagem natural. Por exemplo, a seguinte frase pode ser julgada como "não aceitável",^[48] porque, mesmo sendo sintaticamente bem formada, é improvável no uso humano comum: O curso está a saltar bem.

Note que, embora cada uma destas tarefas seja trivial ou óbvia para falantes nativos humanos do idioma (ou idiomas), elas normalmente provaram ser desafiadoras para as gerações anteriores de arquiteturas de aprendizado de máquina.

Em geral, existem 3 classes de tarefas de modelagem de linguagem: "mascarada" (masked),^[49] "autorregressiva",^[50] e "prefixLM".^[51] Estas classes são independentes de uma arquitetura de modelagem específica, como o transformer, mas são frequentemente discutidas no contexto do transformer.

Numa tarefa mascarada,^[49] um ou mais dos tokens são mascarados, e o modelo produziria uma distribuição de probabilidade prevendo quais são os tokens mascarados com base no contexto. A função de perda para a tarefa é tipicamente a soma das log-perplexidades para os tokens mascarados: $${\displaystyle {\text{Perda}}=-\sum _{t\in {\text{tokens mascarados}}}\ln({\text{probabilidade de }}t{\text{ condicionada ao seu contexto}})}$$ e o modelo é treinado para minimizar esta função de perda. A série de modelos BERT é treinada para a previsão de tokens mascarados e para uma outra tarefa.

Numa tarefa autorregressiva,^[50] toda a sequência é mascarada no início, e o modelo produz uma distribuição de probabilidade para o primeiro token. Depois, o primeiro token é revelado e o modelo prevê o segundo token, e assim por diante. A função de perda para a tarefa continua a ser tipicamente a mesma. A série de modelos GPT é treinada por tarefas autorregressivas.

Numa tarefa prefixLM,^[51] a sequência é dividida em duas partes. A primeira parte é apresentada como contexto, e o modelo prevê o primeiro token da segunda parte. Depois, este seria revelado, e o modelo prevê o segundo token, e assim por diante. A função de perda para a tarefa continua a ser tipicamente a mesma. A série de modelos T5 é treinada por tarefas prefixLM.

Note que "mascarada" (masked) como em "modelagem de linguagem mascarada" não é "mascarada" como em "atenção mascarada", e "prefixLM" como em "modelagem de linguagem de prefixo" não é "prefixLM" como em "modelo de linguagem de prefixo".

Todos os transformers têm os mesmos componentes principais:

• Tokenizadores (Tokenizers), que convertem texto em tokens.
• Camada de embedding, que converte tokens e as posições dos tokens em representações vetoriais.
• Camadas do transformer, que realizam transformações repetidas nas representações vetoriais, extraindo cada vez mais informações linguísticas. Estas consistem em camadas alternadas de atenção e feedforward (alimentação direta). Existem dois tipos principais de camadas de transformer: camadas codificadoras (encoder) e camadas decodificadoras (decoder), com outras variantes.
• Camada de des-embedding (Un-embedding), que converte as representações vetoriais finais de volta numa distribuição de probabilidade sobre os tokens.

A descrição a seguir segue exatamente o transformer conforme descrito no artigo original. Existem variantes, descritas na seção seguinte.

Por convenção, escrevemos todos os vetores como vetores linha. Por exemplo, passar um vetor por uma camada linear significa multiplicá-lo por uma matriz de pesos à direita, como ${\displaystyle xW}$.

Como a arquitetura transformer consiste nativamente em operações sobre números (multiplicações de matrizes, produtos escalares, funções de ativação) em vez de texto, deve haver primeiro um mapeamento de qualquer texto de entrada para alguma representação numérica. Isso ocorre em três etapas.

Primeiro, o texto de entrada é tratado por um pré-processador, que realiza transformações textuais e divide o texto em segmentos de granulação grossa chamados pré-tokens. Este último processo é referido como pré-tokenização. Em segundo lugar, cada pré-token é segmentado ainda mais em tokens por um tokenizador que espera ver apenas pré-tokens emitidos pelo seu pré-processador. Cada token que ele produz é uma cadeia (string) de um ou mais caracteres pertencentes a um conjunto finito de cadeias chamado de vocabulário ${\displaystyle V}$. Em terceiro lugar, como o vocabulário é finito e conhecido de antemão, cada token pode receber um identificador inteiro, e este mapeamento é aplicado à sequência de tokens para representar qualquer texto de entrada como uma sequência numérica. Como este mapeamento é bijetivo, o lado de saída pode produzir uma sequência de identificadores inteiros que podem então ser transformados de volta em tokens. Após desfazer parte do pré-processamento, o resultado é novamente um texto legível.

Treinar um tokenizador (às vezes referido como vocabularização) significa encontrar um vocabulário adequado ${\displaystyle V}$, mas também aprender como usá-lo, uma vez que qualquer cadeia ${\displaystyle s}$ dada de comprimento ${\displaystyle |s|}$ tem ${\displaystyle 2^{|s|-1}}$ segmentações hipotéticas, algumas das quais contendo segmentos que não estão no vocabulário. O hiperparâmetro mais importante durante a vocabularização é o tamanho do vocabulário ${\displaystyle |V|}$: quando é pequeno, o vocabulário aprendido geralmente consiste em caracteres e cadeias menores, e as palavras serão segmentadas em muitos tokens. Em tamanhos maiores, torna-se acessível dedicar tokens a palavras completas, embora, dependendo do pré-processador e do tokenizador, não seja necessariamente o caso de que grandes vocabulários usarão sempre o(s) maior(es) token(s) disponível(eis) para segmentar uma palavra.

Como os tokens nem sempre são palavras completas, eles também podem ser chamados de subpalavras (subwords) e os algoritmos de tokenização podem ser referidos como tokenizadores de subpalavras. Isso também serve para diferenciar estes sistemas da terminologia tradicional usada em sistemas mais antigos de recuperação de informação e processamento de linguagem natural, onde a "tokenização" era usada para denotar o que hoje é chamado de "pré-tokenização" (muito rudemente: divisão em palavras). Nos tokenizadores que produzem tokens que não fazem parte do vocabulário, um token especial que pertence ao vocabulário é usado como um substituto genérico, escrito como "[UNK]" para "unknown" (desconhecido). Em princípio, qualquer cadeia poderia ser ocultada por um [UNK] desse tipo. De fato, na recuperação de informação, os pré-tokenizadores eram eles próprios usados como tokenizadores (e também chamados de "tokenizadores") com um vocabulário ao nível da palavra que continha um [UNK].

Os algoritmos de tokenização de subpalavras comumente usados são a codificação de pares de bytes (BPE) e o modelo de linguagem unigrama (ULM), que incluem, cada um, um algoritmo de vocabularização e um algoritmo de segmentação dedicado. Também existem vários algoritmos de segmentação que não requerem aprendizagem e podem ser aplicados dado um vocabulário (produzido por BPE ou ULM, por exemplo), como reconhecer gulosamente (greedily) tokens num pré-token movendo-se através dele da esquerda para a direita. Implementações de software bem conhecidas de tokenizadores de subpalavras são o pacote Python tokenizers da Hugging Face implementado em Rust, e o pacote Python sentencepiece implementado em C++. Este último pacote tem esse nome porque uma das suas opções de configuração permite desativar o pré-tokenizador integrado, tornando efetivamente frases inteiras um pré-token e, assim, fazendo com que o tokenizador veja frases inteiras, em vez de palavras individuais.

Cada identificador de token inteiro é convertido num vetor de embedding através de uma tabela de pesquisa (lookup table). De forma equivalente, multiplica uma representação one-hot do identificador do token por uma matriz de embedding ${\displaystyle M}$. Por exemplo, se o identificador do token de entrada é ${\displaystyle 3}$, então a representação one-hot é ${\displaystyle [0,0,0,1,0,0,\dots ]}$, e o seu vetor de embedding é: $${\displaystyle \mathrm {Embed} (3)=[0,0,0,1,0,0,\dots ]M}$$ Os vetores de embedding de tokens são adicionados aos seus respetivos vetores de codificação posicional (ver abaixo), produzindo a sequência de vetores de entrada.

A dimensão de um vetor de embedding é chamada de tamanho oculto (hidden size) ou tamanho do embedding e escrita como ${\displaystyle d_{\text{emb}}}$.^[35] Este tamanho é escrito como ${\displaystyle d_{\text{model}}}$ no artigo original do transformer.^[1]

Uma camada de des-embedding (un-embedding) é quase o inverso de uma camada de embedding. Enquanto uma camada de embedding converte um identificador de token num vetor, uma camada de des-embedding converte um vetor numa distribuição de probabilidade sobre os tokens.

A camada de des-embedding é uma camada linear-softmax: $${\displaystyle \mathrm {UnEmbed} (x)=\mathrm {softmax} (xW+b)}$$ A matriz tem formato ${\displaystyle (d_{\text{emb}},|V|)}$. Algumas arquiteturas usam a transposta da matriz de embedding ${\displaystyle M}$ como a matriz de des-embedding ${\displaystyle W}$ para evitar a necessidade de duplicar a quantidade de parâmetros relacionados com o embedding e para evitar a divergência durante o treinamento. Esta prática é chamada de amarração de pesos (weight tying).^[52]

Uma codificação posicional é uma representação vetorial de tamanho fixo das posições relativas dos tokens dentro de uma sequência: ela fornece ao modelo transformer informações sobre onde as palavras estão na sequência de entrada. Isso induz um viés indutivo em relação à ordem da sequência de entrada, de modo que, por exemplo, a sequência de entrada "o cão morde o homem" é processada de forma diferente de "o homem morde o cão".

A codificação posicional é definida como uma função do tipo ${\displaystyle f:\mathbb {R} \to \mathbb {R} ^{d}}$, onde ${\displaystyle d}$ é um inteiro positivo e par. A codificação posicional completa definida no artigo original^[1] é: $${\displaystyle (f(t)_{2k},f(t)_{2k+1})=(\sin(\theta ),\cos(\theta ))\quad \forall k\in \{0,1,\ldots ,d/2-1\}}$$ onde ${\displaystyle \theta ={\frac {t}{r^{k}}},r=N^{2/d}}$.

Aqui, ${\displaystyle N}$ é um parâmetro livre que deve ser significativamente maior do que o maior ${\displaystyle k}$ que seria inserido na função de codificação posicional. O artigo original usa ${\displaystyle N=10000}$.

A função fica numa forma mais simples quando escrita como uma função complexa do tipo ${\displaystyle f:\mathbb {R} \to \mathbb {C} ^{d/2}}$ $${\displaystyle f(t)=\left(e^{it/r^{k}}\right)_{k=0,1,\ldots ,{\frac {d}{2}}-1}}$$ onde ${\displaystyle r=N^{2/d}}$.

A principal razão para usar esta função de codificação posicional é que, com ela, os deslocamentos (shifts) são transformações lineares: $${\displaystyle f(t+\Delta t)=\mathrm {diag} (f(\Delta t))f(t)}$$ onde ${\displaystyle \Delta t\in \mathbb {R} }$ é a distância que se deseja deslocar. Isso permite que o transformer pegue em qualquer posição codificada e encontre a codificação da posição n-passos-à-frente ou n-passos-atrás, através de uma multiplicação de matrizes.

Ao fazer uma soma linear, qualquer convolução também pode ser implementada como transformações lineares: $${\displaystyle \sum _{j}c_{j}f(t+\Delta t_{j})=\left(\sum _{j}c_{j}\,\mathrm {diag} (f(\Delta t_{j}))\right)f(t)}$$ para quaisquer constantes ${\displaystyle c_{j}}$. Isso permite que o transformer pegue em qualquer posição codificada e encontre uma soma linear das localizações codificadas dos seus vizinhos. Esta soma de posições codificadas, quando alimentada no mecanismo de atenção, criaria pesos de atenção nos seus vizinhos, de forma muito semelhante ao que acontece num modelo de linguagem de rede neural convolucional. Nas palavras dos autores, "nós hipotetizámos que isso permitiria ao modelo aprender facilmente a atender por posição relativa."

Em implementações típicas, todas as operações são feitas sobre os números reais, não os números complexos, mas como a multiplicação complexa pode ser implementada como multiplicação de matrizes reais 2 por 2, esta é uma mera diferença notacional.

Como os modelos seq2seq anteriores, o modelo transformer original usava uma arquitetura de codificador-decodificador. O codificador consiste em camadas de codificação que processam todos os tokens de entrada juntos, uma camada após a outra, enquanto o decodificador consiste em camadas de decodificação que processam iterativamente a saída do codificador e os tokens de saída do decodificador até ao momento.

O propósito de cada camada codificadora é criar representações contextualizadas dos tokens, onde cada representação corresponde a um token que "mistura" informações de outros tokens de entrada através do mecanismo de autoatenção. Cada camada decodificadora contém duas subcamadas de atenção: (1) atenção cruzada (cross-attention) para incorporar a saída do codificador (representações contextualizadas de tokens de entrada), e (2) autoatenção (self-attention) para "misturar" informações entre os tokens de entrada para o decodificador (ou seja, os tokens gerados até ao momento durante o tempo de inferência).^[53][54]

Tanto as camadas do codificador quanto as do decodificador possuem uma rede neural feedforward para processamento adicional das suas saídas e contêm conexões residuais e etapas de normalização de camada.^[54] Estas camadas feedforward contêm a maior parte dos parâmetros num modelo transformer.

Os módulos de rede feedforward (FFN) num transformer são perceptrons multicamadas de 2 camadas: $${\displaystyle \mathrm {FFN} (x)=\phi (xW^{(1)}+b^{(1)})W^{(2)}+b^{(2)}}$$ onde ${\displaystyle W^{(1)}}$ e ${\displaystyle W^{(2)}}$ são matrizes de pesos e ${\displaystyle b^{(1)}}$ e ${\displaystyle b^{(2)}}$ são vetores de viés (bias), e ${\displaystyle \phi }$ é a sua função de ativação. O transformer original usou a ativação ReLU.

O número de neurônios na camada intermediária é chamado de tamanho intermediário (GPT),^[55] tamanho do filtro (BERT),^[35] ou tamanho do feedforward (BERT).^[35] Ele é tipicamente maior que o tamanho do embedding. Por exemplo, tanto na série GPT-2 quanto na série BERT, o tamanho intermediário de um modelo é 4 vezes o seu tamanho de embedding: ${\displaystyle d_{\text{ffn}}=4d_{\text{emb}}}$.

O mecanismo de atenção usado na arquitetura transformer são unidades de atenção de produto escalar escalonado. Para cada unidade, o modelo transformer aprende três matrizes de pesos: os pesos de consulta (query) ${\displaystyle W^{Q}}$, os pesos de chave (key) ${\displaystyle W^{K}}$ e os pesos de valor (value) ${\displaystyle W^{V}}$.

O módulo recebe três sequências: uma sequência de consulta, uma sequência de chave e uma sequência de valor. A sequência de consulta é uma sequência de comprimento ${\displaystyle \ell _{\text{seq, query}}}$, e cada entrada é um vetor de dimensão ${\displaystyle d_{\text{emb, query}}}$. O mesmo se aplica às sequências de chave e de valor.

Para cada vetor ${\displaystyle x_{i,{\text{query}}}}$ na sequência de consulta, ele é multiplicado por uma matriz ${\displaystyle W^{Q}}$ para produzir um vetor de consulta ${\displaystyle q_{i}=x_{i,{\text{query}}}W^{Q}}$. A matriz de todos os vetores de consulta é a matriz de consulta: $${\displaystyle Q=X_{\text{query}}W^{Q}}$$ Da mesma forma, construímos a matriz de chaves ${\displaystyle K=X_{\text{key}}W^{K}}$ e a matriz de valores ${\displaystyle V=X_{\text{value}}W^{V}}$.

Geralmente, todos os ${\displaystyle W^{Q},W^{K},W^{V}}$ são matrizes quadradas, o que significa que ${\displaystyle d_{\text{emb, query}}=d_{\text{query}}}$, etc.

Os pesos de atenção são calculados usando os vetores de consulta e chave: o peso de atenção ${\displaystyle a_{ij}}$ do token ${\displaystyle i}$ para o token ${\displaystyle j}$ é o produto escalar entre ${\displaystyle q_{i}}$ e ${\displaystyle k_{j}}$. Os pesos de atenção são divididos pela raiz quadrada da dimensão dos vetores de chave, ${\displaystyle {\sqrt {d_{k}}}}$, o que estabiliza os gradientes durante o treinamento, e passados por uma softmax que normaliza os pesos. O facto de que ${\displaystyle W^{Q}}$ e ${\displaystyle W^{K}}$ são matrizes diferentes permite que a atenção seja não simétrica: se o token ${\displaystyle i}$ atende ao token ${\displaystyle j}$ (ou seja, ${\displaystyle q_{i}\cdot k_{j}}$ é grande), isso não significa necessariamente que o token ${\displaystyle j}$ atenderá ao token ${\displaystyle i}$ (ou seja, ${\displaystyle q_{j}\cdot k_{i}}$ pode ser pequeno). A saída da unidade de atenção para o token ${\displaystyle i}$ é a soma ponderada dos vetores de valor de todos os tokens, ponderada por ${\displaystyle a_{ij}}$, a atenção do token ${\displaystyle i}$ para cada token.

O cálculo de atenção para todos os tokens pode ser expresso como um grande cálculo de matriz usando a função softmax, o que é útil para o treinamento devido a otimizações de operações matriciais computacionais que calculam rapidamente as operações de matriz. As matrizes ${\displaystyle Q}$, ${\displaystyle K}$ e ${\displaystyle V}$ são definidas como as matrizes onde as ${\displaystyle i}$-ésimas linhas são os vetores ${\displaystyle q_{i}}$, ${\displaystyle k_{i}}$ e ${\displaystyle v_{i}}$, respetivamente. Então podemos representar a atenção como: $${\displaystyle {\begin{aligned}{\text{Attention}}(Q,K,V)={\text{softmax}}\left({\frac {QK^{\mathrm {T} }}{\sqrt {d_{k}}}}\right)V\end{aligned}}}$$

onde a softmax é aplicada sobre cada uma das linhas da matriz.

O número de dimensões num vetor de consulta é o tamanho da consulta ${\displaystyle d_{\text{query}}}$ e da mesma forma para o tamanho da chave ${\displaystyle d_{\text{key}}}$ e tamanho do valor ${\displaystyle d_{\text{value}}}$. A dimensão de saída de uma cabeça de atenção é a sua dimensão da cabeça ${\displaystyle d_{\text{head}}}$. O mecanismo de atenção requer que as seguintes três igualdades sejam válidas: $${\displaystyle \ell _{\text{seq, key}}=\ell _{\text{seq, value}},\;d_{\text{query}}=d_{\text{key}},\;d_{\text{value}}=d_{\text{head}}}$$ mas de resto não tem restrições.

Se a cabeça de atenção for usada no modo de autoatenção, então ${\displaystyle X_{\text{query}}=X_{\text{key}}=X_{\text{value}}}$. Se a cabeça de atenção for usada no modo de atenção cruzada, então geralmente ${\displaystyle X_{\text{query}}\neq X_{\text{key}}=X_{\text{value}}}$. É teoricamente possível que os três sejam diferentes, mas isso raramente acontece na prática.

Um conjunto de matrizes ${\displaystyle \left(W^{Q},W^{K},W^{V}\right)}$ é chamado de cabeça de atenção (attention head), e cada camada num modelo transformer possui múltiplas cabeças de atenção. Enquanto cada cabeça de atenção atende aos tokens que são relevantes para cada token, múltiplas cabeças de atenção permitem que o modelo faça isso para diferentes definições de "relevância". Especificamente, as matrizes de projeção de consulta e chave, ${\displaystyle W^{Q}}$ e ${\displaystyle W^{K}}$, que estão envolvidas no cálculo da pontuação de atenção, definem a "relevância". Entretanto, a matriz de projeção de valor ${\displaystyle W^{V}}$, em combinação com a parte da matriz de projeção de saída ${\displaystyle W^{O}}$, determina como os tokens atendidos influenciam quais informações são passadas para as camadas subsequentes e, finalmente, para os logits de saída. Além disso, o escopo da atenção, ou a gama de relacionamentos entre tokens capturada por cada cabeça de atenção, pode expandir-se à medida que os tokens passam por camadas sucessivas. Isso permite que o modelo capture dependências mais complexas e de longo alcance em camadas mais profundas. Muitas cabeças de atenção do transformer codificam relações de relevância que são significativas para os humanos. Por exemplo, algumas cabeças de atenção podem atender principalmente à próxima palavra, enquanto outras atendem principalmente de verbos para os seus objetos diretos.^[56] Os cálculos para cada cabeça de atenção podem ser realizados em paralelo, o que permite um processamento rápido. As saídas da camada de atenção são concatenadas para passar para as camadas da rede neural feedforward.

Concretamente, sejam as múltiplas cabeças de atenção indexadas por ${\displaystyle i}$, então temos: $${\displaystyle {\text{MultiheadAttention}}(Q,K,V)={\text{Concat}}_{i\in [n_{\text{heads}}]}({\text{Attention}}(XW_{i}^{Q},XW_{i}^{K},XW_{i}^{V}))W^{O}}$$ onde a matriz ${\displaystyle X}$ é a concatenação de embeddings de palavras, e as matrizes ${\displaystyle W_{i}^{Q},W_{i}^{K},W_{i}^{V}}$ são "matrizes de projeção" pertencentes à cabeça de atenção individual ${\displaystyle i}$, e ${\displaystyle W^{O}}$ é uma matriz de projeção final pertencente a toda a cabeça de atenção multicabeça.

É teoricamente possível que cada cabeça de atenção tenha uma dimensão de cabeça ${\displaystyle d_{\text{head}}}$ diferente, mas isso raramente acontece na prática.

Como exemplo, no menor modelo GPT-2, existem apenas mecanismos de autoatenção. Ele tem as seguintes dimensões: $${\displaystyle d_{\text{emb}}=768,n_{\text{head}}=12,d_{\text{head}}=64}$$ Como ${\displaystyle 12\times 64=768}$, a sua matriz de projeção de saída ${\displaystyle W^{O}\in \mathbb {R} ^{(12\times 64)\times 768}}$ é uma matriz quadrada.

A arquitetura transformer é construída para calcular tokens de saída iterativamente. Assumindo que ${\displaystyle t=0}$ refere-se ao cálculo do primeiro token de saída ${\displaystyle i=0}$, para o passo ${\displaystyle t>0}$, o token de saída ${\displaystyle i=0}$ deve permanecer constante. Isso garante propriedades do modelo semelhantes aos modelos autorregressivos.^[1] Portanto, em cada passo de tempo ${\displaystyle t}$, o cálculo para todas as saídas ${\displaystyle i}$ não deve ter acesso a tokens na posição ${\displaystyle j}$ para ${\displaystyle j\geq i}$ (como é naturalmente o caso para o passo de tempo ${\displaystyle t=i}$, quando os tokens ${\displaystyle j>t}$ ainda não foram calculados). Esse comportamento pode ser alcançado antes do estágio softmax adicionando uma matriz de máscara ${\displaystyle M}$ que é ${\displaystyle -\infty }$ nas entradas onde o link de atenção deve ser cortado, e ${\displaystyle 0}$ em outros lugares: $${\displaystyle {\begin{aligned}{\text{MaskedAttention}}(Q,K,V)={\text{softmax}}\left(M+{\frac {QK^{\mathrm {T} }}{\sqrt {d_{k}}}}\right)V\end{aligned}}}$$ A seguinte matriz é comumente usada em módulos de autoatenção do decodificador, chamada de "mascaramento causal" (causal masking): $${\displaystyle M_{\text{causal}}={\begin{bmatrix}0&-\infty &-\infty &\dots &-\infty \\0&0&-\infty &\dots &-\infty \\0&0&0&\dots &-\infty \\\vdots &\vdots &\vdots &\ddots &\vdots \\0&0&0&\dots &0\end{bmatrix}}}$$

Em palavras, isso significa que cada token pode prestar atenção a si mesmo, e a todos os tokens antes dele, mas não a nenhum depois dele. Um módulo de atenção não mascarado pode ser pensado como um módulo de atenção mascarado onde a máscara tem todas as entradas iguais a zero. Como exemplo de um uso incomum de matriz de máscara, o XLNet considera todas as máscaras da forma ${\displaystyle PM_{\text{causal}}P^{-1}}$, onde ${\displaystyle P}$ é uma matriz de permutação aleatória.^[57]

Um codificador consiste numa camada de embedding, seguida por múltiplas camadas codificadoras.

Cada camada codificadora consiste em dois componentes principais: um mecanismo de autoatenção e uma camada feedforward. Ele recebe uma entrada como uma sequência de vetores de entrada, aplica o mecanismo de autoatenção para produzir uma sequência intermediária de vetores, depois aplica a camada feedforward para cada vetor individualmente. Esquematicamente, temos: ${\displaystyle {\begin{aligned}{\text{dados os vetores de entrada }}&h_{0},h_{1},\dots \\{\text{combiná-los numa matriz }}H&={\begin{bmatrix}h_{0}\\h_{1}\\\vdots \end{bmatrix}}\\{\text{EncoderLayer}}(H)&={\begin{bmatrix}{\text{FFN}}({\text{MultiheadAttention}}(H,H,H)_{0})\\{\text{FFN}}({\text{MultiheadAttention}}(H,H,H)_{1})\\\vdots \end{bmatrix}}\\\end{aligned}}}$

onde ${\displaystyle {\text{FFN}}}$ significa "rede feedforward". Podemos escrevê-lo de forma mais sucinta como: $${\displaystyle {\text{EncoderLayer}}(H)={\text{FFN}}({\text{MultiheadAttention}}(H,H,H))}$$ com a convenção implícita de que a ${\displaystyle {\text{FFN}}}$ é aplicada a cada linha da matriz individualmente.

As camadas codificadoras são empilhadas. A primeira camada codificadora obtém a sequência de vetores de entrada da camada de embedding, produzindo uma sequência de vetores. Essa sequência de vetores é processada pelo segundo codificador, e assim por diante. A saída da camada codificadora final é então usada pelo decodificador.

Como o codificador processa toda a entrada de uma só vez, cada token pode atender a todos os outros tokens (atenção todos-para-todos), de modo que não há necessidade de mascaramento causal.

Um decodificador consiste numa camada de embedding, seguida por múltiplas camadas decodificadoras, seguidas por uma camada de des-embedding.

Cada decodificador consiste em três componentes principais: um mecanismo de autoatenção mascarado causalmente, um mecanismo de atenção cruzada e uma rede neural feedforward. O decodificador funciona de forma semelhante ao codificador, mas um mecanismo de atenção adicional é inserido, o qual extrai informações relevantes das codificações geradas pelos codificadores. Esse mecanismo também pode ser chamado de atenção codificador-decodificador.^[1][54]

Assim como o primeiro codificador, o primeiro decodificador recebe informações posicionais e embeddings da sequência de saída como sua entrada, em vez de codificações. O transformer não deve usar a saída atual ou futura para prever uma saída, portanto, a sequência de saída deve ser parcialmente mascarada para evitar esse fluxo reverso de informações.^[1] Isso permite a geração de texto autorregressiva. Para a decodificação, a atenção todos-para-todos é inadequada, pois um token não pode atender a tokens ainda não gerados. Assim, o módulo de autoatenção no decodificador é mascarado causalmente.

Em contraste, o mecanismo de atenção cruzada atende aos vetores de saída do codificador, que são calculados antes de o decodificador começar a decodificar. Consequentemente, não há necessidade de mascaramento no mecanismo de atenção cruzada.

Esquematicamente, temos: $${\displaystyle {\begin{aligned}H'&={\text{MaskedMultiheadAttention}}(H,H,H)\\{\text{DecoderLayer}}(H)&={\text{FFN}}({\text{MultiheadAttention}}(H',H^{E},H^{E}))\end{aligned}}}$$ onde ${\displaystyle H^{E}}$ é a matriz com linhas sendo os vetores de saída do codificador.

O último decodificador é seguido por uma camada de des-embedding final para produzir as probabilidades de saída sobre o vocabulário. Então, um dos tokens é amostrado de acordo com a probabilidade, e o decodificador pode ser executado novamente para produzir o próximo token, etc., gerando o texto de saída autorregressivamente.

Cada camada codificadora contém 2 subcamadas: a autoatenção (self-attention) e a rede feedforward. Cada camada decodificadora contém 3 subcamadas: a autoatenção mascarada causalmente, a atenção cruzada (cross-attention) e a rede feedforward.

Os pontos finais de detalhe são as conexões residuais e a normalização de camada (denotada como "LayerNorm", ou "LN" no texto a seguir), que embora conceitualmente desnecessárias, são necessárias para a estabilidade numérica e convergência.

A conexão residual, que é introduzida para evitar problemas de desvanecimento do gradiente e estabilizar o processo de treinamento, pode ser expressa da seguinte forma: y = F(x) + x. A expressão indica que uma saída y é a soma da transformação da entrada x (F(x)) e da própria entrada (x). Adicionar a entrada x pode preservar a informação de entrada e evitar problemas quando o gradiente de F(x) está próximo de zero.

De forma semelhante à maneira como os módulos de rede feedforward são aplicados individualmente a cada vetor, a LayerNorm também é aplicada individualmente a cada vetor.

Existem duas convenções comuns em uso: a convenção post-LN (pós-LN) e a pre-LN (pré-LN). Na convenção post-LN, a saída de cada subcamada é $${\displaystyle \mathrm {LayerNorm} (x+\mathrm {Sublayer} (x))}$$ onde ${\displaystyle \mathrm {Sublayer} (x)}$ é a função implementada pela própria subcamada.

Na convenção pre-LN, a saída de cada subcamada é $${\displaystyle x+\mathrm {Sublayer} (\mathrm {LayerNorm} (x))}$$ O transformer original de 2017 usava a convenção post-LN. Era difícil de treinar e exigia um ajuste cuidadoso de hiperparâmetros e um "aquecimento" (warm-up) na taxa de aprendizagem, onde esta começa pequena e aumenta gradualmente. A convenção pre-LN, proposta várias vezes em 2018,^[58] revelou-se mais fácil de treinar, não exigindo aquecimento, levando a uma convergência mais rápida.^[46]

A seguir está o pseudocódigo para um transformer codificador-decodificador pre-LN padrão, adaptado de Formal Algorithms for Transformers^[59]

 '''input:''' Entrada do codificador t_e
        Entrada do decodificador t_d
 '''output:''' Matriz de distribuições de probabilidade, com formato (tamanho do vocabulário do decodificador x comprimento(sequência de saída do decodificador))

 /* codificador */
 z_e ← encoder.tokenizer(t_e)

 '''for''' '''each''' t '''in''' 1:length(z_e) '''do'''
     z_e[t] ← encoder.embedding(z_e[t]) + encoder.positional_embedding(t)

 '''for''' '''each''' l '''in''' 1:length(encoder.layers) '''do'''
     layer ← encoder.layers[l]

     /* primeira subcamada */
     z_e_copy ← copy(z_e)
     '''for each''' t '''in''' 1:length(z_e) '''do'''
         z_e[t] ← layer.layer_norm(z_e[t])
     z_e ← layer.multihead_attention(z_e, z_e, z_e)
     '''for each''' t '''in''' 1:length(z_e) '''do'''
         z_e[t] ← z_e[t] + z_e_copy[t]

     /* segunda subcamada */
     z_e_copy ← copy(z_e)
     '''for each''' t '''in''' 1:length(z_e) '''do'''
         z_e[t] ← layer.layer_norm(z_e[t])
     z_e ← layer.feedforward(z_e)
     '''for each''' t '''in''' 1:length(z_e) '''do'''
         z_e[t] ← z_e[t] + z_e_copy[t]

 '''for each''' t '''in''' 1:length(z_e) '''do'''
     z_e[t] ← encoder.final_layer_norm(z_e[t])

 /* decodificador */
 z_d ← decoder.tokenizer(t_d)

 '''for''' '''each''' t '''in''' 1:length(z_d) '''do'''
     z_d[t] ← decoder.embedding(z_d[t]) + decoder.positional_embedding(t)

 '''for''' '''each''' l '''in''' 1:length(decoder.layers) '''do'''
         layer ← decoder.layers[l]

         /* primeira subcamada */
         z_d_copy ← copy(z_d)
         '''for each''' t '''in''' 1:length(z_d) '''do'''
             z_d[t] ← layer.layer_norm(z_d[t])
         z_d ← layer.masked_multihead_attention(z_d, z_d, z_d)
         '''for each''' t '''in''' 1:length(z_d) '''do'''
             z_d[t] ← z_d[t] + z_d_copy[t]

         /* segunda subcamada */
         z_d_copy ← copy(z_d)
         '''for each''' t '''in''' 1:length(z_d) '''do'''
             z_d[t] ← layer.layer_norm(z_d[t])
         z_d ← layer.multihead_attention(z_d, z_e, z_e)
         '''for each''' i '''in''' 1:length(z_d) '''do'''
             z_d[t] ← z_d[t] + z_d_copy[t]

         /* terceira subcamada */
         z_d_copy ← copy(z_d)
         '''for each''' t '''in''' 1:length(z_d) '''do'''
             z_d[t] ← layer.layer_norm(z_d[t])
         z_d ← layer.feedforward(z_d)
         '''for each''' t '''in''' 1:length(z_d) '''do'''
             z_d[t] ← z_d[t] + z_d_copy[t]

 z_d ← decoder.final_layer_norm(z_d)

 output_distributions ← []
 '''for each''' t '''in''' 1:length(z_d) '''do'''
     output_distributions.append(decoder.unembed(z_d[t]))

 '''return''' output_distributions

A arquitetura transformer, por ser modular, permite variações. Diversas variações comuns são descritas aqui.^[60]

Um transformer "somente-codificador" (encoder-only) aplica o codificador para mapear um texto de entrada numa sequência de vetores que representam esse texto de entrada. Isso é normalmente usado para embedding de texto e aprendizado de representação para aplicações posteriores (downstream). O BERT é somente-codificador. Eles são menos usados atualmente, pois descobriu-se que não são significativamente melhores do que treinar um transformer codificador-decodificador e depois usar apenas o codificador.^[51] Eles também são referidos como "all-to-all" (todos-para-todos) ou "tipo BERT".

Um transformer "somente-decodificador" (decoder-only) não é literalmente apenas um decodificador, uma vez que, sem um codificador, o mecanismo de atenção cruzada não tem nada a que atender. Assim, as camadas decodificadoras num transformer somente-decodificador são compostas por apenas duas subcamadas: a autoatenção mascarada causalmente e a rede feedforward. Isso é normalmente usado para geração de texto e para o seguimento de instruções. Os modelos da série GPT e da série Chinchilla são somente-decodificadores. Eles também são referidos como "autorregressivos" ou "causais".

Um transformer "codificador-decodificador" é geralmente igual ao transformer original, com 2 subcamadas por camada codificadora e 3 subcamadas por camada decodificadora, etc. Eles podem ter pequenas melhorias arquitetônicas, como funções de ativação alternativas, mudança do local de normalização, etc. Isso também é normalmente usado para geração de texto e seguimento de instruções. Os modelos na série T5 são codificador-decodificador.^[60]

Um "prefixLM" (modelo de linguagem de prefixo) é uma arquitetura somente-decodificador, mas com mascaramento de prefixo, que é diferente do mascaramento causal. Especificamente, ele tem uma máscara da forma^[60]: $${\displaystyle M_{\text{prefixLM}}={\begin{bmatrix}\mathbf {0} &-\infty \\\mathbf {0} &M_{\text{causal}}\end{bmatrix}}}$$ onde as primeiras colunas correspondem ao "prefixo" e as colunas subsequentes correspondem ao texto gerado autorregressivamente com base no prefixo. Eles assemelham-se a modelos codificador-decodificador, mas têm menos "esparsidade" (sparsity). Tais modelos são raramente usados, embora sejam citados como possibilidades teóricas e em comparações de benchmark.^[51]

Também existem modelos seq2seq mistos. Por exemplo, em 2020, o Google Tradutor substituiu o modelo anterior de codificador RNN-decodificador RNN por um modelo codificador transformer-decodificador RNN, pois os decodificadores baseados em transformer não pareciam aumentar significativamente a qualidade, ao contrário do codificador, enquanto o decodificador RNN era muito mais rápido.^[37]

O transformer original usa a função de ativação ReLU. Outras funções de ativação foram desenvolvidas. A série Llama e o PaLM usaram SwiGLU;^[61] tanto o GPT-1 quanto o BERT^[35] usaram GELU.^[62]

As funções de ativação alternativas são frequentemente usadas em combinação com unidades lineares bloqueadas (Gated Linear Units) no módulo feedforward.^[61]

A normalização usada no transformer pode ser diferente da LayerNorm. Um exemplo é a RMSNorm,^[63] que é usada na série Llama. Outros exemplos incluem CapsuleNorm,^[64] ScaleNorm,^[65] ou FixNorm.^[65]

Os transformers podem usar outros métodos de codificação posicional que não sejam os sinusoidais.^[66]

O artigo original do transformer relatou o uso de uma codificação posicional aprendida,^[67] mas concluiu que não era superior à sinusoidal.^[1] Mais tarde,^[68] descobriram que o próprio mascaramento causal fornece sinal suficiente a um decodificador transformer para que ele possa aprender a realizar a codificação posicional absoluta de forma implícita, sem o módulo de codificação posicional.

O RoPE (embedding posicional rotativo),^[69] é melhor explicado ao considerar uma lista de vetores bidimensionais ${\displaystyle [(x_{1}^{(1)},x_{1}^{(2)}),(x_{2}^{(1)},x_{2}^{(2)}),(x_{3}^{(1)},x_{3}^{(2)}),...]}$. Agora, escolha um ângulo ${\displaystyle \theta }$. A codificação RoPE é então: $${\displaystyle {\text{RoPE}}{\big (}x_{m}^{(1)},x_{m}^{(2)},m{\big )}={\begin{pmatrix}\cos m\theta &-\sin m\theta \\\sin m\theta &\cos m\theta \end{pmatrix}}{\begin{pmatrix}x_{m}^{(1)}\\x_{m}^{(2)}\\\end{pmatrix}}={\begin{pmatrix}x_{m}^{(1)}\cos m\theta -x_{m}^{(2)}\sin m\theta \\x_{m}^{(2)}\cos m\theta +x_{m}^{(1)}\sin m\theta \\\end{pmatrix}}}$$ De forma equivalente, se escrevermos os vetores bidimensionais como números complexos ${\displaystyle z_{m}:=x_{m}^{(1)}+ix_{m}^{(2)}}$, então a codificação RoPE é apenas uma multiplicação por um ângulo: $${\displaystyle {\text{RoPE}}{\big (}z_{m},m{\big )}=e^{im\theta }z_{m}}$$ Para uma lista de vetores de ${\displaystyle 2n}$ dimensões, um codificador RoPE é definido por uma sequência de ângulos ${\displaystyle \theta ^{(1)},...,\theta ^{(n)}}$. Então, a codificação RoPE é aplicada a cada par de coordenadas.

A vantagem do RoPE é que o produto escalar entre dois vetores depende apenas da sua localização relativa: $${\displaystyle {\text{RoPE}}{\big (}x,m{\big )}^{T}{\text{RoPE}}{\big (}y,n{\big )}={\text{RoPE}}{\big (}x,m+k{\big )}^{T}{\text{RoPE}}{\big (}y,n+k{\big )}}$$ para qualquer inteiro ${\displaystyle k}$.

O ALiBi (Attention with Linear Biases — Atenção com Vieses Lineares)^[70] não é um substituto para o codificador posicional no transformer original. Em vez disso, é um codificador posicional adicional que está diretamente conectado ao mecanismo de atenção. Especificamente, o mecanismo de atenção ALiBi é: $${\displaystyle {\begin{aligned}{\text{Attention}}(Q,K,V)={\text{softmax}}\left({\frac {QK^{\mathrm {T} }}{\sqrt {d_{k}}}}+sB\right)V\end{aligned}}}$$ Aqui, ${\displaystyle s}$ é um número real ("escalar"), e ${\displaystyle B}$ é a matriz de viés linear definida por: $${\displaystyle B={\begin{pmatrix}0&1&2&3&\cdots \\-1&0&1&2&\cdots \\-2&-1&0&1&\cdots \\-3&-2&-1&0&\cdots \\\vdots &\vdots &\vdots &\vdots &\ddots \\\end{pmatrix}}}$$ em outras palavras, ${\displaystyle B_{i,j}=j-i}$. A ideia é que a matriz de viés linear seja uma máscara suavizada. Assim como ${\displaystyle 0}$ representa atenção total prestada, e ${\displaystyle -\infty }$ representa nenhuma atenção prestada, a matriz de viés linear aumenta a atenção prestada numa direção e diminui a atenção prestada na outra direção.

O ALiBi permite o pré-treinamento em janelas de contexto curtas, seguido por um ajuste fino (fine-tuning) em janelas de contexto mais longas. Como está diretamente conectado ao mecanismo de atenção, ele pode ser combinado com qualquer codificador posicional que esteja conectado na "base" de toda a rede (que é onde o codificador sinusoidal do transformer original, bem como o RoPE e muitos outros, estão localizados).

As Codificações de Posição Relativa^[71] (Relative Position Encodings) são semelhantes ao ALiBi, mas mais genéricas: $${\displaystyle {\begin{aligned}{\text{Attention}}(Q,K,V)={\text{softmax}}\left({\frac {QK^{\mathrm {T} }}{\sqrt {d_{k}}}}+B\right)V\end{aligned}}}$$ onde ${\displaystyle B}$ é uma Matriz de Toeplitz, ou seja, ${\displaystyle B_{i,j}=B_{i',j'}}$ sempre que ${\displaystyle i-j=i'-j'}$. Isto contrasta com a codificação posicional sinusoidal original, que é uma "codificação posicional absoluta".^[72]

O modelo transformer foi implementado em frameworks (estruturas de software) padrão de aprendizado profundo, como TensorFlow e PyTorch. Transformers é uma biblioteca produzida pela Hugging Face que fornece arquiteturas baseadas em transformers e modelos pré-treinados.^[11]

Quando um transformer autorregressivo é usado para inferência, como na geração de texto, o vetor de consulta é diferente a cada passo, mas os vetores de chave e valor já computados são sempre os mesmos. O método de cache de KV guarda os vetores de chave e valor computados em cada bloco de atenção, de modo que eles não sejam recalculados a cada novo token. A PagedAttention aplica a paginação de memória à cache de KV.^[73][74][75]

Se um transformer for usado com um prompt fixo, como ["Você é um agente de suporte ao cliente..."], então os vetores de chave e valor podem ser calculados para o prompt e guardados em disco. A economia em computação é significativa quando o modelo é usado para muitas interações curtas em tempo real, como em chatbots online.

Geralmente, quando um utilizador usa um transformer autorregressivo para gerar uma continuação para uma sequência de tokens, o modelo primeiro executaria uma passagem à frente (forward-pass) nesta sequência, em que as caches de KV sobre esta sequência são computadas. Isto é chamado de preenchimento prévio (prefilling). Provedores de nuvem em larga escala (hyperscalers) que servem modelos Transformer muito grandes podem usar a inferência desagregada, onde o preenchimento prévio e a decodificação são realizados em hardware especializado separadamente.^[76]

FlashAttention^[77] é um algoritmo que implementa o mecanismo de atenção do transformer de forma eficiente numa GPU. É um algoritmo que evita a comunicação, o qual realiza multiplicações de matrizes em blocos, de modo que cada bloco caiba na cache de uma GPU e, por meio de um gerenciamento cuidadoso dos blocos, ele minimiza a cópia de dados entre as caches da GPU (visto que a movimentação de dados é lenta). Veja a página sobre a softmax para detalhes.

Uma versão melhorada, FlashAttention-2,^[78][79][80] foi desenvolvida para atender à crescente procura por modelos de linguagem capazes de lidar com comprimentos de contexto mais longos. Oferece melhorias no particionamento do trabalho e paralelismo, permitindo que alcance até 230 TFLOPs/s em GPUs A100 (FP16/BF16), um aumento de velocidade de 2x em relação ao FlashAttention original.

Os principais avanços no FlashAttention-2 incluem a redução de FLOPs que não são operações de matriz (non-matmul FLOPs), melhor paralelismo sobre a dimensão do comprimento da sequência, melhor particionamento do trabalho entre as threads (warps) da GPU e suporte adicionado para dimensões de cabeça de até 256 e atenção de múltiplas consultas (MQA) e atenção de consultas agrupadas (GQA).^[81]

Benchmarks revelaram que o FlashAttention-2 é até 2x mais rápido do que o FlashAttention e até 9x mais rápido do que uma implementação de atenção padrão em PyTorch. Desenvolvimentos futuros incluem otimização para novos hardwares, como as GPUs H100, e novos tipos de dados, como o FP8.

O FlashAttention-4 foca-se no uso de pipeline para aumentar a taxa de transferência (throughput) de instruções, e foi desenvolvido para ter um desempenho particularmente bom nas GPUs Blackwell.^[82]

A Atenção de Múltiplas Consultas (Multi-Query Attention - MQA) altera o mecanismo de Atenção Multicabeça (Multihead Attention).^[83] Embora normalmente se tenha:

$${\displaystyle {\text{MultiheadAttention}}(Q,K,V)={\text{Concat}}_{i\in [n_{\text{heads}}]}\left({\text{Attention}}(XW_{i}^{Q},XW_{i}^{K},XW_{i}^{V})\right)W^{O}}$$ com a Atenção Multi-Query, existe apenas um ${\displaystyle W^{K},W^{V}}$, resultando em:

$${\displaystyle {\text{MultiQueryAttention}}(Q,K,V)={\text{Concat}}_{i\in [n_{\text{heads}}]}\left({\text{Attention}}(XW_{i}^{Q},XW^{K},XW^{V})\right)W^{O}}$$

Isto tem um efeito neutro na qualidade do modelo e na velocidade de treinamento, mas aumenta a velocidade de inferência.

Mais genericamente, a atenção de consultas agrupadas (Grouped-Query Attention - GQA) particiona as cabeças de atenção em grupos, cada um dos quais partilha o par chave-valor. O MQA é o GQA com um único grupo, enquanto a Atenção Multicabeça padrão é o GQA com o número máximo de grupos.^[84]

A Atenção Latente Multicabeça (Multihead Latent Attention - MLA) é uma aproximação de baixo posto à MHA padrão. Especificamente, cada vetor oculto, antes de entrar no mecanismo de atenção, é primeiro projetado em dois espaços de baixa dimensão ("espaço latente"), um para a consulta e outro para chave-valor (vetor KV). Este design minimiza a cache de KV, uma vez que apenas o vetor KV de baixa dimensão precisa ser mantido na cache.^[85]

A decodificação especulativa^[86][87] é um método para acelerar a decodificação de tokens. À semelhança da execução especulativa nas CPUs, os tokens futuros são computados rapidamente e depois verificados. Se os tokens computados rapidamente estiverem incorretos, eles são descartados e computados de forma mais lenta e precisa.

O fator chave na decodificação especulativa é que um decodificador transformer pode verificar mais rápido do que pode decodificar, no seguinte sentido.

Suponha que temos dois modelos de transformer, como o GPT-3 e o GPT-3-small (pequeno), ambos com uma janela de contexto de tamanho 512. Para gerar uma janela de contexto inteira de forma autorregressiva com decodificação gulosa (greedy decoding) usando o GPT-3, ele deve ser executado 512 vezes, gerando a cada vez um token ${\displaystyle x_{1},x_{2},...,x_{512}}$, levando um tempo de ${\displaystyle 512T_{\text{GPT-3}}}$. No entanto, se tivéssemos algum palpite bem fundamentado (educated guess) para os valores desses tokens, poderíamos verificá-los a todos em paralelo, numa única execução do modelo, verificando se cada ${\displaystyle x_{t}}$ é realmente o token com a maior log-verossimilhança na ${\displaystyle t}$-ésima saída.

Na decodificação especulativa, um modelo menor ou alguma outra heurística simples é usada para gerar alguns tokens especulativos que são subsequentemente verificados pelo modelo maior. Por exemplo, suponha que usamos o GPT-3-small para gerar quatro tokens especulativos: ${\displaystyle {\tilde {x}}_{1},{\tilde {x}}_{2},{\tilde {x}}_{3},{\tilde {x}}_{4}}$. Isto leva apenas ${\displaystyle 4T_{\text{GPT-3-small}}}$. Estes tokens são então passados pelo GPT-3 maior de uma só vez. Suponha que ${\displaystyle {\tilde {x}}_{1}}$ e ${\displaystyle {\tilde {x}}_{2}}$ sejam verificados pelo GPT-3 como os que ele teria escolhido, então estes são mantidos, mas o ${\displaystyle {\tilde {x}}_{3}}$ não é; portanto, ${\displaystyle {\tilde {x}}_{3},{\tilde {x}}_{4}}$ são descartados, e o GPT-3 é executado nestes. Isto levaria ${\displaystyle 4T_{\text{GPT-3-small}}+3T_{\text{GPT-3}}}$, o que pode ser mais curto do que ${\displaystyle 4T_{\text{GPT-3}}}$.

Para decodificação não gulosa, aplicam-se ideias semelhantes, exceto que os tokens especulativos são aceites ou rejeitados estocasticamente, de forma a garantir que a distribuição de saída final seja a mesma como se a decodificação especulativa não tivesse sido usada.^[86][88]

Na Previsão de Múltiplos Tokens (Multi-Token Prediction), uma única passagem à frente (forward pass) cria um vetor de embedding final, que então é des-embedado para uma probabilidade de token. No entanto, esse vetor pode, em seguida, ser processado por outro bloco transformer para prever o próximo token, e assim por diante por tantos passos quanto se desejar no futuro. Isso troca a precisão por velocidade, já que cada novo token custa apenas mais um bloco transformer, e não a pilha inteira.^[89][90]

O treinamento de arquiteturas baseadas em transformers pode ser caro, especialmente para entradas longas.^[91] Muitos métodos foram desenvolvidos numa tentativa de resolver a questão. No domínio da imagem, o Swin transformer é uma arquitetura eficiente que realiza a atenção dentro de janelas móveis (shifting windows).^[92] No domínio do áudio, o SepTr desacopla a atenção nos domínios do tempo e da frequência.^[93] O benchmark Long Range Arena (2020)^[94] é um padrão para comparar o comportamento das arquiteturas de transformers em entradas longas.

O grafo de atenção padrão é quer todos-para-todos quer causal, e ambos escalam como ${\displaystyle O(N^{2})}$ onde ${\displaystyle N}$ é o número de tokens numa sequência.

O Reformer (2020)^[91][95] reduz a carga computacional de ${\displaystyle O(N^{2})}$ para ${\displaystyle O(N\ln N)}$ usando hashing sensível à localidade e camadas reversíveis.^[96]

A atenção esparsa (sparse attention)^[97] usa grafos de atenção que crescem mais lentamente que ${\displaystyle O(N^{2})}$. Por exemplo, o BigBird (2020)^[98] usa redes de mundo pequeno (small-world) aleatórias que crescem como ${\displaystyle O(N)}$.

Os transformers comuns exigem um tamanho de memória que é quadrático em relação ao tamanho da janela de contexto. Os transformers sem atenção (attention-free transformers)^[99] reduzem isto para uma dependência linear enquanto ainda retêm as vantagens de um transformer ao ligar a chave ao valor.

A Atenção de Recurso Aleatório (Random Feature Attention - 2021)^[100] usa recursos aleatórios de Fourier: $${\displaystyle \varphi (x)={\frac {1}{\sqrt {D}}}[\cos \langle w_{1},x\rangle ,\sin \langle w_{1},x\rangle ,\cdots \cos \langle w_{D},x\rangle ,\sin \langle w_{D},x\rangle ]^{T}}$$ onde ${\displaystyle w_{1},...,w_{D}}$ são amostras independentes da distribuição normal ${\displaystyle N(0,\sigma ^{2}I)}$. Esta escolha de parâmetros satisfaz a propriedade ${\displaystyle \mathbb {E} [\langle \varphi (x),\varphi (y)\rangle ]=e^{-{\frac {\|x-y\|^{2}}{2\sigma ^{2}}}}}$, ou $${\displaystyle e^{\langle x,y\rangle /\sigma ^{2}}=\mathbb {E} [\langle e^{\|x\|^{2}/2\sigma ^{2}}\varphi (x),e^{\|y\|^{2}/2\sigma ^{2}}\varphi (y)\rangle ]\approx \langle e^{\|x\|^{2}/2\sigma ^{2}}\varphi (x),e^{\|y\|^{2}/2\sigma ^{2}}\varphi (y)\rangle }$$ Consequentemente, a atenção de uma cabeça, com uma consulta, pode ser escrita como $${\displaystyle {\text{Attention}}(q,K,V)={\text{softmax}}\left({\frac {qK^{\mathrm {T} }}{\sqrt {d_{k}}}}\right)V\approx {\frac {\varphi (q)^{T}\sum _{i}e^{\|k_{i}\|^{2}/2\sigma ^{2}}\varphi (k_{i})v_{i}^{T}}{\varphi (q)^{T}\sum _{i}e^{\|k_{i}\|^{2}/2\sigma ^{2}}\varphi (k_{i})}}}$$ onde ${\displaystyle \sigma =d_{K}^{1/4}}$. O mesmo se aplica a consultas múltiplas, e à atenção multicabeça.

Esta aproximação pode ser calculada em tempo linear, já que podemos calcular a matriz ${\displaystyle \varphi (k_{i})v_{i}^{T}}$ primeiro, e depois multiplicá-la pela consulta. Na essência, conseguimos obter uma versão mais precisa de $${\displaystyle {\text{Attention}}(Q,K,V)={\text{softmax}}\left({\frac {QK^{\mathrm {T} }}{\sqrt {d_{k}}}}\right)V\approx Q(K^{T}V/{\sqrt {d_{k}}})}$$ O Performer (2022)^[101] usa a mesma Atenção de Recurso Aleatório, mas os pesos ${\displaystyle w_{1},...,w_{D}}$ são primeiro amostrados independentemente da distribuição normal ${\displaystyle N(0,\sigma ^{2}I)}$, e então são processados por Gram-Schmidt.

Os transformers também podem ser usados/adaptados para modalidades (de entrada ou de saída) para além do mero texto, normalmente através da descoberta de uma forma de "tokenizar" a modalidade em questão.

Modelos multimodais podem ser treinados quer de raiz quer através do ajuste fino (finetuning). Um estudo de 2022 revelou que transformers pré-treinados apenas em linguagem natural podem ser alvo de um ajuste fino em apenas 0,03% dos parâmetros e tornar-se competitivos em relação a modelos LSTMs numa variedade de tarefas lógicas e visuais, o que demonstra a capacidade da aprendizagem por transferência.^[102] O LLaVA consistia num modelo de linguagem visual composto por um modelo de linguagem (Vicuna-13B)^[103] e um modelo de visão (ViT-L/14), ligados por intermédio de uma camada linear. Apenas a camada linear é submetida a um ajuste fino.^[104]

Os transformers de visão^[41] (Vision transformers) adaptam o transformer para a visão computacional ao decompor as imagens de entrada numa série de retalhos (patches), transformando-os em vetores, e tratando-os como um vetor de embedding de tokens num transformer padrão.

O Conformer^[42] e mais tarde o Whisper^[105] seguem o mesmo padrão para o reconhecimento de fala, transformando primeiro o sinal de fala num espectrograma, que é depois tratado como uma imagem, isto é, decomposto numa série de retalhos, transformados em vetores e tratados como um vetor de embedding de tokens num transformer convencional.

Os perceivers^[106][107] são uma variante de transformers desenhados para a multimodalidade.

Para a geração de imagens, destacam-se arquiteturas como o DALL-E 1 (2021), o Parti (2022),^[108] o Phenaki (2023)^[109] e o Muse (2023).^[110] Ao contrário dos modelos mais recentes, o DALL-E não é um modelo de difusão. Em vez disso, ele usa um transformer do tipo somente-decodificador que gera um texto de forma autorregressiva, seguido por uma representação por tokens de uma imagem, que é posteriormente convertida num autocodificador variacional para uma imagem.^[111] O Parti é um transformer codificador-decodificador, onde o codificador processa o prompt (estímulo) de texto e o decodificador cria uma representação em formato de tokens de uma imagem.^[112] O Muse é um transformer do tipo somente-codificador que foi treinado para inferir tokens de imagem mascarados a partir de tokens de imagem que não estão mascarados. Ao longo da geração, todos os tokens de entrada são mascarados, e as predições com maior nível de confiança integram a iteração seguinte, até que a totalidade dos tokens tenha sido prevista.^[110] O Phenaki é um modelo de texto para vídeo. Trata-se de um transformer mascarado bidirecional condicionado em relação a tokens de texto precomputados. Os tokens produzidos são subsequentemente decodificados para dar lugar a um vídeo.^[109]

O Transformer obteve grande sucesso no processamento de linguagem natural (PLN). Muitos modelos de linguagem grandes (LLMs), tais como GPT-2, GPT-3, GPT-4, Gemini, AlbertAGPT, Claude, BERT, Grok, XLNet, RoBERTa e ChatGPT, demonstram a capacidade dos Transformers de executar uma ampla variedade de tarefas secundárias relacionadas a PLN e suas aplicações práticas no mundo real, incluindo:

• Tradução automática
• Previsão de séries temporais
• Sumarização de documentos
• Geração de documentos
• Reconhecimento de entidade mencionada (NER)^[113]
• Escrita de código de computador com base em requisitos expressos em linguagem natural
• Conversão de fala em texto

Para além do PLN tradicional, a arquitetura Transformer obteve sucesso em diversas outras aplicações, tais como:

• Resposta a desastres^[114]
• Análise de sequências biológicas
• Compreensão de vídeos
• Enovelamento de proteínas (como o AlphaFold)
• Avaliação de posições em tabuleiros de xadrez. Utilizando apenas a avaliação estática (isto é, sem nenhuma busca por algoritmo Minimax), o Transformer alcançou um rating Elo de 2895, o que o posiciona no nível de um Grande Mestre.^[10]

Notas

• Alexander Rush, The Annotated transformer, Harvard NLP group, 3 de abril de 2018. Arquivado em 22 de setembro de 2021 via Wayback Machine.
• Phuong, Mary; Hutter, Marcus (2022). «Formal Algorithms for Transformers». arXiv. arXiv:2207.09238 
• Ferrando, Javier; Sarti, Gabriele; Bisazza, Arianna; Costa-jussà, Marta R. (1 de maio de 2024). «A Primer on the Inner Workings of Transformer-based Language Models». arXiv. arXiv:2405.00208 
• Leech, Gavin (6 de novembro de 2024). «Transformer++». argmin gravitas. Consultado em 8 de maio de 2025. Cópia arquivada em 26 de fevereiro de 2025 
• US 10452978, "Attention-based sequence transduction neural networks" 
• Raschka, Sebastian (11 de março de 2026). «The Big LLM Architecture Comparison: From DeepSeek V3 to GLM-5: A Look At Modern LLM Architecture Design». Sebastian Raschka’s AI Magazine. Consultado em 25 de março de 2026