Como os grandes modelos de linguagem aprenderam a conversar

Há algo um pouco inquietante na primeira boa conversa com uma máquina.

Você digita uma pergunta. A resposta chega quase imediatamente. Tem parágrafos. Lembra o que você disse três mensagens atrás. Pode explicar uma regra tributária, reescrever uma carta de amor, encontrar o erro de um programa em Python e, se você pedir com jeitinho, inventar uma história para dormir sobre um dragão deprimido que trabalha na contabilidade.

A reação natural é imaginar um pequeno sábio eletrônico dentro do computador, alguém que leu a internet e agora revira a memória procurando a resposta.

Não existe esse sábio.

O que acontece é menos mágico e, em certos aspectos, muito mais estranho.

Um grande modelo de linguagem (Large Language Model, LLM) moderno é um enorme sistema matemático treinado para reconhecer padrões da linguagem e prever o que provavelmente vem a seguir. Ele faz isso um pedacinho de texto por vez. Desse talento aparentemente modesto surge uma coleção surpreendente de capacidades: escrever, traduzir, programar, resumir, responder perguntas, analisar documentos e manter conversas que parecem extraordinariamente humanas.

Para entender por que essas máquinas funcionam, e por que às vezes erram com uma confiança tão espetacular, vale começar muito antes do ChatGPT, dos processadores gráficos e até da indústria moderna de computadores.

Antes do chatbot, havia uma pergunta

Em 1950, o matemático britânico Alan Turing publicou um artigo com um título maravilhosamente direto: Computing Machinery and Intelligence.

O artigo começava com uma pergunta:

As máquinas podem pensar?

Turing percebeu o problema imediatamente. Ninguém concordava sobre uma definição precisa de pensar, e os filósofos discutiam isso havia séculos sem precisar de uma tomada.

Então propôs algo mais prático.

Imagine conversar por texto com dois participantes que você não consegue ver. Um é humano. O outro é uma máquina. Se a máquina conversa tão bem que você não consegue distinguir os dois com segurança, talvez observar o que ela faz seja mais útil do que discutir se realmente “pensa”.

Essa ideia ficou conhecida como teste de Turing.

Turing não inventou o grande modelo de linguagem. Fez algo mais importante: ajudou a mudar a conversa de “O que é inteligência?” para “Que comportamento nos convenceria de que há inteligência?”.

Durante décadas, a resposta continuou principalmente teórica.

Computadores eram ótimos em aritmética. Conversar era outra história.

Ensinando linguagem aos computadores, uma regra por vez

Os primeiros programas de linguagem costumavam ser construídos com regras.

Se encontrar esta palavra, faça aquilo. Se a frase tiver esta estrutura, classifique assim. Se o usuário falar da mãe, talvez pergunte o que ele sente em relação a ela.

Isso produzia demonstrações engenhosas, mas havia um problema básico: a linguagem humana se recusa a se comportar.

Usamos sarcasmo. Omitimos palavras. Inventamos expressões. Mudamos o significado conforme o contexto. “That’s sick”, em inglês, pode se referir a uma doença ou a um solo de guitarra excelente.

Escrever regras suficientes para cobrir a linguagem comum acabou parecendo a tentativa de escrever um manual de instruções para ter personalidade.

Nas décadas de 1980 e 1990, pesquisadores recorreram cada vez mais à estatística.

Em vez de explicar exatamente como a linguagem funciona, podiam mostrar enormes quantidades de texto e deixar a matemática descobrir regularidades.

Uma família importante de sistemas era chamada de modelos de linguagem de n-gramas.

Um modelo de n-gramas observa sequências curtas de palavras e pergunta, em essência:

Dadas as palavras que acabei de ver, qual costuma vir depois?

Ao encontrar a expressão inglesa:

peanut butter and… — pasta de amendoim e…

você provavelmente esperaria geleia antes de helicóptero.

A máquina podia aprender o mesmo contando exemplos.

Era primitivo comparado à IA moderna, mas algo profundo havia mudado. Já não se ensinava cada regra ao computador. Ele começava a aprender padrões a partir de dados.

Palavras viram números

O computador não entende gato como o ser peludo sentado no teclado que está impedindo você de trabalhar.

Computadores entendem números.

Era preciso transformar linguagem em matemática sem perder todo o significado no caminho.

Um avanço importante foi a representação vetorial de palavras, ou word embedding.

Ela representa uma palavra como uma longa lista de números: um ponto num espaço matemático de centenas ou até milhares de dimensões.

Parece abstrato, mas a intuição é simples.

