Gemma 4 localmente com Ollama: instalação, VRAM, perfs

#Por que usar Gemma 4 localmente

Gemma 4 é um dos melhores modelos de pesos abertos do seu porte para o francês. O 12B Q4 cabe confortavelmente em 8 a 12 GB de VRAM, o que abrange uma RTX 3060, uma 4070 ou um Mac da série M de categoria intermediária. O 26B-A4B, um MoE que ativa apenas 4B de parâmetros, aproveita as placas de 24 GB (3090, 4090, 7900 XTX) e os Macs com bastante memória unificada, mantendo a rapidez. Para uso como assistente em francês, RAG e programação de propósito geral, é uma excelente escolha padrão.

Outra razão para rodar o modelo localmente: desde abril de 2026, Gemma 4 é publicado sob a licença Apache 2.0, o que elimina as restrições dos antigos termos de uso Gemma Terms of Use (uso comercial, redistribuição e fine-tuning livres), e Ollama gerencia o pull, a quantização e a inferência sem que seja preciso mexer diretamente em Python, CUDA ou llama.cpp.

#O que muda em comparação com a Gemma 3

Gemma 3 (março de 2025) trouxe multimodalidade e um contexto de 128k. Gemma 4 mantém esses avanços e avança em três eixos: qualidade (grande salto medido nos benchmarks de raciocínio e de código), eficiência (o modelo 12B substitui vantajosamente o modelo 27B do Gemma 3 em muitas tarefas, e o 26B-A4B em MoE roda o equivalente a um grande modelo com a velocidade de um pequeno) e tokenizer (vocabulário mais denso, o que reduz o número de tokens para uma geração equivalente — portanto, mais tokens úteis por segundo).

Tamanhos

Gemma 3: 1B, 4B, 12B, 27B (densos). Gemma 4: E2B (compacto), 12B (denso) e 26B-A4B (MoE, 4B ativos). A linha evolui em eficiência, em vez de aumentar em tamanho bruto.

Multimodal

Visão nativa no 12B e no 26B-A4B (texto + imagens). O E2B continua sendo a variante compacta orientada para texto.

Contexto

128k tokens em toda a linha. As mesmas restrições de memória de antes: o cache KV passa rapidamente a ocupar muita memória.

Tokenizer

SentencePiece, com vocabulário revisado para cobrir melhor o francês, o código e as línguas não latinas. Com um prompt equivalente, o consumo de tokens é cerca de 5 a 15% menor.

Licença

Licença Apache 2.0 desde abril de 2026. Uso comercial, redistribuição e fine-tuning livres, sem cláusula específica de uso aceitável — uma verdadeira mudança em relação aos Gemma Terms of Use do Gemma 3.

#Pré-requisitos

Ollama instalado

Versão recente (≥ 0.5). Consultar os guias de instalação para Windows, macOS ou Linux se você ainda não tiver instalado o Ollama.

Espaço em disco

Prever 4,3 GB para o E2B, 7,6 GB para o 12B Q4 e 19 GB para o 26B-A4B Q4. As variantes Q5 e Q8 do 12B e do 26B têm de 1,3 a 2 vezes esse tamanho.

VRAM ou memória unificada

Mínimo prático: 6 GB para o E2B, 8 a 12 GB para o 12B em Q4, 24 GB para o 26B-A4B em Q4. Abaixo disso, parte do modelo passa a ser executada na CPU e a velocidade despenca.

Drivers de GPU atualizados

CUDA 12.x para NVIDIA, ROCm 6.x para AMD, Metal nativo para Apple Silicon. Ollama detecta o backend sozinho.

#1. Download e execução em um único comando

A tag do Ollama para Gemma 4 segue a convenção habitual: gemma4 (latest aponta para o 12B Q4 por padrão), gemma4:e2b-it-qat, gemma4:12b, gemma4:26b. Para especificar a quantização, acrescenta-se um sufixo: gemma4:12b-instruct-q4_K_M.

ollama run gemma4:12b

Na primeira execução, Ollama baixa o modelo (~7,6 GB para o 12B Q4) e abre diretamente um prompt interativo. Nas execuções seguintes, o lançamento é instantâneo desde que o modelo permaneça na memória cache.

