O que são tokens em IA? Tokenização explicada

Quando você envia uma frase para um modelo de linguagem, ele não enxerga letras nem palavras da forma que você escreveu. Ele enxerga tokens: pequenos pedaços de texto convertidos em números. Entender o que é um token muda completamente a forma como você raciocina sobre custo, limite de contexto e até por que a IA às vezes erra ao contar letras.

O que é um token, afinal

Um token é a menor unidade de texto que o modelo processa de uma vez. Pode ser uma palavra inteira, um pedaço de palavra, um sinal de pontuação ou até um espaço. A regra prática para o inglês é que 1 token ≈ 4 caracteres ou cerca de 0,75 palavra. Em português, a proporção costuma ser um pouco menos eficiente, porque muitos tokenizadores foram otimizados primariamente para o inglês.

Veja como uma frase simples poderia ser fatiada:

Texto:  "Tokenização é fascinante!"
Tokens: ["Token", "ização", " é", " fasc", "inante", "!"]

Repare que "Tokenização" não virou um único token. Ela foi quebrada em pedaços menores, e o espaço antes de "é" ficou grudado no token seguinte. Isso não é um detalhe aleatório: é resultado direto do algoritmo que aprende quais pedaços de texto valem a pena agrupar.

Token não é palavra (e essa diferença importa)

A maior fonte de confusão é tratar token como sinônimo de palavra. Não é. Uma palavra comum em inglês costuma ser um token; uma palavra rara, um nome próprio ou um termo técnico pode virar três, quatro ou mais tokens. Em português, com nossa riqueza de conjugações, plurais e acentos, a fragmentação tende a ser maior. Quando você lê "modelo de 128 mil tokens de contexto", isso não significa 128 mil palavras — significa algo em torno de 90 a 100 mil palavras em inglês, e menos em português. Internalizar essa diferença evita estimativas erradas de custo e de quanto texto cabe em uma chamada.

Por que não usar palavras ou letras direto

Existem dois extremos ingênuos para representar texto, e os dois têm problemas sérios.

• Um token por letra (nível de caractere): o vocabulário fica minúsculo (algumas dezenas de símbolos), mas as sequências ficam enormes. Uma frase de 100 caracteres viraria 100 tokens, e o modelo precisaria aprender a remontar significado letra por letra. Caro e ineficiente.
• Um token por palavra (nível de palavra): parece intuitivo, mas o vocabulário explode. Existem milhões de palavras possíveis quando você soma plurais, conjugações, nomes próprios e gírias. Pior: qualquer palavra nova ou com erro de digitação vira um token "desconhecido", e o modelo perde toda a informação.

A solução que venceu fica no meio do caminho: a tokenização por subpalavras (subword tokenization). Palavras comuns viram um token só; palavras raras são quebradas em pedaços reutilizáveis. Assim o vocabulário fica controlado (tipicamente de 30 mil a 100 mil tokens) e nenhuma palavra é genuinamente "desconhecida" — no pior caso ela é montada caractere a caractere.

Essa decisão tem uma elegância de engenharia: ela equilibra dois recursos escassos ao mesmo tempo. O vocabulário não pode ser grande demais (cada token extra custa memória e parâmetros no modelo), mas as sequências também não podem ser longas demais (o custo de processamento cresce com o número de tokens). A tokenização por subpalavras encontra o ponto ótimo entre os dois.

BPE: o algoritmo por trás da maioria dos tokenizadores

O método mais influente para criar esses subtokens é o Byte Pair Encoding (BPE). Ele foi adaptado para tradução automática neural por Sennrich, Haddow e Birch (2016) justamente para lidar com palavras raras, e hoje é a base dos tokenizadores de boa parte dos LLMs modernos.

A intuição é simples e quase mecânica:

1. Comece com um vocabulário de símbolos individuais (caracteres ou bytes).
2. Conte todos os pares de símbolos adjacentes no corpus de treino.
3. Funda o par mais frequente em um novo símbolo único.
4. Repita milhares de vezes, até atingir o tamanho de vocabulário desejado.

Na prática, pares comuníssimos como e + r viram cedo um token er, e depois er + a pode virar era. Pedaços que aparecem muito acabam sendo aprendidos como unidades; pedaços raros permanecem fragmentados. É por isso que "ização" virou um token só no exemplo anterior: esse sufixo aparece em tantas palavras que o BPE achou econômico tratá-lo como uma peça única.

# Pseudocódigo simplificado do treino de BPE
vocab = set(todos_os_caracteres(corpus))
for _ in range(numero_de_fusoes):
    pares = contar_pares_adjacentes(corpus)
    melhor = max(pares, key=pares.get)   # par mais frequente
    corpus = fundir(corpus, melhor)      # trata o par como 1 símbolo
    vocab.add(melhor)

Modelos mais recentes usam uma variante chamada byte-level BPE, que opera sobre os bytes do texto em vez dos caracteres. A vantagem é cobrir qualquer caractere Unicode — emojis, ideogramas, acentos — sem nunca cair em um token "desconhecido".

