O que é um LLM?
- ⬜🕸️ Redes Neurais: o Cérebro Artificial(Fundamentos da IA)
Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.
GPT, Claude, Gemini, Llama — todos são LLMs. Mas o que eles fazem de verdade? A resposta é mais simples e mais surpreendente do que parece: um LLM faz uma única coisa — prevê o próximo token. Só que faz isso com tanta precisão, treinado em tanto texto, que o resultado emergente parece inteligência. Neste módulo, vamos além da superfície: como são treinados (e quanto custa), o que é context window, temperature, top-p, e por que um prompt de 100 palavras pode custar dinheiro real.
A tarefa fundamental: prever o próximo token
Do treino em trilhões de tokens de texto, o modelo aprendeu distribuições estatísticas sobre a linguagem humana. Ele não busca em banco de dados. Não acessa a internet. Não "entende" como um humano. O que faz é calcular probabilidades condicionais com uma precisão que emerge em comportamento que parece compreensão.
As 3 fases do treino
Context window: o limite mais importante
A context window é o número máximo de tokens que o modelo pode processar numa única chamada — incluindo prompt e resposta. Tudo que está fora da window não existe para o modelo.
| Modelo | Context window | Equivalente em texto | Nota |
|---|---|---|---|
| GPT-3.5 | 4k tokens | ~3.000 palavras | O ChatGPT original |
| GPT-4o | 128k tokens | ~100.000 palavras | ~1 livro inteiro |
| Claude 3.5 Sonnet | 200k tokens | ~150.000 palavras | ~2-3 livros |
| Gemini 1.5 Pro | 1M tokens | ~750.000 palavras | ~10 livros |
| Claude Opus 4 | 200k tokens | ~150.000 palavras | Extended thinking usa parte da window |
Temperature e top-p: controlando a aleatoriedade
Quando o modelo calcula a distribuição de probabilidade do próximo token, temperature e top-pcontrolam qual token é escolhido dessa distribuição:
| Parâmetro | Valor baixo | Valor alto | Quando usar |
|---|---|---|---|
| Temperature | 0 = greedy (sempre o mais provável) → determinístico | 1.0+ = mais aleatoriedade → diversidade/criatividade | Factuais/código: 0-0.2 · Criativo: 0.7-1.0 |
| Top-p (nucleus) | 0.1 = só os tokens mais prováveis que somam 10% | 0.95 = quase toda a distribuição entra | Geralmente 0.9-0.95 · combina com temperature |
Custos reais de API
Usar um LLM via API custa por token — separado em input (seu prompt) e output (resposta gerada). Output é mais caro porque é gerado sequencialmente (1 forward pass por token).
| Modelo (abril 2026) | Input (por 1M tokens) | Output (por 1M tokens) | Nota |
|---|---|---|---|
| GPT-4o | $2.50 | $10.00 | Bom equilíbrio custo/qualidade |
| Claude 3.5 Sonnet | $3.00 | $15.00 | Forte em código e raciocínio longo |
| Claude Opus 4 | $15.00 | $75.00 | Frontier — raciocínio profundo |
| GPT-4o mini | $0.15 | $0.60 | Classificação, roteamento, tarefas simples |
| Llama 3.1 405B (self-hosted) | ~$1.50 | ~$3.00 | Custo de GPU, sem markup de API |
Conta rápida: um chatbot que processa 100 mensagens/dia com média de 2.000 tokens por chamada (input+output) usando Claude 3.5 Sonnet: ~200k tokens/dia → ~6M tokens/mês → ~$18 input + ~$90 output = ~$108/mês.
Scaling Laws: tamanho importa — mas quanto?
Uma das descobertas mais importantes da pesquisa de LLMs foi que o desempenho segue leis de escala (scaling laws) previsíveis: à medida que você aumenta parâmetros, dados de treino e compute, o desempenho melhora de forma logarítmica e previsível. O paper Chinchilla (DeepMind, 2022) mudou como os modelos são treinados.
| Lei | O que diz | Consequência prática |
|---|---|---|
| Kaplan et al. (2020) | Loss ∝ N^(-α) — dobrar params reduz loss em fator fixo | GPT-3 foi treinado com 300B tokens em 175B params (sub-ótimo) |
| Chinchilla (2022) | Para compute fixo, N e D devem crescer proporcionalmente: N ≈ D | LLaMA 3 70B treinou em 15T tokens (4× mais dados que OpenAI) |
| Emergência | Capacidades surgem abruptamente acima de thresholds de escala | Chain-of-thought só emerge acima de ~100B params no pré-treino denso |
| Scaling de inferência | Mais compute no decode (sampling, refinamento) melhora qualidade | o1, DeepSeek-R1: "thinking" durante geração — nova fronteira |
Open-source vs Closed: a divisão que mudou a IA
Em 2023, a Meta abriu os pesos do LLaMA — e mudou a dinâmica da IA para sempre. Hoje existe uma divisão clara entre modelos abertos e fechados, com trade-offs reais:
| Aspecto | Modelos Fechados (GPT-4, Claude) | Modelos Abertos (LLaMA 3, Mistral, Qwen) |
|---|---|---|
| Acesso | Apenas via API do provedor | Download e deploy local ou em qualquer nuvem |
| Custo | Por token (variável com uso) | Custo de GPU/infraestrutura (fixo) |
| Privacidade | Dados vão para servidores do provedor | Dados ficam nos seus servidores |
| Customização | Fine-tuning limitado via API | Fine-tuning total, quantização, modificação da arquitetura |
| Qualidade frontier | GPT-4o, Claude Opus 4 ainda à frente | LLaMA 3 405B, Qwen 2.5 72B: competitivos em muitas tarefas |
| Compliance | Depende dos ToS do provedor | Controle total — essencial para saúde, financeiro, governo |
📋 Preciso decidir entre API de LLM fechado ou hospedar modelo open-source
API fechada: custo zero de infra, zero manutenção, qualidade frontier. Open-source: controle total, custo fixo em alto volume, privacidade, possibilidade de fine-tuning profundo.
Alt: API (Claude/GPT) — Para protótipos, uso esporádico, qualidade frontier necessária, equipe sem GPU expertise.
Alt: Open-source self-hosted — Para alto volume (>1M tokens/dia), regulação de dados (HIPAA, LGPD), fine-tuning vertical.
Limitações reais (o que o LLM NÃO faz)
| Limitação | O que acontece | Como mitigar |
|---|---|---|
| Alucinação | Gera texto plausível mas factualmente errado com alta confiança | RAG (busca em base), citations, verificação humana |
| Cutoff de treino | Não sabe eventos após a data de treino | Tool calling (busca web), RAG com dados frescos |
| Raciocínio multi-step | Erra em cadeias longas de lógica ou matemática | Chain-of-thought, decomposição, code execution |
| Contexto perdido | Depois da window, informação desaparece | Sumarização, RAG, agentic loops com memória |
| Sem estado entre chamadas | Cada request é independente — não "lembra" | Reenviar contexto, usar database externa |
Alucinação: por que acontece e como mitigar
Alucinação é o nome técnico para quando o LLM gera texto factualmente errado com aparente confiança. Não é um bug — é uma consequência direta de como LLMs são treinados: maximizar probabilidade do próximo token, não verificar facticidade.
| Tipo de alucinação | Exemplo | Causa provável | Mitigação |
|---|---|---|---|
| Factual incorreto | "A Torre Eiffel tem 450m" (são 330m) | Conflito ou ruído no corpus de treino | RAG com fonte autoritativa, citations |
| Citação inventada | Autor + título de paper que não existe | Interpolação de padrões de citação | Sempre verificar DOI/URL da citação |
| Código que compila mas não funciona | API com assinatura errada, método deprecado | Função raramente usada no corpus | Testes automatizados, type checking |
| Confabulação de timeline | "X aconteceu em 2019" (foi em 2021) | Datas raramente contextualizadas no corpus | Verificação de fatos com dados estruturados |
| Auto-confiança injustificada | Responde com certeza em domínio desconhecido | Calibração de confiança não é objetivo do treino | Prompts que pedem "diga se não sabe" |
Quantização: rodando grandes modelos em hardware menor
Um modelo de 70B parâmetros em FP32 precisa de ~280GB de VRAM — impossível em hardware comum.Quantização reduz a precisão dos pesos (de float32 para int8, int4 ou int2), reduzindo VRAM drasticamente com pequena perda de qualidade.
| Precisão | Bits por param | VRAM para 70B | Perda de qualidade | Tool |
|---|---|---|---|---|
| FP32 | 32 bits | ~280 GB | Nenhuma (referência) | PyTorch padrão |
| FP16 / BF16 | 16 bits | ~140 GB | Mínima | HuggingFace auto |
| INT8 (Q8) | 8 bits | ~70 GB | ~1–2% em benchmarks | bitsandbytes, llama.cpp |
| INT4 (Q4_K_M) | 4 bits | ~35 GB | ~3–5% em benchmarks | GGUF/llama.cpp, GPTQ |
| INT2 (Q2_K) | 2 bits | ~17 GB | >10% — perda notável | Apenas para hardware limitado |
Na prática, Q4_K_M é o sweet spot: LLaMA 3 70B quantizado em Q4 roda em 2× GPUs de 24GB (como 2× RTX 4090) com qualidade próxima ao FP16. Ferramentas comoollama e llama.cpp fazem isso automaticamente.
Modelos: quem é quem em 2026
📋 Preciso de qualidade máxima em raciocínio complexo, código ou análise longa
Modelos frontier com extended thinking/chain-of-thought. Custo alto, mas qualidade imbatível em tarefas complexas.
Alt: Modelos menores — Sonnet/GPT-4o cobrem 90% dos casos com custo 5-10× menor.
📋 Classificar textos, extrair dados, roteamento — alta velocidade, custo mínimo
Modelos leves otimizados pra throughput. 10-50× mais baratos que frontier. Perfeitos pra tarefas onde velocidade > qualidade frontier.
Alt: Modelos open-source (Llama, Mistral) — sem custo de API se auto-hosted, mas precisa de GPU.
Embeddings: como o modelo representa conhecimento
Internamente, um LLM representa cada token como um vetor de alta dimensão (geralmente 4096 a 16384 floats). Esse vetor é o embedding — uma codificação numérica onde tokens semanticamente similares ficam próximos no espaço vetorial. À medida que o texto passa pelas camadas do Transformer, os embeddings acumulam contexto: o vetor de "banco" muda dependendo de estar em "banco de dados" vs "banco do parque".
| Camada | O que o embedding captura | Exemplo |
|---|---|---|
| Input embedding (camada 0) | Identidade do token — puramente sintática | "run" e "running" são vetores diferentes |
| Camadas iniciais (1–10) | Sintaxe, POS tags, co-ocorrências locais | "banco" começa a diferenciar por contexto próximo |
| Camadas médias (10–40) | Entidades, relações semânticas, correferência | "ele" aponta para o sujeito anterior da frase |
| Camadas finais (40–96) | Raciocínio, intenção, resposta esperada | Representação otimizada para prever o próximo token |
Os embeddings da última camada são o que o modelo usa para calcular a distribuição de probabilidade do próximo token. É por isso que LLMs conseguem "entender" contexto longo — as camadas de atenção integram informação de qualquer posição dentro da context window.
Inferência: o que acontece quando você faz uma chamada
Perguntas típicas (Q&A)
❓ LLMs entendem o que dizem?
❓ Qual a diferença entre modelo base e modelo instruct?
❓ Fine-tuning é a mesma coisa que RAG?
❓ Posso rodar um LLM no meu computador?
Quiz rápido
4 perguntas · Acerte tudo e ganhe o badge 🎯 Gabarito