Como uma IA é treinada — entenda cada etapa do processo

No artigo anterior você aprendeu os conceitos: pesos, loss, backpropagation, épocas. Mas ainda falta a imagem concreta. O que acontece de verdade quando alguém treina um modelo? Você pega um texto, joga numa máquina, aperta um botão — e o que acontece depois? Como um arquivo de texto vira um modelo capaz de conversar?

Esse artigo vai percorrer o pipeline inteiro, passo a passo, do arquivo bruto ao modelo treinado. Sem pular etapas.

Etapa 0 — O dado bruto: o texto que vai ensinar o modelo

Tudo começa com texto. Muito texto. Para pré-treinamento de um LLM real, estamos falando de terabytes — livros digitalizados, artigos da Wikipedia, código-fonte do GitHub, páginas da web, fóruns, notícias, posts acadêmicos. O GPT-3 foi treinado em cerca de 300 bilhões de tokens. O LLaMA 3 usou mais de 15 trilhões.

Para um fine-tuning ou um experimento menor, pode ser um arquivo de texto simples mesmo — um .txt com algumas centenas de páginas, um conjunto de pares de perguntas e respostas, transcrições de atendimentos, documentos técnicos. O princípio é o mesmo independente da escala.

Mas antes de qualquer treinamento, esse texto passa por uma etapa de limpeza. Caracteres estranhos são removidos. Textos duplicados são eliminados — duplicatas fazem o modelo supervalorizar aquele conteúdo. Conteúdo de baixa qualidade é filtrado. O dado bruto nunca entra direto.

Etapa 1 — Tokenização: o texto vira números

O modelo não lê texto. Lê números. O primeiro passo é passar todo o conteúdo por um tokenizador — um programa que quebra o texto em pedaços (tokens) e substitui cada pedaço pelo seu ID numérico no vocabulário.

Esse processo acontece uma vez, antes do treinamento começar. O resultado é salvo em disco como um arquivo binário — uma sequência gigantesca de inteiros. É com esse arquivo que o treinamento vai trabalhar, não com o texto original. O texto em si não entra mais.

Etapa 2 — Montagem dos batches: o dado é fatiado

Com o arquivo de IDs em mãos, o sistema de treinamento começa a montar os batches — os lotes que serão processados um de cada vez. Cada batch é composto por várias sequências de tokens, e cada sequência tem um comprimento fixo chamado de context length (tamanho do contexto).

Se o context length é 2.048 tokens, o sistema pega 2.048 IDs consecutivos do arquivo, monta uma sequência, pega os próximos 2.048, monta outra — e assim por diante até montar o batch completo. Nada é escolhido aleatoriamente aqui; é uma leitura sequencial do arquivo.

Mas há um detalhe fundamental na forma como entrada e saída são definidas dentro de cada sequência. Para uma sequência de 5 tokens [A, B, C, D, E], o modelo recebe como entrada [A, B, C, D] e deve prever como saída [B, C, D, E]. Ou seja: dado o token atual, preveja o próximo.

Etapa 3 — Forward pass: o modelo tenta adivinhar

Com o batch montado, começa o forward pass. A sequência de IDs entra na rede. A primeira coisa que acontece é que cada ID é convertido para seu embedding — o vetor de significado que vimos no artigo anterior. Esses vetores entram nas camadas da rede.

Em cada camada, os vetores passam por operações matemáticas que envolvem os pesos do modelo. O mecanismo central dos transformers modernos — a atenção — permite que cada token “olhe” para os outros tokens da sequência e decida o quanto cada um importa para prever o próximo. Isso é o que dá ao modelo a capacidade de entender contexto longo.

No final da última camada, o modelo produz uma distribuição de probabilidades sobre todo o vocabulário para cada posição da sequência. Se o vocabulário tem 50.000 tokens, o modelo atribui uma probabilidade para cada um deles ser o próximo. O token com maior probabilidade é a previsão.

Etapa 4 — Cálculo do loss: quantificando o erro

