Comment Lancer Gemma 4 31B en Local : Unsloth, Ollama, llama.cpp et HuggingFace

Environ 11 min

Comment Lancer Gemma 4 31B en Local : Unsloth, Ollama, llama.cpp et HuggingFace

Google DeepMind a sorti Gemma 4 debut 2026, et la variante 31B instruction-tuned tombe pile ou il faut : assez grosse pour rivaliser avec les modeles proprietaires sur les benchmarks de raisonnement, assez legere pour tourner sur une carte graphique grand public. Elle atteint 85.2% sur MMLU Pro et 89.2% sur AIME 2026 sans outils, ce qui la met dans la meme categorie que des modeles deux fois plus gros.

Le probleme, c'est toujours "comment on fait tourner ca ?" Un modele de 30.7B parametres en pleine precision demande environ 62GB de VRAM. Personne n'a ca sous la main sur une seule carte. Mais avec la bonne quantification et les bons outils, vous pouvez le faire tourner sur une RTX 4090 24GB, ou meme decharger partiellement sur le CPU avec une carte 16GB. Nous recommandons LightNode comme fournisseur VPS si vous voulez des instances GPU sans engagement.

Ce guide couvre quatre methodes, avec Unsloth comme recommandation principale pour la plupart des gens.

Sommaire

Apercu de la Famille Gemma 4
Configuration Materielle Requise
Methode 1 : Unsloth Studio (Recommande)
Methode 2 : Ollama
Methode 3 : llama.cpp
Methode 4 : HuggingFace Transformers
Comprendre les Formats de Quantification GGUF
Astuces de Performance
Resolution des Problemes
Quelle Methode Choisir ?

Apercu de la Famille Gemma 4

Gemma 4 vient en quatre tailles. Choisir la bonne compte parce que le saut de matos entre elles est consequent.

Variante	Params Totaux	Params Actifs	Contexte	Modalites	Meilleur Pour
E2B	5.1B	2.3B effectifs	128K	Texte, Image, Audio	Telephones, Raspberry Pi
E4B	8B	4.5B effectifs	128K	Texte, Image, Audio	Portables, CPU uniquement
26B A4B (MoE)	25.2B	3.8B actifs	256K	Texte, Image	Inference rapide, moins de VRAM
31B (Dense)	30.7B	30.7B	256K	Texte, Image	Qualite maximale

Le 26B A4B, c'est le malin : 25.2B parametres totaux, mais seulement 3.8B actifs pendant l'inference grace a une architecture Mixture-of-Experts (8 experts actifs sur 128, plus 1 partage). Il tourne presque aussi vite qu'un modele 4B tout en offrant une qualite proche du 31B complet. Si votre GPU a 12-16GB de VRAM, le 26B A4B en quantification Q4 est probablement votre meilleur choix.

Le 31B Dense est le sujet de ce guide. C'est le modele complet avec tous les parametres actifs a chaque passe. Meilleure qualite, requirements matos les plus eleves.

Les quatre variantes supportent le mode de reflexion configurable (raisonnement chain-of-thought), les prompts systeme natifs, le function calling et plus de 140 langues.

Configuration Materielle Requise

Avant de choisir une methode, regardez avec quel matos vous travaillez.

Pour Gemma 4 31B-it

Quantification	VRAM Necessaire	Perte de Qualite	Matos Typique
FP16 (pleine precision)	~62 GB	Aucune	A100, plusieurs GPUs
Q8_0 (8-bit)	~32 GB	Negligeable	RTX 4090 (24GB) + decharge CPU
Q5_K_M (5-bit)	~22 GB	Minime	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 GB	Faible	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 GB	Sensible	RTX 4070, decharge partielle

Pour Gemma 4 26B A4B (MoE)

Quantification	VRAM Necessaire	Perte de Qualite	Matos Typique
Q5_K_M	~14 GB	Minime	RTX 4070 Ti
Q4_K_M	~10 GB	Faible	RTX 4070, RTX 3080
Q3_K_M	~8 GB	Sensible	RTX 4060 Ti 8GB

