Fabio Luiz

Além da ficha técnica: qual modelo local você entrega

14 min read

Versão original em inglês: Beyond the spec sheet: which local model you ship.

Pegue um modelo pequeno de cada uma das quatro famílias abertas que todo mundo cita - Gemma, Llama, Qwen e DeepSeek - e uma tabela de benchmark vai ordená-los por velocidade e tamanho. Ela não vai te contar as duas coisas que decidem qual você entrega:

  • para que cada família é legalmente licenciada
  • o quão diferente elas se comportam no mesmíssimo prompt

Dois dos quatro modelos abaixo compartilham um corpo e um tamanho. Eles respondem sob licenças diferentes e se comportam como animais diferentes.

A linhagem que o ollama show imprime

Uma família de modelos é uma linhagem: quem treinou os pesos e a arquitetura da qual eles descendem. As quatro que dominam a conversa sobre modelos abertos:

  • Gemma (Google)
  • Llama (Meta)
  • Qwen (Alibaba)
  • DeepSeek (DeepSeek)

A linhagem não é só marca. O ollama show imprime um campo architecture, e ele nomeia a família mecanicamente. Aqui está ele nas quatro builds que rodei, um modelo instruct geral por família, todos quantizados no mesmo Q4_K_M (os campos da ficha técnica são decodificados em Rodando um modelo de programação localmente com Ollama):

ollama show qwen3:8b
  Model
    architecture        qwen3
    parameters          8.2B
    context length      40960
    quantization        Q4_K_M
 
  Capabilities
    completion
    tools
    thinking

Rode isso para cada família e a linha architecture se lê como uma impressão digital da família:

modeloarchitectureparameterscontextcapabilities
gemma3:4bgemma34.3B131072completion, vision
llama3.1:8bllama8.0B131072completion, tools
qwen3:8bqwen38.2B40960completion, tools, thinking
deepseek-r1:8bqwen38.2B131072tools, thinking, completion

Leia as duas últimas linhas de novo. qwen3:8b e deepseek-r1:8b reportam a mesma arquitetura e o mesmo tamanho: qwen3, 8.2B. O modelo pequeno da DeepSeek não é um corpo DeepSeek de jeito nenhum. É um corpo Qwen3 que a DeepSeek fez fine-tuning (os modelos nativos da DeepSeek são mixture-of-experts (MoE) de escala de fronteira, centenas de bilhões de parâmetros, grandes demais para rodar num laptop, então destilar o raciocínio dela sobre um corpo menor é o único jeito de ela entregar algo local). O campo architecture é o primeiro lugar onde a história das “quatro famílias” começa a borrar, e ela borrou já na saída da ficha técnica.

O confronto justo, e por que ele não é justo

Para comparar famílias você quer um modelo por família, mesma categoria de peso, mesma tarefa. A categoria de peso é ~8B, o denominador comum: o único tamanho em que toda família tem algo que você realmente consegue rodar num laptop, pequeno o bastante para carregar em alguns gigabytes a 4 bits e responder em velocidade interativa. Faixas maiores como 30B existem, mas precisam da memória de uma workstation e rodam muito mais devagar, então 8B é o que “local” costuma significar.

Mas fixar o tamanho comum é a parte fácil. Mesmo aí as quatro famílias não oferecem quatro iguais, e só escolher os concorrentes já expõe o quão diferente cada uma trata modelos pequenos. Vários eixos decidem se dois modelos são de fato equivalentes:

  • Parâmetros (o B): o tamanho do modelo em bilhões de pesos. Mais parâmetros costuma significar mais capaz, porém mais pesado de rodar.

  • Denso (dense): todo parâmetro roda para todo token. Custo previsível, mas o modelo inteiro precisa caber na memória.

  • Mixture-of-experts: os parâmetros são divididos em sub-redes “especialistas” e um roteador dispara só alguns por token. Escrito como ativos / total (ex.: 17B ativos / 109B total): você paga compute pela fatia ativa, mas ainda tem que carregar todo peso.

  • Multimodal: aceita mais que texto, aqui imagens além de prompts.

  • Distill (destilação): um modelo “aluno” menor treinado para copiar o comportamento de um modelo maior, muitas vezes sobre o corpo de outra família.

  • Capabilities (capacidades): o que um modelo consegue de fato fazer, a linha Capabilities do ollama show:

    • tools: chamar funções
    • vision: ler imagens
    • thinking: raciocinar antes de responder

    Esse eixo é um portão rígido, não um mimo: se o seu produto chama ferramentas, um modelo sem a capacidade tools está fora, não importa como ele pontua em tamanho ou licença.

  • Instruct versus reasoning: um modelo instruct é ajustado para seguir uma instrução e responder na hora. Um modelo reasoning (cadeia de raciocínio) trabalha o problema em tokens visíveis primeiro, e então responde. Mesmo tamanho, custo e latência bem diferentes.

