Token

Um token é a unidade básica de entrada e saída que um modelo de IA processa: uma palavra, parte de uma palavra, um caractere ou um byte em texto, ou um bloco de pixels em uma imagem. Antes que um transformer possa ler uma frase ou uma imagem, um tokenizador divide a entrada em tokens e mapeia cada um para um ID inteiro, e o modelo consulta um vetor de embedding para cada ID. A quantidade de tokens determina tanto o que um modelo consegue processar quanto o custo: uma janela de contexto é medida em tokens, os modelos de linguagem de grande porte (LLMs) geram texto um token por vez, e as APIs comerciais cobram por token de entrada e de saída.

Token vs. tokenização e termos relacionados#

• Tokenização: O processo que divide a entrada bruta em tokens. Um token é uma unidade da saída desse processo.
• Vocabulário e IDs de token: O vocabulário de um tokenizador é o conjunto fixo de tokens que ele conhece, cada um com um ID inteiro. O BERT usa 30.522 tokens, o GPT-2, 50.257, o Llama 3, 128.256, e o Gemma 3, cerca de 262.000.
• Tokens especiais: Marcadores da estrutura de uma sequência, como tokens de início de texto, fim de texto e preenchimento, ou o token [CLS], cujo embedding final o BERT usa para classificação.
• Embeddings: Os vetores aprendidos que a primeira camada do modelo consulta para cada ID de token e que levam o significado do token para dentro da rede.

Tokens de texto#

Um vocabulário de palavras inteiras não consegue abranger todos os nomes, erros de digitação e termos novos, e o uso de caracteres individuais produz sequências muito longas. Por isso, os tokenizadores modernos usam subpalavras: palavras frequentes se tornam tokens únicos, e palavras raras são divididas em partes reutilizáveis. A codificação por pares de bytes (BPE), adaptada à tradução automática neural por Sennrich e colegas em 2016, começa com caracteres individuais e combina repetidamente o par adjacente mais frequente até o vocabulário atingir o tamanho desejado. Os modelos GPT aplicam BPE a bytes, permitindo codificar qualquer texto, inclusive código e emojis; o WordPiece (usado pelo BERT) e o modelo Unigram do SentencePiece são esquemas de subpalavras relacionados. O tokenizador BPE do CLIP, carregado aqui do Hub da Hugging Face, mostra como as palavras são divididas:

from transformers import AutoTokenizer

# Load CLIP's byte-pair-encoding (BPE) tokenizer from the Hugging Face Hub
tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

for text in ["bus", "double-decker bus", "unhappiness", "Ultralytics"]:
    tokens = tokenizer.tokenize(text)
    print(f"{text!r} -> {tokens} -> {tokenizer.convert_tokens_to_ids(tokens)}")

"bus" é um único token, ID 2840; "unhappiness" se divide em un e happiness; e a palavra rara "Ultralytics" se divide em três partes: ultr, aly e tics. O sufixo </w> marca o fim de uma palavra no vocabulário do CLIP, que contém 49.408 tokens, e o codificador de texto do CLIP lê no máximo 77 tokens por prompt.

Tokens visuais#

O Vision Transformer (ViT), apresentado no artigo Uma imagem vale 16 × 16 palavras, divide uma imagem em blocos de tamanho fixo, de 16 × 16 pixels no ViT-B/16, e projeta cada bloco em um embedding, de modo que uma imagem de 224 × 224 se torna 196 tokens. Os embeddings posicionais registram a origem de cada bloco, e um token de classe adicional reúne informações para a classificação. A projeção geralmente é implementada como uma convolução cujo passo é igual ao tamanho do kernel:

import torch

# ViT-B/16 patch embedding: a 16x16 convolution with stride 16 turns each patch into one 768-dim token
patch_embed = torch.nn.Conv2d(3, 768, kernel_size=16, stride=16)

for size in (224, 448):
    image = torch.rand(1, 3, size, size)
    tokens = patch_embed(image).flatten(2).transpose(1, 2)  # (batch, tokens, dims)
    print(f"{size}x{size} image -> {tuple(tokens.shape)}")

Uma imagem de 224 × 224 produz 196 tokens de 768 valores, e dobrar o lado para 448 pixels resulta em 784 tokens, quatro vezes mais. A autoatenção compara cada token com todos os outros, portanto quatro vezes mais tokens significam cerca de dezesseis vezes mais custo de atenção; por isso, modelos de alta resolução usam atenção em janelas, como no Swin Transformer, ou combinam tokens semelhantes com a fusão de tokens.

Os modelos de visão e linguagem passam os tokens visuais de um codificador de imagens para um LLM junto com tokens de texto, permitindo que um único transformer preste atenção a ambos e escreva a resposta um token de texto de cada vez:

Por que a contagem de tokens é importante#

• Limites de contexto: O prompt, todos os documentos ou imagens recuperados e a resposta gerada precisam caber na janela de contexto do modelo.
• Custo e latência: As APIs cobram separadamente pelos tokens de entrada e saída, e o tempo de geração aumenta com a quantidade de tokens de saída, pois cada um exige uma etapa de decodificação que lê o cache KV do modelo.
• Idiomas e formatos: Tokenizadores treinados principalmente em inglês dividem outros idiomas, código e números longos em mais tokens por palavra, então o mesmo conteúdo custa mais e preenche a janela de contexto mais rapidamente.
• Tarefas no nível de caracteres: O modelo vê tokens de subpalavras, por isso tarefas que dependem de letras individuais, como contar as letras de uma palavra ou invertê-la, são mais difíceis do que parecem.

Aplicações no mundo real#

• Geração de texto: Um LLM atribui uma probabilidade a cada token do vocabulário, escolhe um, acrescenta-o à sequência e repete o processo; métodos de amostragem como a amostragem de núcleo escolhem entre os tokens mais prováveis.
• Geração de imagens: Modelos autorregressivos de imagens preveem tokens visuais discretos de um livro de códigos aprendido, criado com quantização vetorial, da mesma maneira que um LLM prevê palavras.
• Detecção de vocabulário aberto: O YOLOE-26, versão baseada em YOLO26 do YOLOE da Universidade Tsinghua no pacote Ultralytics, encontra objetos a partir de nomes de classes digitados. Seu método set_classes() tokeniza cada nome com o tokenizador BPE do CLIP; o codificador de texto MobileCLIP2 da Apple transforma os tokens em um embedding, e o modelo compara esses embeddings com regiões da imagem, para detectar apenas com base nas palavras, por exemplo, um "double-decker bus", uma classe que não faz parte do conjunto de dados COCO.