Si vous etes en CPU uniquement, les variantes E4B ou E2B tournent sans probleme. Le 31B sur CPU est techniquement possible mais douloureusement lent (comptez 1-3 tokens/seconde sur un CPU moderne).

Besoin en RAM : Ajoutez 8-16GB de RAM systeme en plus de la VRAM pour l'overhead du runtime, plus si vous dechargez des couches sur le CPU.

Methode 1 : Unsloth Studio (Recommande)

Unsloth est la facon la plus simple de lancer Gemma 4 en local. C'est une interface web qui gere le telechargement du modele, la selection de quantification et l'inference en un seul package. Fonctionne sur Windows, Linux, macOS et WSL.

Pourquoi Unsloth

Recherche et telechargement de modeles en un clic depuis HuggingFace
Choisit automatiquement la bonne quantification GGUF pour votre matos
Interface de chat integree avec support images, PDFs et documents
Tool calling et recherche web integres
Sandbox d'execution de code
Pas besoin de trifouiller en ligne de commande

Installation

macOS, Linux, WSL :

curl -fsSL https://unsloth.ai/install.sh | sh

Windows (PowerShell) :

irm https://unsloth.ai/install.ps1 | iex

Docker :

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 8000:8000 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Lancement

unsloth studio -H 0.0.0.0 -p 8888

Ouvrez http://localhost:8888 dans votre navigateur. Vous verrez l'interface Unsloth Studio.

Lancer Gemma 4 31B

Cherchez le modele : Dans la barre de recherche, tapez gemma-4-31B
Choisissez une quantification : Unsloth heberge des fichiers GGUF pre-quantifies. Pour un GPU 24GB, selectionnez Q4_K_M ou Q5_K_M. Pour 16GB, prenez Q3_K_M
Telechargez : Cliquez sur download. La variante Q4_K_M fait environ 18GB
Commencez a discuter : Une fois telecharge, le modele se charge automatiquement dans l'interface de chat

Unsloth propose ces variantes GGUF pour Gemma 4 31B-it :

Fichier	Taille	Quantification
`gemma-4-31B-it-Q3_K_M.gguf`	~14 GB	3-bit (equilibre)
`gemma-4-31B-it-Q4_K_M.gguf`	~18 GB	4-bit (recommande)
`gemma-4-31B-it-Q5_K_M.gguf`	~22 GB	5-bit (haute qualite)
`gemma-4-31B-it-Q6_K.gguf`	~26 GB	6-bit (quasi sans perte)
`gemma-4-31B-it-Q8_0.gguf`	~32 GB	8-bit (pratiquement sans perte)

Le depot HuggingFace est sur unsloth/gemma-4-31B-it-GGUF.

Utiliser l'Interface de Chat

Le chat d'Unsloth Studio supporte :

Conversations texte avec toggle du mode de reflexion
Upload d'images : Glissez-deposez des images pour du question-reponse visuel
Upload PDF/DOCX : Extrayez et discutez du contenu de documents
Execution de code : Le modele peut ecrire et tester du code dans un sandbox
Prompts systeme personnalises : Definissez le comportement et la persona

Pour activer le mode de reflexion de Gemma 4, activez l'option "Thinking" dans les parametres du chat. Ca active le raisonnement chain-of-thought, ou le modele travaille les problemes etape par etape avant de donner sa reponse finale.

Fine-Tuning avec Unsloth

Si vous voulez aller au-dela de l'inference, Unsloth gere aussi l'entrainement :

Fine-tuning LoRA : Entrainz des adaptateurs avec jusqu'a 70% de VRAM en moins
Apprentissage par renforcement GRPO : La bibliotheque RL la plus efficace disponible
Data Recipes : Creez automatiquement des datasets d'entrainement a partir de PDFs, CSVs, DOCX
Support multi-GPU : Disponible maintenant avec des ameliorations a venir

