Les dernières mises à jour de Mistral : améliorer les performances des modèles locaux

Dernières actualités de Mistral : Améliorer les performances des modèles locaux

Les modèles de langage locaux sont passés d'un passe-temps d'expérimentation à une véritable discipline d'ingénierie. Peu de noms ont façonné cette évolution aussi clairement que Mistral. Les modèles à poids ouverts de l'entreprise—de la version originale 7B aux architectures sparse Mixtral à mixture d'experts (MoE), en passant par les nouvelles gammes NeMo et Small—ont constamment relevé le niveau de ce que l'on peut exécuter sur une simple station de travail. Ces derniers mois, les annonces officielles de Mistral AI et les articles de l'écosystème sur le blog Hugging Face se sont concentrés sur un thème récurrent : la performance par watt, par dollar et par GPU. Pendant ce temps, le blog Ollama et le blog Meta AI ont documenté la vague plus large de l'open source que Mistral a contribué à accélérer, des modèles de codage agentiques à l'inférence locale efficace.

Cet article est un guide pratique pour obtenir les meilleures performances possibles des derniers modèles locaux de Mistral. Je vais vous guider à travers les exigences, un chemin d'installation propre, et des exemples d'utilisation concrets que vous pouvez exécuter dès aujourd'hui sur un ordinateur portable ou un serveur à GPU unique. En chemin, je vous montrerai comment obtenir plus de tokens par seconde grâce à la quantification, l'attention flash, le décodage spéculatif et les moteurs de service modernes.

Exigences

Avant de taper la moindre commande, vous devez avoir une idée claire de votre matériel. Les modèles Mistral sont distribués en plusieurs tailles, et votre choix de modèle dépendra de la mémoire et de la puissance de calcul disponibles sur votre machine.

Pour une utilisation locale confortable, voici un modèle mental approximatif :

• **Mistral 7B** (7 milliards de paramètres) fonctionne confortablement avec **8 Go de VRAM** une fois quantifié, ou environ 16 Go de RAM dans une configuration CPU uniquement. C'est le point d'entrée classique.
• **Mistral NeMo 12B** est le couteau suisse moderne, développé en collaboration avec NVIDIA. Il offre une grande fenêtre de contexte de 128K et nécessite environ **12 à 16 Go de VRAM** une fois quantifié, ou environ 16 à 24 Go de mémoire unifiée sur Apple Silicon.
• **Mixtral 8x7B** est un modèle MoE avec 47 milliards de paramètres au total, mais il n'active que deux de ses huit experts par token. En pratique, il fonctionne avec **32 à 48 Go de VRAM** sous forme quantifiée. Il semble beaucoup plus rapide que son nombre de paramètres ne le suggère.
• **Mistral Small (24B)** est le dernier et le plus puissant modèle local de Mistral. Une version quantifiée en 4 bits tient dans **16 à 24 Go de VRAM**, ce qui en fait un candidat idéal pour un RTX 4090 ou un Mac Studio. Le modèle non quantifié nécessite environ 50 Go.

Côté logiciel, vous avez besoin d'un système d'exploitation 64 bits récent. Linux est le chemin le plus simple, macOS fonctionne extrêmement bien grâce à Metal et à la mémoire unifiée, et les utilisateurs de Windows devraient exécuter un environnement WSL2 pour la meilleure prise en charge des outils. Python 3.10 ou plus récent est recommandé, et si vous avez un GPU NVIDIA, installez un pilote CUDA récent (12.x est un choix sûr).

Les principaux outils que nous utiliserons sont **Ollama** pour la facilité d'utilisation, **Hugging Face Transformers** pour la recherche et les workflows de fine-tuning, **llama.cpp** pour un contrôle de bas niveau maximal, et **vLLM** pour le service à haut débit.

Installation étape par étape

Je vais installer tous les outils essentiels d'une manière qui garde votre système propre. Commencez par Ollama, puis préparez un environnement virtuel Python, et enfin ajoutez llama.cpp et vLLM comme améliorations optionnelles mais hautement recommandées.

1. Installer Ollama

Ollama est désormais le moyen le plus simple d'exécuter les modèles Mistral. Il regroupe la gestion des modèles, un serveur API compatible OpenAI et une interface de chat en ligne de commande dans un seul binaire.

Installez-le sur Linux ou macOS avec le script d'installation officiel :

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

Le script ajoute Ollama à votre PATH, crée un service `ollama` sur Linux et télécharge la dernière version. Sur macOS, vous pouvez également télécharger l'application native depuis le site web d'Ollama ; l'application inclut automatiquement l'outil en ligne de commande.

Sous Windows, l'application de bureau Ollama fonctionne nativement avec WSL2, donc la commande Linux ci-dessus fonctionne également dans un terminal WSL2.