Agora o sistema compara a previsão com a resposta correta — que já estava no arquivo de dados, um token à frente. A função de loss (cross-entropy) calcula um número único que representa o erro médio do batch inteiro.

A lógica é: se o modelo deu probabilidade alta ao token correto, o loss é baixo. Se deu probabilidade baixa, o loss é alto. E isso é calculado para cada posição de cada sequência do batch, depois a média é tirada. Um número só que resume o quão mal o modelo foi naquele lote.

Etapa 5 — Backpropagation: o erro volta pela rede

Com o loss calculado, o algoritmo de backpropagation entra em ação. Ele percorre a rede no sentido inverso — da saída para a entrada — e calcula, para cada peso, quanto ele contribuiu para o erro e em qual direção deve ser ajustado.

O resultado dessa operação é o gradiente — um conjunto de instruções, um por peso, dizendo “aumente um pouco” ou “diminua um pouco”. Para um modelo com 7 bilhões de parâmetros, isso são 7 bilhões de instruções calculadas a cada step.

Esse processo exige muito mais memória do que o forward pass. É por isso que treinar modelos grandes exige GPUs com dezenas de gigabytes de VRAM — e por isso que fine-tuning completo de LLMs ainda é caro mesmo em 2026.

Etapa 6 — Atualização dos pesos: o modelo muda um pouco

Com os gradientes em mãos, o otimizador atualiza os pesos. A fórmula básica é:

Na prática, otimizadores modernos como o AdamW são mais sofisticados que isso — eles acumulam informações dos gradientes anteriores para fazer ajustes mais inteligentes, acelerando onde o terreno é plano e diminuindo o passo onde há oscilação. Mas a intuição é a mesma: cada step move os pesos um pouco na direção que reduz o erro.

Um step concluído. O batch foi processado, o erro foi calculado, o backpropagation rodou, os pesos foram atualizados. O modelo agora é minimamente diferente do que era antes — e um pouco menos errado.

Etapa 7 — O loop: repetir até convergir

O sistema pega o próximo batch e repete tudo. Forward pass → loss → backpropagation → atualiza pesos. Próximo batch. Repete. Isso acontece continuamente, durante horas, dias ou semanas — dependendo do tamanho do modelo e da quantidade de dados.

A cada step, o engenheiro acompanha o gráfico de loss. No início do treinamento, o loss cai rápido — o modelo saiu de “não sabe nada” para “sabe alguma coisa”. Com o tempo, a queda desacelera e o loss se estabiliza. Esse plateau é o sinal de que o modelo está convergindo — chegando no melhor resultado possível com aqueles dados e aquela arquitetura.

Etapa 8 — Checkpoint: salvando o modelo

A cada N steps (mil, dez mil — depende da configuração), o sistema salva um checkpoint: um arquivo com todos os pesos do modelo naquele momento. Se o treinamento travar por alguma razão — e isso acontece em runs de dias —, dá para retomar do último checkpoint em vez de começar do zero.

O arquivo de pesos de um modelo é denso. O LLaMA 3 8B ocupa cerca de 16GB em disco no formato padrão. Versões quantizadas — que reduzem a precisão dos números para economizar espaço — chegam a 4–5GB. É esse arquivo que você baixa quando roda um modelo local no Ollama.

O pipeline completo — do texto ao modelo

E como isso vira um chatbot?

O que descrevemos até aqui é o pré-treinamento — a fase em que o modelo aprende a prever o próximo token em texto genérico. Um modelo pré-treinado consegue completar frases, mas não sabe responder perguntas de forma útil. Ele foi treinado para continuar texto, não para conversar.

Para virar um assistente, o modelo passa por uma segunda fase: o fine-tuning supervisionado com pares de instrução e resposta. Aqui sim o dado é estruturado: “Pergunta: X → Resposta: Y”. O modelo aprende o formato de diálogo.

Depois, técnicas como o RLHF (Reinforcement Learning from Human Feedback) fazem humanos avaliarem respostas e o modelo aprende a preferir as que foram melhor avaliadas. É isso que dá ao ChatGPT e ao Claude o comportamento de assistente útil e seguro — não só o pré-treinamento.