Palavras que aparecem em circunstâncias parecidas tendem a adquirir representações numéricas parecidas.

Rei e rainha ficam relacionados. Assim como Paris e França, Tóquio e Japão, cachorro e filhote.

O modelo não tem um verbete dizendo “filhote = cachorro jovem”. Aprende relações porque essas palavras aparecem repetidamente em vizinhanças linguísticas relacionadas.

Pela primeira vez, as máquinas tinham algo parecido com um mapa matemático do significado.

Mas ainda havia um problema.

Linguagem não é apenas um saco de palavras relacionadas. A ordem e o contexto importam.

Compare:

The bank approved my mortgage. — O banco aprovou meu financiamento.

E:

We sat on the bank of the river. — Sentamos na margem do rio.

A mesma palavra inglesa, bank. Mundos inteiramente diferentes.

Para trabalhar bem com a linguagem, um modelo precisa considerar as relações entre as partes da frase, não só as palavras isoladas.

Isso nos leva ao avanço que mudou a IA moderna.

O Transformer chega

Em 2017, oito pesquisadores publicaram Attention Is All You Need.

O título era um pouco atrevido. As consequências foram enormes.

O artigo apresentou uma arquitetura chamada Transformer.

A ideia central era um mecanismo chamado atenção.

A atenção permite observar uma sequência e determinar quais informações são especialmente relevantes umas para as outras.

Considere a frase:

Maria put the glass on the table because it was wet.

Maria colocou o copo na mesa porque “it” estava molhado. O que estava molhado?

O copo? A mesa?

Um sistema de linguagem útil precisa examinar as palavras ao redor e suas relações para decidir.

A atenção oferece um mecanismo matemático para isso.

Em vez de tratar a linguagem apenas como uma corrente rígida — primeira palavra, segunda, terceira —, um Transformer pode examinar muitas relações no texto e atribuir importâncias diferentes a elas.

Isso tornou o treinamento muito mais eficiente em hardware paralelo moderno e permitiu construir modelos muito maiores.

E, quando eles cresceram, algo surpreendente aconteceu.

Passaram a ser úteis em tarefas que ninguém havia programado explicitamente.

Afinal, o que significa “grande”?

Quando alguém fala em 8B, 14B ou 70B, o B significa bilhão.

Um modelo 8B contém cerca de oito bilhões de parâmetros.

Um parâmetro é um dos valores numéricos ajustáveis de uma rede neural.

Imagine uma mesa de som gigantesca, com bilhões de pequenos botões.

No início do treinamento, eles estão mal regulados. O modelo faz previsões ruins.

O treinamento apresenta exemplos, mede os erros e ajusta um pouquinho os botões.

Isso se repete uma quantidade quase inimaginável de vezes.

No fim, a combinação desses ajustes captura uma enorme coleção de padrões.

Esses valores armazenados costumam ser chamados de pesos do modelo.

Quando você baixa um arquivo de cinco, dez, vinte ou cinquenta gigabytes, boa parte é, essencialmente, uma coleção gigantesca de números aprendidos.

O conhecimento não fica numa enciclopédia organizada com capítulos “Napoleão”, “Programação em Python” e “Como fazer lasanha”.

Ele está distribuído pelos pesos.

Por isso um modelo pode ser brilhante num momento e bizarro no seguinte.

Não são bancos de dados tradicionais.

São máquinas de padrões.

A menor unidade de uma conversa não é uma palavra

Suponha que você escreva:

I absolutely love this computer.

O modelo não precisa dividir a frase nas mesmas palavras que você conta.

Antes de chegar à rede neural, outro programa, o tokenizador, corta o texto em unidades chamadas tokens.

Um token pode ser uma palavra inteira.

Parte de uma palavra.

Um sinal de pontuação.

Parte de um número.

Computer pode ser um token num modelo e vários em outro.

Isso importa muito: sistemas de IA medem o espaço de trabalho em tokens, não em páginas ou palavras.

Um limite de 32.000 tokens não significa 32.000 palavras.

Significa aproximadamente 32.000 pedaços segundo o tokenizador daquele modelo.

Idiomas diferentes podem consumir quantidades diferentes para a mesma ideia. Inglês, russo, espanhol, chinês, código e notação matemática podem ser divididos de formas distintas.

Por isso a contagem parece misteriosa quando começamos com modelos locais.

O modelo lê a mesma frase que você, mas matematicamente pode estar vendo um conjunto de pedaços muito diferente.

A pontuação invisível das conversas com IA

Existe outra classe de tokens que normalmente você não vê.

São os tokens especiais.