Com esses eixos claros, aqui está o que cada família entrega em meados de 2026:

  • Qwen3
    • denso: 0.6, 1.7, 4, 8, 14, 32B
    • MoE: 30B-A3B, 235B-A22B
    • existe um 8B real e nativo
  • Gemma 3
    • denso: 1, 4, 12, 27B, multimodal
    • nada de 7-9B: você escolhe o 4B ou salta para o 12B
  • Llama 4
    • tudo MoE: Scout (17B ativos / 109B total), Maverick (17B ativos / 400B total)
    • o menor Llama 4 tem 109B total; nenhuma build densa pequena
    • então um Llama local em 2026 significa a geração anterior, Llama 3.1 8B
  • DeepSeek
    • os modelos nativos são MoE de fronteira: V3 e R1 a 671B total / 37B ativos
    • não entrega nenhum modelo nativo pequeno
    • a opção de tamanho de laptop é um distill: o raciocínio da DeepSeek treinado sobre o corpo de outro, aqui o Qwen3-8B que já flagramos
graph TD
    Q[Qwen: 8B denso nativo] --> RUN[o que cabe num laptop a ~8B]
    G[Gemma: nativo, mas 4B ou 12B, sem 8B] --> RUN
    L[Llama 4: só MoE, menor com 109B] -->|recua uma geração| L31[Llama 3.1 8B]
    L31 --> RUN
    D[DeepSeek: só MoE, sem nativo pequeno] -->|distila sobre outro corpo| DR[deepseek-r1 sobre um corpo Qwen3]
    DR --> RUN

Então o confronto “justo” já é, por si só, um achado: só a Qwen traz um modelo atual e nativo para a briga de 8B. A Gemma traz um irmão menor, a Llama traz sua geração anterior, e a DeepSeek traz um distill vestindo o corpo da Qwen. Os modelos que alinhei:

  • Gemma → gemma3:4b (o modelo pequeno nativo da Gemma)
  • Llama → llama3.1:8b (o Llama local na prática)
  • Qwen → qwen3:8b (nativo, atual)
  • DeepSeek → deepseek-r1:8b (o distill)

Mesmo prompt, quatro respostas

Um prompt, enviado aos quatro, com --verbose para o runtime reportar seu trabalho:

Write a Python function is_prime(n), then use it to say whether 91 is prime. Keep it short.

A armadilha é o 91: parece primo e não é (7 × 13). “Keep it short” é a segunda sonda, uma instrução que cada família obedece em grau diferente.

A coisa toda são quatro pulls e um prompt num único laptop:

ollama pull gemma3:4b
ollama pull llama3.1:8b
ollama pull qwen3:8b
ollama pull deepseek-r1:8b
 
# linhagem + licença, por modelo
ollama show qwen3:8b
ollama show gemma3:4b --license | head
 
# mesmo prompt, quatro famílias
prompt="Write is_prime(n) and say if 91 is prime. Keep it short."
 
for m in gemma3:4b llama3.1:8b qwen3:8b deepseek-r1:8b; do
  ollama run "$m" --verbose "$prompt"
done
 
# o interruptor híbrido
curl -s localhost:11434/api/chat -d '
{
  "model": "qwen3:8b",
  "stream": false,
  "think": false,
  "messages": [
    {
      "role": "user",
      "content": "Write is_prime(n) and say if 91 is prime."
    }
  ]
}'

Todo número abaixo veio desses comandos num único Apple M4 Pro. A sua throughput vai diferir; as personalidades e as licenças, não.

Gemma responde com código e nada mais. Sem preâmbulo, sem explicação, nem sequer as palavras “91 não é primo”:

def is_prime(n):
  """Checks if n is a prime number."""
  if n <= 1:
    return False
  for i in range(2, int(n**0.5) + 1):
    if n % i == 0:
      return False
  return True
 
print(is_prime(91))

Llama embrulha o código em títulos markdown e uma explicação, e afirma a resposta num comentário:

def is_prime(n):
    """Check if n is a prime number."""
    return n > 1 and all(n % i for i in range(2, int(n**0.5) + 1))
 
# Example usage:
print(is_prime(91))  # False

This function uses the all function with a generator expression to check if n has any divisors other than 1 and itself.

Qwen faz algo que os dois primeiros não conseguem: ele pensa em aberto antes de responder. O código final é limpo, mas chega depois de um longo monólogo visível (dobrado em um campo thinking separado), raciocinando por casos de borda e até conferindo à mão que 91 / 7 = 13:

import math
 
def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    max_divisor = int(math.sqrt(n)) + 1
    for i in range(3, max_divisor, 2):
        if n % i == 0:
            return False
    return True
 
print(is_prime(91))  # Output: False

