Velocidade de Geração (TPS / TTFT / Latência)

1. Visão geral do conceito e problema sistêmico

Em discussões de engenharia, o desempenho dos modelos é frequentemente reduzido a definições vagas como "rápido" ou "lento". Essa abordagem amadora leva ao fracasso de sistemas em tempo real: a interface do bot de voz congela por vários segundos antes de responder, o autocompletar de código na IDE irrita com a latência de exibição dos caracteres, e os loops agênticos em segundo plano ficam presos em filas que duram horas.

A inferência real de grandes modelos de linguagem obedece às leis da física dos semicondutores e divide-se em duas fases de hardware completamente distintas:

1. Fase de Prefill (Prefill / Context Phase): processamento paralelo do prompt de entrada.
2. Fase de Decodificação (Decode / Generation Phase): geração sequencial dos tokens de saída, um por um.

As métricas TTFT (Time to First Token) e TPS (Tokens Per Second) são a bússola sistêmica do engenheiro, definindo a arquitetura das filas, a escolha do hardware e a experiência do usuário em aplicações interativas.

2. Taxonomia arquitetural e modelo mental

As métricas de latência e throughput são classificadas pelas etapas do ciclo de vida da requisição:

┌─────────────────────────────────────────────────────────────┐
│                 TAXONOMIA DE LATÊNCIA DE INFERÊNCIA         │
├─────────────────────────────────────────────────────────────┤
│ 1. Tempo de Fila (Aguardando recursos GPU disponíveis)      │
├─────────────────────────────────────────────────────────────┤
│ 2. Fase de Prefill ➔ TTFT (Tempo até o Primeiro Token)      │
│    • Limitado por Computação (TFLOPS dos Tensor Cores)      │
│    • Cálculo direto do cache KV para todo o texto de entrada│
├─────────────────────────────────────────────────────────────┤
│ 3. Fase de Decodificação ➔ TPS / ITL (Latência entre Tokens)│
│    • Limitado pela Largura de Banda de Memória (GB/s da     │
│      barramento VRAM)                                       │
│    • Leitura sequencial dos pesos para cada token           │
├─────────────────────────────────────────────────────────────┤
│ 4. Latência Total E2E = TTFT + (N_tokens_gerados * ITL)     │
└─────────────────────────────────────────────────────────────┘

1. TTFT (Time to First Token — tempo até o primeiro token):
   • Número de milissegundos desde o momento em que o cliente envia a requisição HTTP até o recebimento do primeiro byte da resposta em streaming. É composto pela latência de rede, espera na fila e tempo de cálculo do prefill.
2. TPS (Tokens Per Second — velocidade de geração):
   • Quantidade de tokens que o sistema emite por segundo. Para um único stream, isso equivale a $1 / \text{ITL}$. Para o servidor inteiro (Aggregate Throughput), é a soma dos tokens gerados por todos os clientes simultaneamente.
3. ITL (Inter-Token Latency — latência entre tokens):
   • Tempo entre a aparição de tokens vizinhos durante o streaming. Para o olho humano, um indicador confortável é inferior a 30 ms por token (correspondente a >33 TPS).
4. Decodificação Especulativa (Speculative Decoding):
   • Truque algorítmico que converte parte das operações da fase Decode em verificação paralela, aumentando o TPS puro em 2–3 vezes sem perda de precisão.

3. Pipeline técnico e mecânica interna

O ciclo de vida da inferência sob a lupa dos timings:

1. Recepção da requisição e batching: A requisição com 4000 tokens de código entra no motor de inferência (por exemplo, vLLM).
2. Prefill (Fase de Prefill): A GPU carrega as matrizes de pesos e multiplica paralelamente todos os 4000 tokens nos núcleos Tensor Cores. Os vetores Q, K, V são calculados e a memória do KV-cache é inicializada.
3. Emissão do primeiro token (Fixação do TTFT): O primeiro token é enviado ao cliente via Server-Sent Events. Se o prompt estiver cacheado (Prompt Caching), esta etapa leva 50 ms; caso contrário, varia de 500 ms a 3 segundos.
4. Loop sequencial de decodificação (Decode Loop):
   • Para gerar um token, a placa de vídeo deve ler todos os 70 bilhões de parâmetros do modelo da VRAM para o cache do chip.
   • Em uma memória com throughput de 1000 GB/s (RTX 4090), a leitura de um modelo quantizado de 35 GB leva: $$35 \text{ GB} / 1000 \text{ GB/s} = 35 \text{ ms por token} \approx 28 \text{ TPS}$$
5. Conclusão da requisição: A geração termina ao atingir o token <|im_end|> ou o limite de comprimento, e os recursos do KV-cache são liberados para outras requisições.

4. Cenários práticos de engenharia em produção

01. Desenvolvimento de assistente de voz com reação viva (Human-Like Latency)

O humano percebe uma pausa na conversa se a resposta demorar mais de 500 ms:

• Engenheiros escolhem o modelo Gemini 2.0 Flash ou Mistral NeMo com implantação local.
• Graças à otimização da stack, o TTFT é reduzido a 180 ms, e a conversão de texto em fala (TTS) leva mais 120 ms. O tempo total de reação de 300 ms cria o efeito de diálogo vivo.

02. Autocompletar de alta velocidade na IDE (Ghost Text)

O desenvolvedor digita código no Cursor a uma velocidade de 5 caracteres por segundo:

• Qualquer latência superior a 150 ms faz com que a sugestão apareça apenas depois que o desenvolvedor já digitou um novo caractere.
• Para essas tarefas, usam-se modelos leves específicos (3B–7B parâmetros) ou motores especulativos que entregam os primeiros caracteres em 40–80 ms.

03. Processamento em lote de grandes volumes de documentos no backend

Processamento noturno de 100.000 arquivos PDF de usuários:

• O TTFT individual para cada arquivo não tem importância.
• O servidor é otimizado para Aggregate Throughput: através do continuous batching no vLLM, o cluster atende paralelamente 256 streams, atingindo uma velocidade agregada de 4.000 tokens por segundo.

5. Armadilhas, erros comuns e segurança

• Queda de TPS devido ao esgotamento do KV-cache: Quando a memória da GPU está 95% cheia, o motor começa a descarregar o cache para SSD ou CPU. A velocidade de geração cai instantaneamente dezenas de vezes, paralisando o sistema.
• Corrida cega por TPS sem controle de qualidade: Um modelo de alta velocidade (200 tokens/s) que escreve código inoperante com erros sintáticos apenas aumenta o tempo de desenvolvimento devido às correções manuais.
• Ilusão de velocidade devido ao buffering de rede: Se o proxy server (Nginx ou Cloudflare) bufferizar a resposta em vez de fazer streaming (ausência do header X-Accel-Buffering: no), o cliente não verá nenhum token até que o modelo tenha gerado todo o texto completamente.
• Impacto do comprimento do contexto no TTFT: Ao aumentar o prompt de entrada de 2.000 para 100.000 tokens, o tempo de prefill cresce desproporcionalmente sem caching ativado, transformando um modelo "rápido" em lento.