ollama pull gemma4:e2b-it-qat
ollama pull gemma4:12b
ollama pull gemma4:26b

Para verificar o que está carregado na VRAM em tempo real :

ollama ps

A coluna PROCESSOR deve mostrar 100% GPU. Se aparecer 70%/30% GPU/CPU, é porque o modelo não cabe inteiramente na VRAM — passe para uma quantização mais agressiva ou para um modelo menor.

#2. VRAM por tamanho e quantização

Os números abaixo incluem os pesos do modelo mais um KV-cache para uma janela de contexto de 8k tokens (o padrão do Ollama). Para aumentar para 32k ou 128k, considere de 2 a 8 GB adicionais, dependendo do tamanho.

Gemma 4 E2B — QAT int4

≈ 4,5 GB de VRAM. Versão compacta (QAT, ~2B ativos no estilo MatFormer). Roda em qualquer GTX 1660 (6 GB), RTX 3050 (8 GB) ou Mac com 8 GB de memória unificada.

Gemma 4 12B — Q4_K_M

≈ 8 GB de VRAM. Hardware naturalmente indicado: RTX 3060 12 GB, 4070 12 GB, 5070 12 GB, Mac com 16 GB ou mais.

Gemma 4 12B — Q5_K_M

≈ 9,5 GB de VRAM. Cabe em 12 GB com um contexto pequeno; fica mais confortável em 16 GB (4070 Ti Super, 5080).

Gemma 4 12B — Q8_0

≈ 13 GB de VRAM. Reservado para placas com 16 GB ou mais ou máquinas com Apple Silicon e bastante memória.

Gemma 4 26B-A4B — Q4_K_M

≈ 19 GB de VRAM. Ponto ideal: RTX 3090, 4090, 5090, RX 7900 XTX, Mac Studio. MoE: carrega apenas 4B ativos, então é rápido apesar da memória ocupada.

Gemma 4 26B-A4B — Q5_K_M

≈ 23 GB de VRAM. Próximo do limite de uma placa de 24 GB; caso contrário, optar por um Mac com 48 GB ou mais de memória unificada ou por uma configuração com múltiplas GPUs.

Gemma 4 26B-A4B — Q8_0

≈ 30 GB de VRAM. Para as placas com 32 GB+ (RTX 5090) ou os Mac com memória unificada de 48 GB ou mais.

#3. Tokens/segundo: RTX e Apple Silicon

Ordens de grandeza observadas com uma versão recente do Ollama, contexto de 8k, prompt curto e geração de 200 tokens. Os números variam em ±15% de acordo com o conteúdo gerado e a versão do Ollama. Por ser um MoE (4B ativos), o 26B-A4B roda muito mais rápido que um modelo denso de 26B, depois de carregado na memória.

RTX 3060 12 GB

Gemma 4 E2B: ~90 tok/s. Gemma 4 12B Q4: ~28 tok/s. 26B-A4B: excede a VRAM disponível (19 GB), evite.

RTX 4070 12 GB

E2B: ~130 tok/s. 12B Q4: ~46 tok/s. 26B-A4B: excede a VRAM disponível.

RTX 4080 Super 16 GB

12B Q4: ~66 tok/s. 12B Q8: ~40 tok/s. 26B-A4B: não cabe em 16 GB.

RTX 4090 24 GB

12B Q4: ~100 tok/s. 26B-A4B Q4: ~58 tok/s. 26B-A4B Q5: ~50 tok/s.

RTX 5090 32 GB

12B Q4: ~150 tok/s. 26B-A4B Q4: ~88 tok/s. 26B-A4B Q8: ~48 tok/s.

Mac M3 Max 64 GB

12B Q4: ~38 tok/s. 26B-A4B Q4: ~30 tok/s. Boa regularidade graças à memória unificada.

Mac M4 Pro 48 GB

12B Q4: ~34 tok/s. 26B-A4B Q4: ~24 tok/s. O MoE funciona sem problemas e permanece ágil para o seu tamanho.

Mac M4 Max 128 GB