Imagine uma peça de teatro sem indicação de quem está falando. Logo você se perderia.

As conversas com IA têm o mesmo problema.

O modelo precisa de marcas invisíveis que podem significar:

As instruções do sistema começam aqui.

É o usuário que está falando.

Agora o assistente deve responder.

Esta mensagem terminou.

Um exemplo importante é o token de fim de sequência (End-of-Sequence, EOS).

Pense nele como uma pontuação especial entendida pelo modelo, não pelo leitor.

Famílias diferentes usam tokens especiais diferentes. Os aplicativos geralmente os inserem automaticamente.

Talvez você nunca os veja.

Mas eles ocupam espaço.

Isso nos leva a uma das partes mais mal compreendidas da IA local.

O modelo tem uma mesa, e ela não é infinita

Todo modelo de linguagem tem uma janela de contexto.

É a quantidade de informação com que pode trabalhar ativamente de uma só vez.

Imagine contratar um pesquisador brilhante com uma biblioteca enorme, mas apenas uma mesa.

Os livros representam o conhecimento aprendido no treinamento.

A mesa representa a janela de contexto.

Tudo o que você quer que ele considere agora precisa caber nessa mesa.

Sua pergunta ocupa espaço.

O histórico ocupa espaço.

Um documento ocupa espaço.

O código ocupa espaço.

As instruções ocupam espaço.

As ferramentas ocupam espaço.

A resposta também precisa de espaço.

Um modelo anunciado com 32.000 tokens não oferece todos eles para seu documento.

Talvez vários milhares já tenham sido usados antes de ele chegar.

Isso importa especialmente nos agentes: o modelo pode receber instruções do sistema, descrições de ferramentas, habilidades carregadas, resultados de buscas, arquivos, ações anteriores e histórico antes mesmo de começar sua tarefa.

A janela teórica e o contexto útil de trabalho não são a mesma coisa.

Essa diferença é uma das razões pelas quais criamos o Green Zone.

O modelo também precisa de um caderno

Outro consumidor de memória tem um nome maravilhosamente enigmático:

Cache de chaves e valores (Key-Value Cache, KV cache).

Parece algo escondido num servidor de banco de dados. A ideia é bem mais simples.

Imagine uma conversa longa.

A cada frase nova, a outra pessoa não começa a conversa do zero, recalculando mentalmente todas as frases anteriores.

Ela mantém informações de trabalho sobre o que já aconteceu.

Um Transformer faz algo parecido.

Ao processar tokens, calcula informações internas chamadas chaves e valores. Em vez de recalculá-las a cada token novo, o sistema as guarda temporariamente no KV cache.

Os pesos são como o conhecimento aprendido a longo prazo. O KV cache é como o caderno temporário da conversa atual.

Quanto mais longa a conversa, maior o caderno.

E o caderno ocupa memória.

Daí surge um problema prático importante.

Um modelo pode caber tecnicamente na placa de vídeo e ser quase inútil para o trabalho que você quer fazer.

Suponha que sua placa tenha 32 gigabytes de memória de vídeo (Video Random Access Memory, VRAM).

A VRAM é a memória rápida usada pela unidade de processamento gráfico (Graphics Processing Unit, GPU).

Se os pesos ocupam 27 gigabytes, dá vontade de comemorar.

Vinte e sete é menos que trinta e dois.

Vitória!

Não necessariamente.

Sobram cerca de cinco gigabytes para KV cache, buffers do programa, memória temporária e tudo o mais que a inferência exige.

É como comprar um sofá que cabe na sala, mas não deixa espaço para abrir a porta.

O sofá cabe.

A sala deixa de funcionar.

Quantização: ensinando números grandes a viajar leves

É aqui que entra a quantização.

Pesos são números. Computadores podem armazená-los com diferentes níveis de precisão numérica.

Mais precisão guarda mais informação sobre cada número, mas exige mais memória.

A quantização usa menos bits para armazená-los.

Imagine registrar medições num laboratório.

Você pode escrever:

3.14159265358979

Ou:

3.14

A segunda versão ocupa menos espaço. Também descarta precisão.

A quantização aplica uma versão muito mais sofisticada dessa ideia aos pesos das redes neurais.

Você encontrará Q8, Q6, Q5 e Q4.

O Q significa quantizado.

O número dá uma indicação aproximada dos bits usados para representar os pesos.

Q8 usa aproximadamente oito bits.

Q4, aproximadamente quatro.

Por isso Q4 geralmente ocupa muito menos memória que Q8.

Isso não transforma um modelo de oito bilhões de parâmetros num de quatro bilhões.