Treino versus uso: dois momentos distintos

Vale separar duas coisas que costumam ser confundidas. O processo descrito acima — contar pares e fundir os mais frequentes — acontece uma única vez, durante a criação do tokenizador, sobre um corpus gigantesco. O resultado é uma tabela fixa de fusões (o vocabulário). Quando você usa o modelo no dia a dia, o tokenizador apenas aplica essas regras já aprendidas para fatiar o seu texto, de forma determinística e rápida. Ou seja: o vocabulário é congelado no treino; o uso é só consulta. Por isso o mesmo texto sempre gera exatamente os mesmos tokens para um dado modelo.

Outros algoritmos que você vai encontrar

O BPE domina, mas não é o único. Vale conhecer os nomes:

• WordPiece, usado em modelos da família BERT, é parecido com o BPE mas escolhe as fusões maximizando a verossimilhança do corpus, não só a frequência bruta.
• Unigram / SentencePiece parte de um vocabulário grande e vai removendo tokens pouco úteis, em vez de fundir de baixo para cima. O SentencePiece tem a vantagem de tratar o espaço como um caractere comum, o que facilita lidar com idiomas sem separação clara de palavras.

Para o uso prático, o que importa é entender o princípio compartilhado: subpalavras frequentes viram tokens; o raro é fragmentado.

Tokens, custo e a fatura no fim do mês

Aqui está a parte que dói no bolso: você paga por token, não por palavra ou requisição. Os provedores cobram pela soma dos tokens de entrada (seu prompt) e de saída (a resposta gerada), geralmente com preços diferentes para cada um. Se você está dando os primeiros passos com chamadas de API, vale ler API da OpenAI na prática: primeiros passos para devs, onde o consumo de tokens aparece direto na resposta de cada chamada.

Algumas consequências práticas dessa contagem:

• Texto em português custa um pouco mais que o mesmo conteúdo em inglês, porque tende a gerar mais tokens por palavra.
• Formatação repetitiva pesa. JSON com chaves verbosas, indentação e aspas consome tokens que poderiam ser informação útil.
• Respostas longas custam mais que prompts longos em muitos modelos, já que o preço de saída costuma ser maior.
• Histórico de conversa acumula. Em um chat, todo o histórico é reenviado a cada turno, então a conta cresce a cada mensagem.

Estimar tokens antes de enviar evita surpresas. Bibliotecas oficiais de tokenização (como a tiktoken) permitem contar exatamente quantos tokens um texto vai gerar para um modelo específico.

# Contando tokens antes de enviar, com tiktoken
import tiktoken

enc = tiktoken.get_encoding("cl100k_base")
texto = "Quantos tokens isto gera em português?"
tokens = enc.encode(texto)
print(len(tokens))          # quantidade de tokens
print(tokens[:5])           # os primeiros IDs numéricos

O efeito do cache de prompt

Um ponto que muda a conta na prática: vários provedores oferecem cache de prompt. Se você reenvia um trecho longo e idêntico no começo de cada chamada — instruções de sistema, documentação, exemplos — esse prefixo pode ser cacheado e cobrado a uma fração do preço nas chamadas seguintes. Estruturar o prompt para colocar a parte estável no início e a parte variável no fim é, portanto, uma otimização de custo real, não só de organização. Pensar em tokens é também pensar em onde eles aparecem.

A relação direta com a janela de contexto

Todo modelo tem um teto de quantos tokens consegue considerar de uma vez — entrada mais saída somadas. Esse teto é a janela de contexto, e ela é medida em tokens, nunca em palavras ou páginas.

Isso significa que tokenização e contexto são dois lados da mesma moeda. Um documento que "cabe" depende inteiramente de quantos tokens ele gera. Um PDF cheio de tabelas e números pode consumir muito mais tokens do que sua contagem de palavras sugere, porque dígitos e símbolos costumam fragmentar bastante. Foi a capacidade de aprender a partir de janelas grandes que tornou possível o aprendizado "in-context" descrito por Brown, Mann, Ryder, Subbiah, Kaplan et al. (2020), em que o modelo resolve tarefas só vendo exemplos no próprio prompt.

Na prática, isso tem uma implicação direta para quem constrói sistemas: quando você monta um prompt com documentos recuperados (RAG), precisa orçar tokens. Cada documento injetado come parte da janela, e o espaço que sobra para a resposta diminui. Estourar a janela não dá um erro "elegante" — ou a chamada falha, ou o conteúdo mais antigo é truncado silenciosamente, o que pode degradar a qualidade sem aviso.

Onde a tokenização se encaixa na arquitetura

Tokenizar é o primeiro passo de todo o pipeline. Depois que o texto vira uma lista de IDs de tokens, cada ID é convertido em um vetor — um embedding — que carrega o significado daquele token em forma numérica. Só então esses vetores entram nas camadas de atenção da arquitetura Transformer, o desenho que tornou os modelos atuais viáveis.

O fluxo completo, de forma resumida:

