Conteúdo detalhado
⚖️ Pesos e parâmetros
Quando você vê um modelo chamado "Llama 3.1 8B" ou "Qwen2.5 32B", aquele número é a coisa mais importante da etiqueta. Ele diz o tamanho do cérebro do modelo. Entender o que ele significa já te deixa escolher melhor do que a maioria.
🆕 Novo aqui?
Parâmetros (pesos) são os números que o modelo aprendeu durante o treino — eles guardam tudo o que ele "sabe". "7B" quer dizer 7 bilhões de parâmetros (o B é de billion). "70B" = 70 bilhões; "235B" = 235 bilhões. Na prática, o arquivo do modelo é basicamente uma lista gigante desses números.
🔑 A regra que vale lembrar
Mais parâmetros costuma significar duas coisas ao mesmo tempo:
- •Mais capaz: tende a raciocinar melhor, errar menos, lidar com tarefas difíceis.
- •Mais pesado: ocupa mais memória e roda mais devagar na mesma máquina.
- •Não é linear: um 70B não é "10× melhor" que um 7B — o ganho diminui, mas o custo de memória sobe junto.
As faixas mais comuns que você vai encontrar no mundo local:
Pequenos · 1B–4B
Gemma 2 2B, Llama 3.2 3B, Phi. Rodam em quase qualquer laptop. Ótimos para classificação, resumo curto, autocompletar e tarefas simples.
Médios · 7B–14B
Llama 3.1 8B, Qwen2.5 7B/14B, Mistral 7B. O "ponto doce" do uso diário: bom em chat, escrita e código simples, ainda cabe em hardware modesto.
Grandes · 27B–70B
Gemma 2 27B, Qwen2.5 32B, Llama 3.1 70B. Raciocínio mais sólido; pedem GPU forte ou Mac com bastante memória unificada.
Enormes · 100B+
DeepSeek-V3, Llama 3.1 405B, modelos MoE (mistura de especialistas). Topo da casa local — exigem hardware de estação de trabalho ou Mac de muita memória.
📊 Detalhe útil: "base" vs "instruct"
Quase todo modelo vem em duas versões. O base só completa texto. O instruct (ou chat) foi ajustado para seguir instruções e conversar — é o que você quer 99% das vezes. Procure o sufixo -instruct ou -chat no nome.
🔤 Tokens e janela de contexto
O modelo não lê letras nem palavras inteiras: ele lê tokens. E ele só consegue prestar atenção em uma quantidade limitada deles de cada vez — a janela de contexto. Esses dois conceitos explicam por que às vezes o modelo "esquece" o começo de uma conversa longa.
🆕 Novo aqui?
Token = um pedaço de texto. Pode ser uma palavra curta, parte de uma palavra ou um sinal de pontuação. Uma regra de bolso para português/inglês: 1 token ≈ 4 caracteres ≈ ¾ de uma palavra. A frase "IA local é poder" tem ~5–6 tokens. Contexto = quantos tokens o modelo consegue "ler de uma vez" (entrada + resposta juntas).
A janela de contexto é medida em tokens. Os tamanhos mais comuns:
4.096 tokens — o básico
Cabe umas poucas páginas. Suficiente para perguntas e respostas curtas. Modelos antigos paravam aqui.
8.192 tokens — o confortável
Padrão de muitos modelos atuais. Dá para conversar bastante e colar um documento médio sem apertos.
128.000 tokens — o longo
Llama 3.1, Qwen2.5 e outros chegam aqui. Cabe um livro inteiro. Mas atenção: contexto grande custa memória — você raramente precisa usar tudo.
💡 O custo escondido do contexto
Quanto maior a janela que você liga, mais memória extra o modelo precisa enquanto trabalha (isso é o KV cache, que você vê no tópico 4). Por isso ter "128k de contexto" não é grátis: ligar tudo pode estourar a sua memória. A boa prática é usar só o contexto de que precisa.
🗜️ Quantização: o truque que faz IA caber
Este é, talvez, o conceito mais importante do módulo. Quantização é o que permite rodar um modelo grande em hardware modesto. É a diferença entre "não cabe na minha máquina" e "roda numa boa".
🆕 Novo aqui?
Quantização = reduzir a precisão de cada peso para ele ocupar menos espaço. Em vez de guardar cada número com muitos dígitos (FP16, 16 bits = 2 bytes por peso), você guarda com menos (Q8 ≈ 1 byte; Q4 ≈ meio byte). É como salvar uma foto em qualidade menor: o arquivo encolhe muito e, na prática, você quase não nota a diferença.
Olhe o mesmo modelo de 7B em três precisões. Repare como o tamanho desaba enquanto a qualidade quase não cai:
Leia de cima para baixo: o arquivo encolhe pela metade a cada passo (14 → 7 → 4 GB), enquanto a qualidade quase não muda (100% → ~97%). É por isso que quase todo mundo roda os modelos quantizados — o ganho de memória vale muito mais que a perdinha de qualidade.
✓ O que você ganha quantizando
- ✓O modelo cabe em muito menos memória
- ✓Roda mais rápido (menos dados para mover)
- ✓Hardware modesto passa a rodar modelos maiores
- ✓Q4/Q5 mantêm qualidade ótima para o dia a dia
✗ O preço a pagar
- ✗Pequena perda de precisão a cada nível
- ✗Quantizar demais (Q2, Q3) degrada de forma perceptível
- ✗Em tarefas muito exatas (código complexo) a perda aparece mais
- ✗Abaixo de Q4 raramente compensa
💡 Dica prática
Quando estiver em dúvida, comece com Q4_K_M ou Q5_K_M — são o "ponto doce" reconhecido pela comunidade: encaixam em pouca memória e mantêm qualidade bem alta. Você vê os sufixos completos (Q4_K_M, Q5_K_S…) em detalhe na Trilha 3, módulo 3.3.
🧠 Memória: o recurso que manda
Se há um único número que decide se um modelo roda na sua máquina, é a memória. Não é o tipo de processador, não é a marca da placa: é quanta memória você tem para carregar os pesos. Aqui você aprende a estimar isso de cabeça.
🆕 Novo aqui?
VRAM é a memória da placa de vídeo (GPU) — a mais rápida para IA. RAM é a memória do sistema. Em Macs com memória unificada, as duas são a mesma coisa. O modelo precisa caber nessa memória inteiro (ou quase) para rodar rápido. O KV cache é uma memória extra de trabalho que o modelo usa para "lembrar" do que já leu na conversa — e ela cresce junto com o contexto.
A regra de bolso é direta:
memória (GB) ≈ parâmetros (B) × bytes por peso + folga de contexto
Onde bytes por peso = 2 (FP16), 1 (Q8) ou ~0,5 (Q4). Some ~10–20% de folga para o sistema e o KV cache.
Aplicando a fórmula, esta é a tabela que vale colar na parede — estimativa de memória só dos pesos (some folga por cima):
| Modelo | Q4 (~0,5 B/peso) | Q8 (~1 B/peso) | FP16 (2 B/peso) |
|---|---|---|---|
| 7B | ~4 GB | ~7 GB | ~14 GB |
| 13B | ~7 GB | ~13 GB | ~26 GB |
| 34B | ~19 GB | ~34 GB | ~68 GB |
| 70B | ~39 GB | ~70 GB | ~140 GB |
Leitura prática: com uma GPU de 8 GB você roda confortável um 7B em Q4. Com 24 GB, um 34B em Q4 entra. Um 70B só cabe inteiro em hardware grande (GPU de 48 GB+ ou Mac com bastante memória unificada). Sempre deixe folga — o contexto come memória.
🧩 O KV cache, em uma frase
Além dos pesos, reserve memória para o KV cache: ele guarda o "trabalho em andamento" da conversa e cresce com o número de tokens no contexto. Dobrar o contexto pode dobrar esse custo. Por isso, num hardware apertado, baixar a janela de contexto às vezes é o que faz o modelo finalmente caber.
💡 Dica prática
Se o modelo não cabe inteiro na GPU, dá para mandar parte dele para a RAM (offload) — ele roda, mas mais devagar. Melhor que não rodar. A Trilha 2 (Hardware) e o módulo 3.4 mostram como ajustar isso na prática.
🌳 Famílias de modelos abertas
O mundo aberto não é um modelo só — são famílias, cada uma de um lab, com forças diferentes. Conhecer os nomes principais te poupa de ficar perdido na hora de escolher. Estas são as que você mais vai encontrar:
🦙 Llama (Meta)
A família mais popular e com maior ecossistema. Tamanhos de 1B a 405B. Generalista forte, muito material e ferramentas em volta. Licença própria (a "Llama Community License") — aberta, com algumas restrições.
🐉 Qwen (Alibaba)
Linha chinesa muito competitiva, de 0.5B a 72B+. Ótima em código e multilíngue (inclui português). Muitas variantes em licença Apache 2.0 — bem permissiva.
💎 Gemma (Google)
Modelos pequenos e médios (2B, 9B, 27B) muito eficientes — rendem acima do tamanho. Ótimos para hardware modesto. Licença própria de uso permitido amplo.
🌬️ Mistral (Mistral AI)
Lab europeu. Mistral 7B e Mixtral (MoE) ficaram famosos por entregar muito em pouco. Boa parte em Apache 2.0; alguns modelos premium têm licença restrita.
🐳 DeepSeek
Lab chinês que ganhou o mundo com modelos grandes de raciocínio e código (DeepSeek-V3, R1). Topo de capacidade aberta — mas os maiores pedem hardware sério.
🔬 Phi (Microsoft)
Modelos pequenos (3B–14B) treinados em dados de altíssima qualidade. Surpreendem para o tamanho. Licença MIT em várias versões — das mais permissivas.
🎯 Como navegar entre tantas
- •Faixa pequena (≤4B): Gemma 2 2B, Phi, Llama 3.2 3B, Qwen pequenos — para classificação, resumo e máquinas fracas.
- •Faixa diária (7B–14B): Llama 3.1 8B, Qwen2.5 7B/14B, Mistral 7B — chat e código do dia a dia.
- •Faixa pesada (27B+): Gemma 2 27B, Qwen2.5 32B, Llama 70B, DeepSeek — raciocínio sério, exige hardware forte.
- •Embeddings (tópico da Trilha 3): modelos minúsculos especializados (ex.: nomic-embed) — outra categoria, para memória/RAG.
💡 Dica prática
Não existe "o melhor modelo" — existe o melhor para a sua tarefa no seu hardware. Uma boa rotina: escolha 2–3 candidatos da faixa que cabe na sua memória e teste todos no mesmo prompt real seu. A diferença prática costuma decidir mais que qualquer ranking de benchmark.
📜 Licenças importam
"Aberto" não quer dizer "pode tudo". Cada família vem com uma licença que define o que você pode fazer — especialmente se for usar para trabalho ou produto. Ignorar isso pode dar dor de cabeça depois.
🆕 Novo aqui?
Licença = o "contrato de uso" do modelo. Ela diz se você pode usar comercialmente, redistribuir, modificar e quais condições precisa cumprir. As mais permissivas são Apache 2.0 e MIT (quase "faça o que quiser"). Outras, como a licença da Llama, são abertas mas têm restrições (ex.: regras para empresas muito grandes ou exigência de atribuição).
✓ Permissivas (Apache 2.0 / MIT)
- ✓Uso comercial liberado, sem pegadinha
- ✓Pode modificar e redistribuir
- ✓Ex.: muitos Qwen, Mistral 7B, Phi, modelos de embedding
- ✓A escolha mais tranquila para produto
✗ Restritas / customizadas
- ✗Podem limitar uso comercial em certa escala
- ✗Podem exigir atribuição ou aceite de termos
- ✗Algumas proíbem usos específicos
- ✗Ex.: licença Llama, alguns modelos "research only"
Onde tudo isso vive? No model card do Hugging Face — a página de cada modelo. Saber lê-la é a habilidade prática deste módulo:
⌨️ Exemplo prático: ler um model card no Hugging Face
Objetivo: abrir a página de um modelo e extrair, em 30 segundos, tudo o que decide se ele serve para você. Abra no navegador (não precisa baixar nada).
Como verificar: se você conseguiu dizer "é um 7B, 128k de contexto, Apache 2.0, tem GGUF Q4_K_M, versão instruct" — você lê um model card. Esses cinco itens são exatamente o que você precisa para decidir se ele cabe e se você pode usá-lo.
✅ Checklist antes de adotar um modelo
- →Cabe? Parâmetros × quantização batem com a sua memória (tópico 4).
- →Pode? A licença permite o seu uso (pessoal x comercial).
- →Serve? É a versão instruct e tem o contexto de que você precisa.
- →Existe pronto? Há GGUF quantizado disponível para baixar (Trilha 3).
Auto-checagem (opcional): você quer rodar um 13B e tem uma GPU de 8 GB. Qual a jogada mais sensata, segundo este módulo?
📌 Resumo do módulo
Próximo:
Você fechou a Trilha 1 — Fundamentos. A teoria está montada; agora é hora de hardware. Trilha 2 — Hardware & Lab: as categorias de máquina, o que cabe na sua e como montar seu lab.