26B-A4B Q4: ~36 tok/s. 26B-A4B Q8: ~20 tok/s. O Mac mais adequado para o 26B no dia a dia.

#4. Primeiro prompt e configurações úteis

Gemma 4 responde bem em francês sem um prompt de sistema específico, mas alguns parâmetros merecem ser ajustados de acordo com o caso de uso.

ollama run gemma4:12b
>>> Explique la différence entre un index B-tree et un index hash en SQL, en 5 lignes.

Para ajustar os parâmetros durante a execução pelo prompt interativo:

/set parameter temperature 0.3
/set parameter num_ctx 16384
/set parameter num_predict 800

temperature

0,7 por padrão. Reduza para 0,2-0,4 para conteúdo factual, código ou RAG. Aumente para 0,9-1,1 para brainstorming.

num_ctx

Tamanho do contexto. 4096 ou 8192 por padrão conforme as versões. Aumente conforme seu uso e a VRAM disponível.

num_predict

Número máximo de tokens gerados. -1 para ilimitado (até o stop). Útil para limitar o comprimento das respostas.

repeat_penalty

1,1 por padrão. Se o Gemma 4 entrar em um ciclo de repetição, aumente para 1,15–1,2. Se as respostas parecerem excessivamente elaboradas, reduza para 1,05.

#5. API e integração a partir do seu código

O Ollama expõe um endpoint compatível com a OpenAI em http://localhost:11434/v1. Qualquer SDK compatível com a API da OpenAI funciona simplesmente configurando a base_url para apontar para esse endereço local.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # valeur ignorée, mais le SDK l'exige
)

resp = client.chat.completions.create(
    model="gemma4:12b",
    messages=[
        {"role": "system", "content": "Tu réponds en français, de manière concise."},
        {"role": "user", "content": "Résume la photosynthèse en 3 lignes."},
    ],
    temperature=0.3,
)
print(resp.choices[0].message.content)

Para a versão multimodal (12B e 26B-A4B), a imagem é enviada em base64 ou por uma URL local na mensagem — o mesmo protocolo do GPT-4o.

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:12b",
  "prompt": "Décris cette image en français.",
  "images": ["'"$(base64 -w0 photo.jpg)"'"],
  "stream": false
}'

#Solução de problemas

"Error: model gemma4 not found"

A tag não existe ainda na sua versão de Ollama, ou é um erro de digitação. Verifique com o comando ollama list os modelos instalados e a documentação da biblioteca Ollama para as tags oficiais.

Modelo parcialmente executado na CPU por falta de espaço na GPU

ollama ps affiche 60% GPU / 40% CPU. Passez à une quantization plus agressive (Q4 → Q3_K_S), réduisez num_ctx, ou descendez d'une taille (12B → E2B).

Velocidade dividida por 3 após algumas horas

O KV-cache se fragmenta com certos drivers. Reinicie o serviço Ollama (sudo systemctl restart ollama no Linux, reiniciar o app no Mac/Windows).

Respostas truncadas após ~400 palavras

num_predict muito baixo. Coloque 2048 ou -1 para ilimitado e aumente num_ctx de acordo.

Francês pouco preciso no E2B

Isso é esperado: o E2B é poderoso para seu tamanho, mas continua sendo uma variante compacta. Para tarefas exigentes em francês, escolha o 12B.

OOM na RTX 4060 8 GB em 12B

O 12B em Q4 mal cabe em 8 GB, sem margem para o contexto. Use gemma4:e2b-it-qat, aceite o offload para a CPU (~3-5 tok/s) ou troque de placa.

#Para se aprofundar

Você tem Gemma 4 rodando. Algumas dicas para avançar conforme o que você deseja fazer:

O que é o Ollama e como ele funciona

Se você está começando a conhecer o Ollama, este guia para iniciantes apresenta os comandos essenciais e o modelo mental completo.

Escolher sua quantização (Q4, Q5, Q8, FP16)

Para entender exatamente o que você sacrifica ao passar do Q8 para o Q4, e quando isso realmente importa.

Open WebUI com Ollama

Para uma interface semelhante à do ChatGPT sobre o Gemma 4: histórico de conversas, RAG integrado, compartilhamento entre vários usuários.