"Olá mundo"  →  [tokenizador]  →  [3923, 1991]  →  [embeddings]  →  [Transformer]  →  saída
   texto          fatiamento        IDs numéricos    vetores          atenção          tokens

Vale lembrar que a tokenização é também a última etapa: o modelo gera um token por vez, e o tokenizador é usado de novo, em sentido inverso, para transformar IDs de volta em texto legível. Tudo isso acontece dentro de um LLM (Large Language Model), que orquestra essas etapas para você.

Por que o modelo gera um token por vez

Esse detalhe explica várias características práticas dos LLMs. Como a geração é autorregressiva — cada novo token depende de todos os anteriores — a resposta é produzida sequencialmente, o que é o motivo de você ver o texto aparecer em fluxo (streaming), palavra por palavra. Também é por isso que respostas mais longas levam proporcionalmente mais tempo e custam mais: cada token de saída é uma passada completa pelo modelo. Entender que a saída nasce token a token ajuda a calibrar expectativas de latência e a decidir quando vale a pena pedir respostas mais curtas.

Por que a IA erra ao contar letras

Uma curiosidade reveladora: peça a um modelo para contar quantas vezes a letra "r" aparece em "morredouro" e ele pode tropeçar. O motivo é tokenização. O modelo não vê letras individuais — ele vê tokens como mor, red, ouro. Contar caracteres exige "desmontar" algo que, para o modelo, já chegou empacotado. Não é falta de inteligência; é uma consequência direta de como o texto foi fatiado na entrada.

O mesmo raciocínio explica por que modelos às vezes erram aritmética com números grandes: "1234567" pode virar dois ou três tokens, e a fronteira entre eles nem sempre respeita as casas decimais. Quando o número é fatiado em pedaços que não correspondem a casas, o modelo perde a estrutura posicional que a aritmética exige. É também por isso que pedir o raciocínio "passo a passo" ajuda: ao escrever os dígitos separadamente, o modelo recria uma representação mais favorável à conta.

Boas práticas para devs

Sabendo como tokens funcionam, dá para escrever sistemas mais baratos e previsíveis:

• Meça antes de mandar. Use um contador de tokens para estimar custo e garantir que o prompt cabe na janela.
• Enxugue prompts. Remova instruções redundantes e exemplos longos demais; cada token cortado é dinheiro economizado em escala.
• Cuidado com dados densos. Tabelas, IDs longos e código minificado podem custar muito mais tokens do que parecem.
• Trate português com folga. Reserve uma margem extra na sua estimativa, já que ele costuma gerar mais tokens que o inglês.
• Acompanhe o uso. A maioria das APIs retorna a contagem de tokens em cada resposta — registre isso para monitorar custos em produção.
• Aproveite o cache. Coloque a parte estável do prompt no início para se beneficiar de cache de prefixo, quando o provedor oferecer.
• Limite a saída. Defina um teto de tokens de resposta (max_tokens) para evitar respostas longas inesperadas que inflam a conta.

Perguntas frequentes

Quantas palavras cabem em uma janela de 128 mil tokens? Em inglês, algo em torno de 90 a 100 mil palavras. Em português, menos, porque a fragmentação é maior. Sempre estime com folga.

O mesmo texto gera o mesmo número de tokens em modelos diferentes? Não necessariamente. Cada família de modelos pode usar um tokenizador distinto, com vocabulário próprio. Conte os tokens com o tokenizador específico do modelo que você vai usar.

Por que minha conta de API subiu sem eu mudar o prompt? Em chats, o histórico é reenviado a cada turno. Conforme a conversa cresce, cada nova mensagem carrega todo o passado, e os tokens de entrada acumulam.

Espaços e pontuação contam como token? Sim. Espaços costumam grudar no token seguinte, e cada sinal de pontuação geralmente é um token. Formatação verbosa consome tokens reais.

Como reduzir custo sem perder qualidade? Enxugue instruções redundantes, use cache de prefixo, limite o tamanho da saída e, quando possível, escolha um modelo menor para tarefas simples. Medir antes de enviar é o hábito mais valioso.

Conclusão

Tokens são a moeda real dos modelos de linguagem: a unidade que define custo, que preenche a janela de contexto e que explica peculiaridades como erros de contagem de letras. O algoritmo BPE encontrou um equilíbrio elegante entre vocabulários pequenos e a capacidade de representar qualquer palavra, fragmentando o raro e agrupando o frequente. Para quem constrói com IA, pensar em tokens deixa de ser um detalhe técnico e vira uma ferramenta concreta de engenharia: controlar tokens é controlar custo, latência e o quanto de informação o modelo realmente consegue enxergar.

Referências

• Sennrich, R., Haddow, B., Birch, A. (2016). Neural Machine Translation of Rare Words with Subword Units. ACL.
• Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., et al. (2020). Language Models are Few-Shot Learners. NeurIPS.
• Kudo, T., Richardson, J. (2018). SentencePiece: A simple and language independent subword tokenizer and detokenizer for Neural Text Processing. EMNLP.