Ele continua com cerca de oito bilhões.

Você apenas compactou mais a representação numérica.

Existe uma troca.

Menos precisão economiza memória, mas perde informação.

Felizmente, os métodos modernos podem preservar a qualidade surpreendentemente bem. Uma boa versão Q4 ou Q5 pode ser muito útil e ocupar muito menos memória que uma versão de dezesseis bits.

Você também encontrará ponto flutuante de 16 bits (FP16) e Brain Floating Point 16 (BF16).

São formatos de maior precisão comuns na IA moderna.

A pergunta prática não é:

Qual formato tem mais precisão?

A pergunta útil é:

Qual formato oferece qualidade suficiente e deixa memória para o trabalho que quero fazer?

Essa é uma pergunta muito melhor.

Por que um modelo Instruct tem boas maneiras

Nomes de modelos contêm pistas.

Por exemplo:

Qwen 8B Instruct

Qwen informa a família.

8B informa cerca de oito bilhões de parâmetros.

Instruct significa outra coisa.

Depois do enorme treinamento inicial, o modelo pode lidar razoavelmente bem com a linguagem e continuar sendo estranho de conversar.

Você pede:

Explique a gravidade para uma criança de doze anos.

Um modelo apenas pré-treinado não foi necessariamente ensinado a se comportar como um assistente útil.

Então os desenvolvedores fazem treinamento adicional com exemplos de instruções e respostas desejáveis.

Isso se chama ajuste fino com instruções.

O modelo vê exemplos como:

Usuário: Resuma este parágrafo.

Seguidos de um resumo útil.

Ou:

Usuário: Escreva uma função Python que ordene estes dados.

Seguidos do código apropriado.

Depois de exemplos suficientes, aprende melhor o padrão:

Uma pessoa me pede algo; devo tentar fazer.

Daí o nome Instruct.

É mais uma descrição da educação do que uma medida de inteligência.

O modelo base foi à escola.

O Instruct também fez aulas de etiqueta.

Ajuste fino: mandando o modelo de volta à escola

De forma geral, ajuste fino, ou fine-tuning, significa continuar treinando um modelo já treinado para uma finalidade mais especializada.

Imagine alguém com formação universitária ampla que depois entra na faculdade de medicina.

A pessoa não esquece como ler ou fazer contas.

Ela recebe formação especializada.

Da mesma forma, um modelo geral pode ser ajustado para programação, medicina, finanças, atendimento, textos jurídicos ou determinados estilos de interação.

O ajuste completo pode ser caro porque modifica muitos pesos.

Uma técnica mais leve, a adaptação de baixo posto (Low-Rank Adaptation, LoRA), adapta o modelo com mais eficiência treinando componentes adicionais relativamente pequenos.

Pense na LoRA como acrescentar anotações cuidadosamente preparadas a uma enciclopédia, em vez de reescrevê-la.

O livro principal continua quase igual.

Três famílias de Transformer

Nem todo Transformer foi feito para o mesmo trabalho.

Uma categoria é o codificador, ou encoder.

Ele lê informações e produz uma representação numérica.

O BERT, do Google, é um exemplo famoso.

Codificadores ajudam a identificar assuntos, encontrar documentos parecidos, extrair nomes e classificar sentimentos.

Depois há os decodificadores, ou decoders.

Eles geram novos tokens.

A maioria dos modelos de conversa executados localmente — Llama, Qwen, Mistral, Gemma e similares — pertence principalmente a essa família.

São bons em responder, escrever, programar e continuar sequências.

Por fim, há sistemas codificador-decodificador, também chamados sequência a sequência.

Uma parte lê a entrada. Outra gera a saída.

T5 e BART são exemplos.

Eles se tornaram especialmente úteis para tradução e resumo.

Você não precisa decorar essas categorias para usar IA local.

Mas elas explicam por que dois modelos chamados Transformer podem se comportar de maneiras bem diferentes.

Uma picape e um Fórmula 1 têm motores.

Você não escolheria entre eles contando só os cilindros.

O estranho poder de prever o próximo token

Talvez este seja o fato mais estranho sobre os grandes modelos de linguagem.

No fundo, muitos modelos generativos são treinados para fazer algo quase constrangedoramente simples:

prever o que vem a seguir.

Você escreve:

A capital da França é…

O modelo atribui probabilidades aos próximos tokens possíveis.

Paris recebe uma probabilidade muito alta.

Banana recebe, esperamos, uma muito baixa.

O modelo escolhe um token.

E repete o processo.

De novo.

E de novo.

Milhares de vezes.