DeepSeek também pensa primeiro, e então responde com um one-liner e, de forma característica, uma linha de LaTeX na sua explicação:

def is_prime(n):
    return n > 1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1))
 
print(is_prime(91))  # Output: False

Checking divisibility from 2 to ( \lfloor\sqrt{91}\rfloor + 1 = 10 ), we find that 91 is divisible by 7, so it’s not prime.

Todos os quatro acertaram a conta. Mas eles não são intercambiáveis. A personalidade aparece no que você não pediu:

  • Gemma levou “keep it short” mais ao pé da letra: só o código, e nunca disse em palavras se 91 é primo.
  • Llama é o assistente ansioso: títulos, prosa, uma nota de eficiência.
  • Qwen e DeepSeek ambos escolheram uma solução no estilo all(...) ou otimizada, mas só depois de gastar tokens pensando, que os modelos instruct nunca gastaram.

O rodapé --verbose transforma “personalidade” em números. Throughput (eval rate, tokens por segundo) é estável por modelo. Custo (eval count, quantos tokens o modelo escolheu gerar) é onde os modelos de reasoning estouram o orçamento:

modelothroughputtokens até a respostatempo totalpensa?
gemma3:4b75 tok/s86~4snão
llama3.1:8b47 tok/s127~6snão
deepseek-r1:8b44 tok/s~400 (faixa 290-530)~10ssim
qwen3:8b43 tok/s~1.500 (faixa 1.100-2.500)~30-50ssim
qwen3:8b (think:false)43 tok/s68~2snão (desligado)

A tabela separa as quatro famílias em “pensa” e “não pensa”, e essa divisão é o maior trade-off de inferência entre elas. Três sabores:

  • Instruct (Gemma, Llama aqui): responde na hora. Sem fase de pensamento, sem capacidade de thinking.
  • Reasoning (DeepSeek-R1): pensa primeiro, sempre. A cadeia de raciocínio é o produto.
  • Híbrido (Qwen3): pensa por padrão, mas você desliga com um único flag, o parâmetro think na API de chat do Ollama.

Algumas coisas para ler dela:

  • Modelos instruct geram uma contagem de tokens previsível entre rodadas repetidas:
    • gemma3:4b ficou em 86 tokens, e é o mais rápido por token (75 tok/s) simplesmente porque é o menor.
    • llama3.1:8b ficou em 127 tokens, a 47 tok/s (os três modelos de 8B se agrupam em 43-48 tok/s).
  • O custo de um modelo de reasoning é uma distribuição, não um número:
    • Quase nenhum daqueles tokens é a resposta, é pensamento que você paga.
    • qwen3:8b no seu modo padrão variou de 1.100 a 2.500 tokens, mais de dez vezes o que a Gemma gastou e dez vezes o tempo de relógio.
    • Vire o qwen3:8b para think:false (última linha) e a mesma resposta cai para 68 tokens, menos do que qualquer um dos modelos instruct gastou (86 da Gemma, 127 do Llama).
    • deepseek-r1:8b geralmente pousou perto de 300-530 tokens, mas uma vez espiralou além de 6.000 nesse mesmo prompt trivial.

Arquitetura por família: o que a linhagem otimiza

Afaste o zoom das builds de 8B para o que cada família está de fato construindo na fronteira, e as personalidades ganham raízes arquiteturais:

famíliaarquitetura de fronteirao que ela otimiza
Gemmadensa, multimodal, quantization-awarepequena, eficiente, imagem + texto, roda em qualquer lugar
Qwendensa e MoE, thinking híbridoescada completa de tamanhos, um botão para custo vs profundidade
Llamatudo mixture-of-experts, contexto muito longoescala de fronteira, implantável via ativação esparsa
DeepSeekMoE com latent attention, reasoning + distillsqualidade de raciocínio, inferência barata em escala

Alguns fios que valem puxar:

  • Denso versus mixture-of-experts.
    • Um modelo denso roda todo peso para todo token.
    • Um modelo MoE agrupa pesos em sub-redes especialistas e um roteador dispara só alguns por token, então um modelo de 400B pode inferir ao custo da sua fatia ativa de ~17B.
    • Llama e DeepSeek foram all-in em MoE no topo, que é exatamente por que não têm um modelo denso pequeno para te entregar: o design delas pressupõe escala.
  • Gemma fica pequena de propósito.
    • Densa, multimodal (note a capacidade vision no gemma3:4b).
    • Distribuída com quantization-aware training, treinada já esperando ser comprimida para 4 bits, então a build pequena mal degrada.
    • Sua aposta inteira é “roda no seu hardware”.
  • Qwen entrega a escada mais larga.
    • Seis tamanhos densos e duas builds MoE, mais o interruptor híbrido de thinking.
    • É a família que te deixa escolher seu ponto exato na curva de tamanho e custo.
  • DeepSeek vende reasoning, depois o distila para baixo.
    • Seus modelos nativos são grandes e reasoning-first, então nenhum cabe num laptop.
    • Seu presente para os laptops é distilar esse raciocínio sobre corpos Qwen e Llama.
    • É por isso que “DeepSeek a 8B” é um Qwen3 por baixo.