Vérifiez l'installation :

ollama --version

Si vous voyez un numéro de version, vous êtes prêt. Aucune installation de pilote séparée n'est nécessaire pour Apple Silicon ; Ollama utilise le framework Metal. Sur les GPU NVIDIA, Ollama détectera automatiquement votre environnement CUDA.

2. Configurer un environnement Python pour Hugging Face

De nombreux workflows—en particulier le fine-tuning, l'inférence quantifiée et l'évaluation d'agents—reposent sur l'écosystème Hugging Face. Créez un environnement virtuel pour que les paquets ne polluent pas le Python de votre système :

python -m venv mistral-env
source mistral-env/bin/activate

Sous Windows PowerShell, remplacez la deuxième ligne par `mistral-env\Scripts\activate`.

Installez maintenant les paquets essentiels :

pip install --upgrade transformers accelerate bitsandbytes huggingface_hub

• **Transformers** est la principale bibliothèque d'inférence et de fine-tuning.
• **Accelerate** gère le placement des appareils et la précision mixte.
• **bitsandbytes** permet la quantification en 4 bits et 8 bits sur CUDA.
• **huggingface_hub** vous donne l'interface en ligne de commande pour télécharger des modèles.

3. Compiler llama.cpp à partir des sources (optionnel)

Si vous voulez un contrôle absolu sur la vitesse d'inférence—en particulier sur les machines CPU uniquement ou Apple Silicon—vous devriez compiler llama.cpp à partir des sources. C'est le moteur derrière Ollama, mais l'exécuter directement ouvre des options qu'Ollama n'expose pas.

Commencez par cloner le dépôt :

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

Configurez ensuite la compilation avec CMake. Pour un GPU NVIDIA, utilisez :

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

Pour Apple Silicon, remplacez l'option CUDA par Metal :

cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j

Pour une compilation CPU pure, vous pouvez simplement exécuter `cmake -B build` sans aucun drapeau supplémentaire. La compilation prend quelques minutes et produit des exécutables dans `build/bin/`, y compris `llama-cli` et `llama-server`.

4. Installer vLLM (optionnel, pour le service)

vLLM est un moteur de service à haut débit avec traitement par lots continu. Si vous prévoyez d'exposer un modèle Mistral comme API de production, installez-le :

pip install vllm

vLLM fonctionne mieux sur les GPU NVIDIA avec CUDA. Il prend en charge nativement de nombreuses architectures Mistral, y compris les modèles MoE, et peut servir avec PagedAttention pour réduire considérablement le gaspillage de mémoire.

Exemples d'utilisation

Une fois les outils en place, examinons des modèles d'utilisation concrets. Tous les exemples ici utilisent des modèles Mistral publiquement disponibles.

Discuter avec Mistral 7B dans Ollama

Le test de bout en bout le plus rapide est une session de chat. Téléchargez d'abord le modèle :

ollama pull mistral

Cela télécharge le modèle instruct Mistral 7B quantifié en GGUF, optimisé pour l'inférence locale sur CPU et GPU. Commencez une conversation :

ollama run mistral

Vous verrez une invite dans votre terminal. Tapez une question, par exemple :

>>> Expliquez la mixture d'experts en trois phrases.

Vous devriez voir les tokens défiler en temps réel. Sur un ordinateur portable moderne avec une puce de la série M ou un GPU de milieu de gamme, attendez-vous à des dizaines de tokens par seconde pour ce modèle 7B.

Ollama propose également de nombreuses autres versions des modèles Mistral. Téléchargez et exécutez un modèle plus grand avec :

ollama pull mixtral:8x7b
ollama run mixtral:8x7b

Si vous avez une VRAM limitée, restez avec les versions 7B et NeMo 12B, qui sont plus indulgentes.

Exposer un point de terminaison local compatible OpenAI

Le plus grand avantage pratique d'Ollama est que son serveur est un remplacement direct de l'API OpenAI. Démarrez le serveur dans un terminal :

ollama serve

Envoyez ensuite une requête de complétion de chat depuis un autre terminal avec `curl` :

curl -X POST http://localhost:11434/v1/chat/completions -d '{
  "model": "mistral",
  "messages": [
    {"role": "user", "content": "Quel est le moyen le plus rapide d'exécuter Mistral localement ?"}
  ]
}'

La réponse est un objet JSON standard avec les champs `choices`, `usage` et `model`. Vous pouvez pointer n'importe quel client compatible OpenAI, comme LangChain ou LlamaIndex, vers `http://localhost:11434/v1` et changer le nom du modèle en `mistral`. Cela facilite le basculement entre les modèles locaux et cloud sans réécrire le code de l'application.