Pour le fine-tuning de Gemma 4 31B, vous aurez besoin d'au moins un GPU 24GB avec QLoRA (entrainement quantifie en 4-bit).

Mettre a jour Unsloth

Relancez la meme commande d'installation :

# macOS/Linux/WSL
curl -fsSL https://unsloth.ai/install.sh | sh

# Windows
irm https://unsloth.ai/install.ps1 | iex

Methode 2 : Ollama

Ollama est la facon la plus rapide de demarrer si vous preferez la ligne de commande. Il gere les telechargements de modeles, la detection GPU et le serving automatiquement.

Installation

# macOS
brew install ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# Telechargez depuis https://ollama.com/download

Lancer Gemma 4

# Telechargez et lancez le modele 31B
ollama run gemma4:31b-it

# Ou la variante MoE plus petite pour moins de VRAM
ollama run gemma4:26b-a4b-it

# Ou les modeles dense plus petits
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama quantifie automatiquement en Q4_K_M par defaut. Si vous voulez une autre quantification :

# Lancez avec une quantification specifique
ollama run gemma4:31b-it-q5_K_M

Utiliser l'API

Ollama expose une API locale sur le port 11434 :

import requests

response = requests.post('http://localhost:11434/api/chat', json={
    "model": "gemma4:31b-it",
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    "stream": False
})

print(response.json()['message']['content'])

Avantages et Inconvenients d'Ollama

Avantages : Zero configuration, detection automatique du GPU, CLI propre, serveur API inclus, gestion simple des modeles.

Inconvenients : Moins d'options de quantification que llama.cpp, pas de support image integre pour tous les modeles (verifiez la compatibilite actuelle), moins de controle sur les parametres d'inference.

Methode 3 : llama.cpp

Pour un controle maximum sur la quantification, l'utilisation memoire et les parametres d'inference, llama.cpp est la solution. C'est ce qui fait tourner Ollama et Unsloth sous le capot pour l'inference GGUF.

Compilation depuis les Sources

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Avec support CUDA (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Avec support Metal (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# CPU uniquement
cmake -B build
cmake --build build --config Release -j$(nproc)

Telecharger le Modele GGUF

Recuperez le modele quantifie depuis le depot Unsloth sur HuggingFace :

# Installez huggingface-cli
pip install huggingface-hub

# Telechargez Q4_K_M (recommande pour GPUs 24GB)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# Ou Q5_K_M pour meilleure qualite
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Lancer le Modele

# Chat basique
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64 \
  -p "You are a helpful assistant.\nUser: Explain quantum computing in simple terms.\nAssistant:"

Flags importants :

-ngl 99 : Decharge toutes les couches sur le GPU. Reduisez ce nombre si vous n'avez pas assez de VRAM (ex. : -ngl 40 decharge environ deux tiers des couches)
-c 8192 : Longueur du contexte en tokens. Augmentez jusqu'a 256K pour les longs documents, mais plus de contexte utilise plus de VRAM
--temp 1.0 : Google recommande temperature=1.0 pour Gemma 4
--top-p 0.95 et --top-k 64 : Parametres de sampling recommandes

Demarrer un Serveur

./build/bin/llama-server \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Puis accedez a l'interface web sur http://localhost:8080 ou appelez l'API compatible OpenAI :

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="unused")

response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a Rust function to reverse a linked list."}
    ]
)

print(response.choices[0].message.content)

Strategie de Decharge GPU

Si votre GPU n'a pas assez de VRAM pour le modele complet, vous pouvez repartir les couches entre GPU et CPU :

# Pour un GPU 16GB avec le modele Q4 (~18GB total)
# Dechargez environ 40 couches sur le GPU, le reste sur le CPU
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Ca tourne plus lentement que la decharge complete sur GPU mais ca rentre sur des cartes plus petites. Comptez environ 5-15 tokens/seconde selon votre CPU et le nombre de couches dechargees.

Methode 4 : HuggingFace Transformers

Si vous construisez une application et avez besoin de controle programmatique, HuggingFace Transformers vous donne un acces direct au modele en pleine precision ou avec une quantification personnalisee.