Licença: o que você pode de fato entregar

Velocidade e tamanho decidem se um modelo funciona. A licença decide se você tem permissão de entregá-lo. O ollama show imprime ela também:

ollama show deepseek-r1:8b --license | head

Entre os quatro, as licenças não são variações de um tema. São quatro regimes legais diferentes, separados por serem OSI-open (aprovadas pela Open Source Initiative como código aberto genuíno, sem amarras) ou uma concessão condicional com uma política anexada:

modelolicença (do ollama show)o que significa para um produto
qwen3:8bApache 2.0permissiva; uso comercial, modificação, redistribuição, sem teto
deepseek-r1:8bMITpermissiva; entre as mais liberais, uso comercial tranquilo
llama3.1:8bLlama 3.1 Communitycomercial abaixo de 700M de usuários/mês; atribuição “Built with Llama”; política de uso aceitável; não é OSI-open
gemma3:4bGemma Terms of Useuma política de uso proibido que flui para os seus usuários; a Google pode restringir o uso remotamente; não é OSI-open

Duas cláusulas valem ser lidas por inteiro, porque surpreendem as pessoas:

  • A licença da Gemma também vincula qualquer modelo que você distilar dela.
    • Distilação significa treinar um novo modelo “aluno” nas saídas da Gemma. Os termos da Gemma contam isso como fazer um derivado, e detalham as técnicas que cobrem: “distillation methods that use intermediate data representations or methods based on the generation of synthetic data Outputs”.
    • Então até um modelo novo treinado nas respostas da Gemma herda as regras da Gemma.
    • A DeepSeek faz o oposto: distilação é toda a sua estratégia de modelo pequeno, e ela entrega esses distills sob a permissiva licença MIT.
  • A licença de um modelo vem de quem o treinou, não da sua arquitetura.
    • qwen3:8b e deepseek-r1:8b compartilham o mesmo corpo Qwen3, e ainda assim qwen3:8b é Apache 2.0 (Alibaba) e deepseek-r1:8b é MIT (DeepSeek).
    • Mesmos pesos por baixo, fine-tuner diferente, licença diferente.
    • Então linhagem (arquitetura de quem) e licença (termos legais de quem) se movem de forma independente; você tem que checar as duas.

Para quem entrega comercialmente, seja redistribuindo um modelo derivado ou apenas rodando o modelo sem modificação por trás do seu próprio produto, a licença pode superar a throughput:

  • Um modelo Apache-2.0 ou MIT (Qwen, o distill da DeepSeek) é sinal verde.
  • Um modelo Llama ou Gemma é uma concessão condicional, uma política anexada e uma ligação para o advogado dentro dela.

Escolhendo uma família para uma tarefa

Junte os eixos e nenhuma família única vence. Você escolhe o canto que serve para a tarefa:

  • Menor, mais rápido, multimodal, roda em qualquer coisa: Gemma. Concisa, eficiente, enxerga imagens. Aceite os termos restritivos e a política que flui para baixo.
  • O padrão geral seguro que você pode entregar livremente: Qwen3. Nativo no seu tamanho, Apache 2.0, e o único modelo aqui com um interruptor de thinking, então você paga por raciocínio só quando a tarefa merece.
  • Qualidade de raciocínio em problemas difíceis, licenciado de forma permissiva: o distill da DeepSeek. MIT, pensa por padrão, e pensa de forma mais concisa que o próprio padrão da Qwen. Só saiba que você não consegue desligar o thinking.
  • Familiaridade profunda com o tooling e uma escolha conhecida: Llama. Mas em tamanho de laptop você está rodando o Llama 3.1 do ano passado, e a licença te limita a 700M de usuários com atribuição.

Quando você escolhe um modelo local para entregar, mantenha duas coisas à sua frente que nenhum benchmark vai mostrar: o que a licença de fato te permite fazer, e como o modelo se comporta quando você lhe entrega uma tarefa real. Tamanho e velocidade só decidem se ele roda. A licença decide se você pode entregá-lo, e a personalidade decide se você vai querer.

qwen3:8b e deepseek-r1:8b são a prova: idênticos na ficha técnica, mesma arquitetura e mesmo tamanho, e ainda assim separados nos dois eixos que decidem a escolha, licença e comportamento. Escolha pela licença sob a qual você pode entregar e por como o modelo respondeu ao seu próprio prompt, não pela velocidade e tamanho no topo de um benchmark.

See 2 more →