Inférence Python avec Transformers

Hugging Face Transformers est l'outil approprié lorsque vous devez intégrer Mistral dans une application Python. Le modèle Mistral 7B Instruct est disponible sous l'identifiant `mistralai/Mistral-7B-Instruct-v0.3`. Voici un script de chat minimal :

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "mistralai/Mistral-7B-Instruct-v0.3"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

messages = [{"role": "user", "content": "Écrivez un haïku sur les LLM locaux."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=128, do_sample=True, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

L'argument `device_map="auto"` place les couches sur le GPU si disponible, en revenant au CPU uniquement sinon. Si vous voulez utiliser Flash Attention, ajoutez `attn_implementation="flash_attention_2"` à l'appel `from_pretrained`. Notez que Flash Attention 2 nécessite un GPU compatible CUDA à partir de l'architecture Ampere.

Exécuter directement des poids GGUF quantifiés

Pour des performances maximales en dehors d'Ollama, vous pouvez télécharger une conversion GGUF officielle et l'exécuter avec llama.cpp. Hugging Face héberge de nombreux checkpoints GGUF. Par exemple, une quantification 4 bits populaire de Mistral 7B Instruct v0.2 est disponible dans l'espace communautaire `TheBloke` :

huggingface-cli download TheBloke/Mistral-7B-Instruct-v0.2-GGUF \
  mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  --local-dir ./mistral-gguf \
  --local-dir-use-symlinks False

Exécutez-le ensuite avec l'interface en ligne de commande llama.cpp. Le drapeau `-ngl` contrôle le nombre de couches déchargées sur le GPU ; définissez-le à un nombre élevé pour tout décharger :

./build/bin/llama-cli \
  -m mistral-gguf/mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  -p "Qu'est-ce qui distingue Mixtral d'un transformer dense ?" \
  -n 256 \
  -ngl 99 \
  -fa

`-fa` active l'attention flash dans llama.cpp, ce qui accélère considérablement la génération de contextes longs. Avec `-ngl 99` et un GPU NVIDIA, presque toutes les couches s'exécutent sur le GPU, et la vitesse dépasse souvent 40 tokens par seconde pour un modèle 7B.

Exécuter NeMo et Codestral localement

Mistral NeMo 12B est une sortie récente importante pour une utilisation locale. Il est disponible sur le Hub Hugging Face sous l'identifiant `mistralai/Mistral-Nemo-Instruct-2407`, et il est également intégré dans Ollama. Pour l'exécuter avec Ollama :

ollama pull mistral-nemo
ollama run mistral-nemo

Ce modèle a une fenêtre de contexte native de 128K et est nettement plus performant en raisonnement et en code que le 7B d'origine. En quantification 4 bits, il utilise environ 8 à 10 Go de RAM ou de VRAM, ce qui en fait un choix idéal pour un GPU grand public.

Pour le travail local axé sur le codage, le modèle Codestral 22B de Mistral est également disponible sur Ollama :

ollama pull codestral
ollama run codestral

Codestral utilise une licence non-Apache pour l'utilisation de complétion de code, alors vérifiez les termes de licence sur le site de Mistral avant de l'utiliser dans vos produits.

Améliorer les performances

L'installation n'est que la moitié de la bataille. Une fois votre modèle en cours d'exécution, vous pouvez généralement doubler son débit avec quelques optimisations ciblées.

La quantification est votre premier levier

La quantification réduit l'empreinte mémoire et augmente la vitesse en sacrifiant une petite quantité de qualité. Les fichiers GGUF aux formats Q4_K_M et Q5_K_M sont le juste milieu pour la plupart des utilisateurs. Sur Ollama, les versions quantifiées sont la norme, vous bénéficiez donc automatiquement de cet avantage. Dans Transformers, vous pouvez obtenir des résultats similaires avec le chargement 4 bits de bitsandbytes :

from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype="float16",
    bnb_4bit_quant_type="nf4",
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
)

Pour un modèle 7B, le chargement 4 bits réduit la mémoire d'environ 15 Go à environ 4 à 5 Go, ce qui fait souvent la différence entre exécuter et ne pas exécuter sur un GPU donné.

Choisissez la bonne longueur de contexte pour votre charge de travail

Les modèles Mistral prennent en charge de longs contextes, mais les contextes plus longs coûtent de la mémoire et du temps de manière quadratique pendant l'attention. Si votre tâche n'a besoin que d'un contexte de 2 000 tokens, ne laissez pas le tokenizer remplir une fenêtre de 32K. Dans Ollama, vous pouvez définir explicitement la longueur du contexte à l'exécution :

ollama run mistral --num-ctx 4096

Au niveau de Transformers, passez `max_new_tokens` et limitez `max_length` dans l'appel `generate`. Des contextes plus courts conduisent à des tokens par seconde nettement plus élevés car la mémoire d'attention est réduite.

Utilisez la mixture d'experts lorsque c'est possible

Mixtral 8x7B et Mixtral 8x22B sont des modèles MoE sparses. Seul un sous-ensemble d'experts est actif par token, donc l'inférence est bien moins coûteuse qu'un modèle dense de 47B, malgré le grand nombre de paramètres. Si vous avez un GPU avec au moins 48 Go de VRAM, exécuter un Mixtral 8x7B quantifié offre une qualité proche de modèles deux fois plus gros en taille effective. Sur les machines plus petites, Mistral NeMo 12B offre un compromis utile : une architecture dense avec un entraînement plus riche et un contexte plus long que le 7B.

Activez l'attention flash

L'attention flash est un algorithme d'attention sensible aux entrées-sorties qui réduit les frais généraux de mémoire et accélère la génération, en particulier pour les séquences longues. Dans Transformers, c'est un changement d'une ligne :

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    attn_implementation="flash_attention_2",
)