Installation

pip install -U transformers torch accelerate

Pour le support d'images :

pip install -U transformers torch torchvision accelerate

Lancer en Pleine Precision (62GB+ VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."},
]

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False
)

inputs = processor(text=text, return_tensors="pt").to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Lancer avec Quantification 4-bit (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

MODEL_ID = "google/gemma-4-31B-it"

# Config quantification 4-bit
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quantization_config,
    device_map="auto"
)

Traitement d'Images

Le modele 31B supporte les entrees texte et image :

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/photo.jpg"},
            {"type": "text", "text": "Describe what you see in this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Activer le Mode de Reflexion

Gemma 4 supporte le raisonnement chain-of-thought. Activez-le avec enable_thinking=True :

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Active le mode raisonnement
)

Quand la reflexion est activee, le modele produit son raisonnement interne suivi de la reponse finale. Utilisez processor.parse_response(response) pour separer la reflexion de la reponse.

Comprendre les Formats de Quantification GGUF

Si vous telechargez des fichiers GGUF, vous allez voir pas mal de suffixes. Voici ce qu'ils signifient en pratique.

Format	Bits	Taille (31B)	Quand Utiliser
Q8_0	8-bit	~32 GB	Meilleure qualite, necessite 32GB+ VRAM
Q6_K	6-bit	~26 GB	Quasi sans perte, 24GB+ VRAM
Q5_K_M	5-bit	~22 GB	Point d'equilibre qualite/taille
Q4_K_M	4-bit	~18 GB	Meilleur equilibre, tient sur GPU 24GB
Q3_K_M	3-bit	~14 GB	GPU plus petit, quelque perte de qualite
Q2_K	2-bit	~10 GB	Mesures desesperees, degradation notable

Ma recommandation : Q4_K_M pour les GPUs 24GB, Q5_K_M si vous pouvez vous permettre les 4GB supplementaires. La difference de qualite entre Q4_K_M et Q5_K_M est mesurable sur les benchmarks mais difficile a remarquer en utilisation courante. En dessous de Q3_K_M, ca n'en vaut pas la peine sauf si vous n'avez pas d'autre choix.

Le suffixe _K_M signifie "K-quantization, medium". Il existe aussi des variantes _K_S (small, plus de compression) et _K_L (large, moins de compression). _K_M est la recommandation par defaut.

Astuces de Performance

Gestion de la Longueur du Contexte

Gemma 4 31B supporte jusqu'a 256K tokens de contexte, mais chaque token dans le contexte coute de la VRAM. Quelques reperes pratiques :

4K tokens : Confortable sur tout GPU qui fait tourner le modele
8K tokens : Standard pour la plupart des conversations, toujours confortable
32K tokens : Necessite environ 4-6GB de VRAM supplementaire selon la quantification
128K+ tokens : Requiere de la VRAM substantielle ou de la decharge agressive

Commencez avec -c 8192 et augmentez uniquement quand vous en avez besoin.

Parametres de Sampling

Google recommande ces reglages pour Gemma 4 :

temperature = 1.0
top_p = 0.95
top_k = 64

Ces valeurs different de ce que la plupart des modeles utilisent. N'utilisez pas temperature=0.7 avec Gemma 4 ; il est entraine pour temperature=1.0 et produit de meilleurs resultats a ce reglage.

Flash Attention

Si vous utilisez HuggingFace Transformers, activez Flash Attention pour une inference plus rapide et une consommation memoire reduite :

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

Necessite pip install flash-attn et un GPU compatible (la plupart des RTX NVIDIA fonctionnent).

Configuration Multi-GPU

Si vous avez plusieurs GPUs, device_map="auto" dans Transformers gere la repartition automatiquement. Pour llama.cpp :

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # Repartit equitablement entre 2 GPUs
  -c 8192

Resolution des Problemes

Out of Memory (CUDA OOM)

Le probleme le plus courant. Solutions par ordre de desespoir :

