Conteúdo detalhado
🤗 Hugging Face: o "GitHub dos modelos"
Antes de rodar qualquer coisa, você precisa de um lugar pra pegar os modelos. Esse lugar é o Hugging Face: o repositório central onde quase todo modelo aberto mora. Saber ler uma página de modelo lá já resolve 80% das suas dúvidas de "qual baixar".
🆕 Novo aqui?
Hugging Face (o "HF") é tipo um GitHub só para IA: um site onde laboratórios e a comunidade publicam modelos abertos, cada um na sua "página de modelo" (o model card). O model card é o README do modelo — descreve o que ele é, quantos parâmetros tem, qual licença, e lista os arquivos para baixar.
🔑 O que ler no model card
Abra a página do modelo e procure quatro coisas — elas decidem tudo:
- •Parâmetros: está no nome (7B, 14B, 70B). Mais parâmetros ≈ mais capaz e mais pesado.
- •Variante: prefira a versão Instruct / Chat (treinada para conversar), não a "base" crua.
- •Aba "Files": os arquivos reais. É onde você vê se existe
GGUFe quais quantizações. - •Licença: aberto ≠ liberado pra tudo. Confira uso comercial antes de depender dele.
📊 Atalho de garimpo
- Procure repositórios com "GGUF" no nome (ex.: publicados por bartowski ou pelo próprio lab) — já vêm prontos para Ollama/LM Studio.
- Ordene por downloads/trending: o que a comunidade usa costuma ser estável e bem testado.
- Modelo bom e popular hoje para começar: Qwen2.5, Llama 3.1/3.2, Gemma 2, Mistral.
📦 Formatos: GGUF, safetensors, GPTQ/AWQ
Na aba "Files" você vai topar com extensões diferentes. Elas não são versões "melhores" ou "piores" — são embalagens para runtimes diferentes. Escolher a errada é a causa nº 1 de "baixei e não roda".
🆕 Novo aqui?
GGUF = formato de arquivo único que empacota o modelo já pronto para rodar em CPU e/ou GPU via llama.cpp — o motor por trás do Ollama e do LM Studio. É o formato da IA local "plug and play".
safetensors = formato de pesos "crus", do ecossistema Python/PyTorch (Transformers, vLLM). Seguro e padrão para treino e servidores de GPU — mas pede mais setup.
GPTQ / AWQ = pesos já quantizados feitos para rodar só em GPU via runtimes como vLLM/AutoGPTQ. Rápidos em GPU, mas não é o caminho mais simples para começar.
✓ GGUF — escolha do curso
- ✓Roda no Ollama e no LM Studio sem configurar nada
- ✓Funciona em CPU, GPU ou os dois (offload)
- ✓Um arquivo só, com a quantização embutida
- ✓Ideal para Mac, laptop e PCs sem GPU monstro
✗ safetensors / GPTQ / AWQ
- ✗Pedem Python + Transformers/vLLM e dependências
- ✗GPTQ/AWQ geralmente exigem GPU NVIDIA dedicada
- ✗Não abrem direto no Ollama/LM Studio
- ✗Brilham em servidores e treino — não no "começar fácil"
💡 Regra prática
Para tudo neste curso (Ollama, LM Studio), a resposta é quase sempre GGUF. Só vá para safetensors/GPTQ/AWQ quando você for servir em escala numa GPU dedicada — assunto da Trilha 4. Na dúvida: existe GGUF? Baixe o GGUF.
🔢 Lendo as quantizações
Dentro do GGUF tem um monte de variantes: Q4_K_M, Q5_K_M, Q8_0... Esse é o coração da escolha. Decifrar esses sufixos é o que separa "baixei certo" de "baixei 14 GB que não cabem".
🆕 Novo aqui?
Quantização = reduzir a precisão dos pesos do modelo (de 16 bits para 8, 5, 4...) para o arquivo ficar muito menor e caber em menos memória, perdendo pouca qualidade.
Lendo Q4_K_M: o Q4 = ~4 bits por peso (quanto menor o número, menor e "mais comprimido"); o K = método moderno "k-quant" (mais inteligente que o antigo); o M = tamanho Medium da variante (há S/small e L/large). FP16 = sem quantização, precisão cheia.
Use um modelo 7B como régua. Veja o que cada quantização faz com o tamanho e a qualidade — o ponto doce é onde o arquivo já é pequeno mas a qualidade quase não caiu:
| Quant | Bits/peso | Tamanho (7B) | Qualidade | Quando usar |
|---|---|---|---|---|
| FP16 | 16 | ~14 GB | máxima | referência / VRAM sobrando |
| Q8_0 | ~8 | ~7.7 GB | ~quase idêntica | quer qualidade quase total |
| Q6_K | ~6.5 | ~5.5 GB | ótima | meio-termo alto |
| Q5_K_M | ~5.5 | ~5.1 GB | muito boa | ponto doce alto |
| Q4_K_M ★ | ~4.5 | ~4.4 GB | boa | melhor equilíbrio (padrão) |
| Q3_K_M | ~3.5 | ~3.5 GB | começa a cair | só se faltar memória |
| Q2_K | ~2.6 | ~2.8 GB | degrada bastante | último recurso |
Leia de cima para baixo: o arquivo encolhe rápido (de ~14 GB para ~4.4 GB) enquanto a qualidade cai devagar — até o Q4_K_M, onde a curva ainda está alta. Abaixo dele (Q3, Q2) a qualidade começa a despencar. Por isso a comunidade trata Q4_K_M / Q5_K_M como o equilíbrio padrão.
💡 Dica prática
Regra de bolso: comece em Q4_K_M. Se sobrar memória, suba para Q5_K_M ou Q8_0 e ganhe um tiquinho de qualidade. Só desça para Q3/Q2 se o modelo não couber — e sabendo que vai notar a perda.
⬇️ Baixando: via Ollama vs direto
Existem dois caminhos: deixar o Ollama baixar pra você (o mais fácil) ou pegar um GGUF direto do Hugging Face e registrar na sua máquina. Você vai usar os dois — comece pelo simples.
⌨️ Caminho 1 — Ollama baixa pra você
Objetivo: baixar o Qwen2.5 7B já no formato e quantização certos, com um comando. O q4_K_M na tag escolhe a quantização do ponto doce.
Como verificar: o ollama list mostra a linha qwen2.5:7b-instruct-q4_K_M com ~4.4 GB. Rode ollama run qwen2.5:7b-instruct-q4_K_M e faça uma pergunta — se responder, deu certo.
⌨️ Caminho 2 — GGUF direto do Hugging Face
Objetivo: usar um GGUF que não está no catálogo do Ollama (baixado da aba "Files" de um model card). Três passos:
Baixe o arquivo .gguf
No model card, aba Files, baixe a quant desejada (ex.: ...Q4_K_M.gguf).
Crie um Modelfile
Um arquivo texto que só aponta para o GGUF com a linha FROM.
Registre e rode
ollama create transforma o GGUF num modelo seu, com nome.
LM Studio (sem terminal): na aba de busca, procure o modelo, escolha a quantização (ex.: Q4_K_M) e clique Download. Ele reconhece o GGUF e já abre o chat — zero comando.
Como verificar: ollama list mostra meu-qwen e o chat responde. No LM Studio, o modelo aparece em "My Models" e carrega no chat.
💡 Atalho do Ollama
O Ollama também puxa GGUF do Hugging Face direto, sem Modelfile: ollama run hf.co/usuario/repo-GGUF:Q4_K_M. Troque pelo caminho do repositório e a quant que você viu na aba "Files".
🧮 Combinando modelo × hardware
Quant escolhida, falta a pergunta final: cabe na minha máquina? A regra de bolso da Trilha 2 fecha o ciclo — o tamanho do arquivo precisa caber na memória com folga para o contexto.
Tamanho aproximado por modelo × quantização (e quanta memória ter para rodar bem):
| Modelo | Q4_K_M | Q8_0 | Memória ideal |
|---|---|---|---|
| 7B | ~4.4 GB | ~7.7 GB | 8–12 GB |
| 13B | ~7.9 GB | ~14 GB | 12–16 GB |
| 34B | ~19 GB | ~36 GB | 24–40 GB |
| 70B | ~40 GB | ~75 GB | 48–80 GB |
A diferença entre "cabe" e "não cabe" é a diferença entre rápido e inutilizável. Veja os dois cenários:
✓ Quant cabe na memória
- ✓O modelo inteiro entra na VRAM/RAM
- ✓Respostas saem fluidas, muitos tokens/s
- ✓Sobra espaço para o contexto (KV cache)
- ✓Dá pra rodar 24/7 sem travar a máquina
✗ Estourou a memória
- ✗Parte vai pra CPU/disco (swap) — lentíssimo
- ✗Poucos tokens/s, respostas arrastadas
- ✗Erro de OOM (out of memory) ou trava
- ✗Resposta: baixe uma quant menor ou um modelo menor
💡 Fluxo de decisão
Quanta memória você tem? → escolha o maior modelo cuja Q4_K_M caiba com 2–4 GB de folga. Coube com sobra? Suba a quant (Q5/Q8) antes de subir de modelo — qualidade extra é mais barata que dobrar o tamanho. 8 GB ≈ 7B Q4; 16 GB ≈ 13B Q4 ou 7B Q8; 24 GB+ ≈ 34B Q4.
✅ Verificando qualidade e integridade
Baixou — agora confirme duas coisas: que o arquivo veio inteiro (download não corrompido) e que a quantização não foi longe demais. Dois minutos de teste evitam horas de "por que esse modelo está tão ruim?".
⌨️ Exemplo prático: checksum + prompt-padrão
Objetivo: confirmar integridade do arquivo e fazer um teste de sanidade na resposta.
Como verificar: o SHA256 tem que bater com o da página. A resposta deve vir coerente, em português, com 3 bullets de verdade — sem repetir, travar em loop ou trocar de idioma. Se virar salada, a quant pode estar agressiva demais: suba para Q5_K_M ou Q8.
✓ Quant saudável
- ✓SHA256 confere com a página do HF
- ✓Segue o que você pediu (formato, idioma)
- ✓Texto coerente, sem repetições estranhas
- ✓Respostas parecidas em Q4 e Q5 (perda mínima)
✗ Quantizou demais
- ✗Salada de palavras ou frases sem sentido
- ✗Ignora o pedido / troca de idioma sozinho
- ✗Loop: repete a mesma frase sem parar
- ✗Erra contas/fatos simples que a Q5 acerta
Auto-checagem (opcional): você tem 8 GB de VRAM e quer rodar um modelo 7B com o melhor equilíbrio qualidade × tamanho. Qual quantização é o "ponto doce" para começar?
💡 Dica prática
Guarde um "prompt-padrão" seu (um resumo, uma conta, uma pergunta sobre algo que você conhece) e rode-o sempre que testar um modelo ou quant nova. Comparar a mesma pergunta entre versões é o jeito mais rápido e honesto de sentir a perda de quantização.
📌 Resumo do módulo
Próximo módulo:
3.4 — Parâmetros e qualidade: contexto, temperatura, offload