Dessa repetição surgem parágrafos, programas, explicações, traduções, poemas, argumentos, piadas e, às vezes, absurdos completos ditos com a segurança de alguém que dá direções numa cidade onde nunca esteve.

Essa última parte importa.

Um LLM não é uma máquina da verdade.

É uma máquina de previsão.

Seu objetivo é produzir uma continuação plausível, não jurar que cada frase está correta.

Por isso modelos podem alucinar: produzir informações convincentes, mas falsas.

A palavra é imperfeita, mas o fenômeno existe.

O modelo não está necessariamente “mentindo”.

Está gerando uma continuação compatível com padrões aprendidos mesmo quando o fato está errado.

Do chatbot ao agente

Um modelo de linguagem sozinho só pode gerar informação.

Um agente de IA acrescenta ferramentas.

Voltemos ao pesquisador sentado à mesa.

Sem ferramentas, responde usando a memória e os documentos colocados à sua frente.

Agora dê a ele:

uma calculadora,

um buscador,

acesso a arquivos,

um banco de dados,

um interpretador Python

e permissão para realizar determinadas ações.

Ele se torna muito mais útil.

Um agente funciona de forma parecida.

O LLM fornece o componente de linguagem e de decisão.

Programas comuns executam as ações.

Quando precisa de um número num banco de dados, solicita a ferramenta correspondente.

Quando precisa examinar um arquivo, solicita a ferramenta de leitura.

Quando precisa fazer contas, chama uma calculadora em vez de tentar ser uma.

Essa diferença importa: às vezes falamos de agentes como se o modelo tivesse adquirido poderes mágicos.

Não adquiriu.

Recebeu ferramentas.

Um carpinteiro com uma furadeira continua sendo o mesmo carpinteiro.

A furadeira apenas muda o que ele pode realizar.

Rodar IA localmente muda as perguntas

Num serviço de IA na nuvem, o hardware pertence a outra pessoa.

Você envia o pedido.

Um centro de dados distante cuida de processadores gráficos, memória, refrigeração, fontes de alimentação e da assustadora conta de luz.

Rodar o modelo localmente muda a relação.

Agora o hardware é seu.

De repente, perguntas que pertenciam aos engenheiros de centros de dados aparecem na sua mesa.

Quanta VRAM eu tenho?

Quanto ocupam os pesos?

Qual quantização escolher?

Quanto contexto posso usar?

Quanta memória o KV cache vai consumir?

Posso carregar o modelo e ainda ter espaço para fazer algo útil?

No começo parece uma sopa de letrinhas.

GPU. VRAM. KV. Q4. Q8. FP16.

Mas por trás das siglas existe um problema muito comum:

Você tem um espaço limitado. O que quer colocar nele?

É esse problema que o Green Zone foi criado para tornar visível.

A diferença entre caber e funcionar

Imagine duas pessoas arrumando malas para viajar.

A primeira enche a mala de roupas até o limite.

Consegue fechar o zíper e comemora.

Vitória?

Então lembra dos sapatos, remédios, escova de dentes e do passaporte que, de algum modo, ficou no fundo de tudo.

A segunda deixa espaço de propósito.

Tecnicamente, a primeira mala leva mais roupas.

Na prática, a segunda está mais preparada para a viagem.

A IA local tem o mesmo problema.

Você pode carregar o maior modelo possível e se parabenizar porque ele cabe.

Mas, se quase não sobra memória para contexto e estado de trabalho, talvez tenha montado um sistema impressionante que mal consegue realizar confortavelmente a tarefa para a qual foi comprado.

Escolher um modelo não é uma competição pelo maior número seguido de B.

Uma configuração útil é um equilíbrio.

Capacidade do modelo.

Quantização.

Contexto.

KV cache.

Ferramentas.

Arquivos.

Histórico da conversa.

Espaço para respostas.

E a memória física disponível na placa de vídeo.

A melhor configuração não é necessariamente o maior modelo que seu hardware consegue carregar.

É a que deixa espaço suficiente para o modelo trabalhar.

Quando você entende essa diferença, a floresta intimidadora de números nas páginas de download fica muito menos misteriosa.

Você deixa de perguntar:

Consigo espremer esse modelo na minha placa de vídeo?

E faz a pergunta que realmente importa:

Se eu colocar esse modelo na minha placa, quanto espaço sobrará para pensar, lembrar a conversa, usar meus arquivos e terminar o trabalho?

É aí que a IA local deixa de ser uma coleção de especificações misteriosas e vira um problema de engenharia que pessoas comuns conseguem compreender.