Utilisez une quantification plus petite : Passez de Q5 a Q4, ou Q4 a Q3
Reduisez la longueur du contexte : Baissez -c de 8192 a 4096 ou 2048
Dechargez sur le CPU : Reduisez -ngl pour decharger quelques couches
Utilisez la variante 26B A4B MoE : Meme niveau de qualite, une fraction de la VRAM
Utilisez la variante E4B : Tourne sur n'importe quoi

Inference Lente sur CPU

Si vous tournez sur CPU, comptez 1-3 tokens/seconde pour le modele 31B. Options :

Passez au modele E4B ou E2B (10-20 tok/s sur CPU)
Utilisez une instance cloud avec GPU (LightNode propose des VPS avec GPU)
Compilez llama.cpp avec les jeux d'instructions de votre CPU actives (AVX2, AVX-512)

Echecs de Telechargement du Modele

Le fichier Q4_K_M fait environ 18GB. Si le telechargement plante en boucle :

# Utilisez huggingface-cli avec support de reprise
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models \
  --local-dir-use-symlinks False

Ou utilisez un gestionnaire de telechargement qui supporte la reprise. Le CDN HuggingFace peut etre capricieux pour les gros fichiers.

Erreurs "Model not supported"

Assurez-vous d'utiliser la derniere version de vos outils. Gemma 4 est recent et les anciennes versions de llama.cpp, Ollama et Transformers ne le supportent pas :

# Mettez a jour llama.cpp
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Mettez a jour Ollama
ollama pull gemma4:31b-it  # Ca met a jour automatiquement si necessaire

# Mettez a jour Transformers
pip install -U transformers

Quelle Methode Choisir ?

Scenario	Meilleure Methode
Vous voulez une GUI, pas envie de toucher au terminal	Unsloth Studio
Vous voulez le setup le plus rapide, la CLI ca va	Ollama
Vous avez besoin du controle maximum sur l'inference	llama.cpp
Vous construisez une application	HuggingFace Transformers
Vous avez une VRAM limitee (8-16GB)	Unsloth ou Ollama avec Q3/Q4
Vous avez 24GB+ VRAM	N'importe quelle methode, utilisez Q4_K_M ou Q5_K_M
Vous avez besoin de comprehension d'images	Unsloth Studio ou HuggingFace Transformers
Vous voulez faire du fine-tuning	Unsloth (entrainement LoRA/GRPO integre)

Pour la plupart des gens qui debutent, Unsloth Studio est le chemin de moindre resistance. Installez-le, cherchez Gemma 4, choisissez une quantification qui rentre sur votre GPU et commencez a discuter. Tout le processus prend environ 15 minutes entre l'installation et la premiere conversation.

Si vous etes a l'aise avec le terminal et voulez juste lancer le modele, Ollama vous y amene en deux commandes. Et si vous avez besoin d'un acces programmatique ou construisez quelque chose au-dessus du modele, HuggingFace Transformers avec quantification 4-bit vous donne l'API Python complete.

Pour Conclure

Faire tourner Gemma 4 31B en local est devenu remarquablement pratique. Il y a un an, un modele 30B a ce niveau de qualite aurait ete un projet de recherche. Maintenant c'est un processus de 15 minutes avec Unsloth ou Ollama, et ca tourne sur du matos grand public que vous pouvez acheter aujourd'hui.

Le modele en soi tient la comparaison avec les alternatives proprietaires en raisonnement, code et taches multimodales. 256K de contexte, mode de reflexion integre, comprehension d'images et function calling le rendent veritablement utile pour du vrai travail, pas seulement de l'experimentation.

Pour heberger le modele sur un GPU distant, LightNode propose des instances VPS avec GPU facturees a l'heure, donc vous pouvez en lancer une quand vous en avez besoin et l'eteindre quand vous n'en avez plus.

La carte du modele Gemma 4 sur HuggingFace contient tous les details techniques, et le depot GGUF d'Unsloth a toutes les variantes quantifiees pretes a telecharger.