Dans llama.cpp, passez `-fa`. Dans vLLM, l'attention flash est activée par défaut sur les GPU pris en charge. L'amélioration est la plus visible lorsque la longueur du contexte dépasse 2 048 tokens.

Utilisez le décodage spéculatif pour le débit

Le décodage spéculatif est une technique où un petit modèle de brouillon génère des tokens candidats, et le grand modèle les vérifie en parallèle. Cela peut considérablement augmenter la vitesse de génération sans nuire à la qualité de sortie. llama.cpp prend en charge cette technique avec un modèle GGUF de brouillon, comme un petit modèle 1B. La syntaxe de la ligne de commande varie selon les versions, alors vérifiez l'aide de votre compilation :

./build/bin/llama-cli --help | grep -i draft

Si votre compilation prend en charge un drapeau `--draft`, pointez-le vers un petit fichier GGUF et définissez `-n` pour une génération longue. L'effet observable est une augmentation notable des tokens par seconde pour le même modèle cible.

Servez avec vLLM pour un débit de production

Pour les requêtes concurrentes, vous avez besoin d'un serveur qui traite les requêtes par lots efficacement. Le traitement par lots continu de vLLM regroupe de nombreuses requêtes en une seule passe avant, ce qui peut augmenter le débit global de plusieurs fois par rapport à une boucle naïve. Lancez un serveur Mistral comme ceci :

python -m vllm.entrypoints.openai.api_server \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --tensor-parallel-size 1 \
  --max-model-len 8192

L'API est compatible OpenAI à `/v1`. Sous charge, vous verrez une bien meilleure utilisation du GPU qu'avec un client à flux unique, car vLLM maintient le GPU occupé avec un lot rotatif de requêtes actives.

Réglez la taille du lot et le nombre de threads

Sur les systèmes CPU uniquement, llama.cpp bénéficie du réglage du nombre de threads. Trop de threads peuvent provoquer une contention. Un bon point de départ est de définir le nombre de threads sur le nombre de cœurs physiques :

./build/bin/llama-cli \
  -m model.gguf \
  -p "Bonjour" \
  -n 64 \
  -t 8 \
  --numa

Le drapeau `--numa` aide sur les postes de travail multi-sockets. Sur Apple Silicon, il est généralement préférable de laisser les threads par défaut car Metal gère la planification pour vous.

Conclusion

Les récentes sorties de Mistral ont rendu l'inférence locale plus pratique que jamais. La combinaison de petits modèles denses comme Mistral 7B et NeMo 12B, de modèles MoE sparses comme Mixtral, et de solides options axées sur le codage comme Codestral signifie qu'il existe un modèle Mistral pour presque tous les budgets et configurations matérielles. Les quatre piliers de la performance sont les mêmes pour tous : utilisez un moteur d'inférence moderne, quantifiez vos poids, gardez les fenêtres de contexte proportionnelles à votre tâche et activez les optimisations d'attention comme l'attention flash et le décodage spéculatif.

Commencez avec Ollama pour une session sans friction, passez à llama.cpp lorsque vous avez besoin d'un contrôle fin, et passez à vLLM lorsque vous voulez un débit de qualité production. La page officielle des actualités de Mistral AI, le blog Hugging Face, le blog Ollama et le blog Meta AI sont tous d'excellents endroits pour suivre la prochaine vague de mises à jour. Alors que l'efficacité des modèles continue de s'améliorer, l'écart entre les API cloud et le matériel local ne fera que se réduire—et avec les étapes de cet article, vous êtes déjà en avance sur la courbe.