Comment Exécuter Qwen3 Localement - Un Guide Pratique pour les Passionnés d'IA

Environ 11 min

Comment Exécuter Qwen3 Localement - Un Guide Pratique pour les Passionnés d'IA

Le mois dernier, lorsque j'ai entendu parler pour la première fois de la sortie des modèles Qwen3 d'Alibaba, j'ai immédiatement voulu les tester. Après avoir parcouru les résultats impressionnants des benchmarks et les capacités, je me suis posé la même question que beaucoup d'entre nous : « Dois-je simplement utiliser l'API cloud, ou essayer de faire tourner ce modèle localement ? »

Les API cloud sont pratiques, mais entre les préoccupations liées à la confidentialité, les coûts d'utilisation, et le simple défi technique, j'ai décidé de me lancer dans l'aventure d'exécuter Qwen3 sur mon propre matériel. Après plusieurs semaines d'expérimentations, d'innombrables ajustements de configuration, et quelques moments de panique provoqués par le ventilateur du GPU, j'ai compilé ce guide complet pour partager ce que j'ai appris.

Que vous cherchiez à préserver la confidentialité des données, réduire les coûts d'API, personnaliser vos modèles, ou simplement ressentir la satisfaction de faire tourner une IA de pointe sur votre propre machine, ce guide est fait pour vous.

Qu'est-ce que Qwen3 exactement ?

Avant de plonger dans le processus d'installation, comprenons ce avec quoi nous travaillons. Qwen3 (prononcé « chwen ») représente la troisième génération de grands modèles de langage de l'équipe Qwen, sortie en avril 2025. Il est disponible en plusieurs tailles, allant de modèles légers de 0,6 milliard de paramètres à des monstres massifs de 235 milliards de paramètres.

Ce qui rend Qwen3 particulièrement intéressant, c'est son approche d'architecture double :

Modèles Denses : Ils vont de 0,6B à 32B paramètres, avec tous les paramètres actifs lors de l'inférence :

Qwen3-0.6B, 1.7B, 4B (fenêtre de contexte 32K)
Qwen3-8B, 14B, 32B (fenêtre de contexte 128K)

Modèles Mixture-of-Experts (MoE) : Ils utilisent une architecture sparse pour une efficacité computationnelle accrue :

Qwen3-30B-A3B : 30 milliards de paramètres au total mais seulement environ 3 milliards activés lors de l'inférence
Qwen3-235B-A22B : Un colosse avec 235 milliards de paramètres, activant environ 22 milliards lors de l'inférence

Le « A » dans les noms des modèles MoE signifie « Active » (paramètres actifs). C’est une approche astucieuse – imaginez ne pas embaucher une seule personne qui sait tout (coûteux !), mais plutôt avoir une équipe de spécialistes et ne consulter que les plus pertinents pour chaque tâche. Cela rend ces modèles bien plus efficaces que ce que leur nombre total de paramètres pourrait laisser penser.

Une des caractéristiques remarquables de Qwen3 est sa capacité de pensée hybride – il peut effectuer un raisonnement étape par étape en interne (mode réflexion) ou fournir des réponses directes (mode non-réflexif), offrant un bon équilibre entre raisonnement approfondi et rapidité.

Pourquoi exécuter Qwen3 localement ?

Vous vous demandez peut-être pourquoi vouloir faire tourner ces modèles localement alors que des API cloud existent. Voici quelques raisons convaincantes qui m'ont motivé :

Confidentialité des données : Tout reste sur votre machine – aucune donnée ne quitte votre système.
Contrôle des coûts : Pas de factures surprises ni de quotas de tokens – juste le coût initial du matériel et un peu d'électricité.
Fonctionnement hors ligne : Pas de dépendance à Internet après le téléchargement initial du modèle.
Personnalisation : Liberté de fine-tuner les modèles sur vos propres données.
Expérience d'apprentissage : Rien ne vaut la satisfaction de faire fonctionner un système d'IA avancé sur votre propre matériel.
Latence réduite : Élimination des allers-retours réseau pour des réponses plus rapides.

J'ai trouvé l'aspect confidentialité particulièrement précieux. Pouvoir explorer des analyses de données sensibles sans craindre que mes informations soient envoyées à des serveurs externes a été libérateur.

Exigences matérielles – Ce dont vous aurez besoin

Soyons réalistes – faire tourner ces modèles localement n’est pas une promenade de santé, surtout pour les variantes plus grandes. Vos besoins matériels dépendront beaucoup du modèle que vous choisirez.

Voici un aperçu des besoins selon les modèles :

Exigences en RAM

Petits modèles (0.6B, 1.7B) : Au moins 8 Go de RAM, 16 Go recommandés
Modèles moyens (4B, 8B) : Minimum 16 Go, 32 Go recommandés
Grands modèles (14B, 32B) : Minimum 32 Go, 64 Go préférés
Modèles MoE (30B-A3B, 235B-A22B) : 64 Go+ de RAM, surtout pour la variante 235B

Exigences GPU/VRAM

Ici, ça devient sérieux. La mémoire GPU (VRAM) est généralement le facteur limitant :

Qwen3-0.6B : Peut tourner sur des GPU avec 2 Go+ de VRAM (même un vieux GTX 1060)
Qwen3-1.7B : 4 Go+ VRAM (GTX 1070 ou mieux)
Qwen3-4B : 8 Go+ VRAM (RTX 3060 ou mieux)
Qwen3-8B : 16 Go+ VRAM (RTX 3090, 4080, ou A4000)
Qwen3-14B : 24 Go+ VRAM (RTX 4090 ou A5000)
Qwen3-32B : 40 Go+ VRAM (A100 ou plusieurs GPU grand public)
Qwen3-30B-A3B : Malgré le nombre réduit de paramètres actifs, nécessite toujours 24 Go+ VRAM
Qwen3-235B-A22B : Plusieurs GPU haut de gamme (ex. 2+ A100 80GB ou 4+ A6000)

La bonne nouvelle ? La quantification peut aider à réduire drastiquement ces besoins. Par exemple, avec une quantification 4 bits (plus d’infos plus loin), vous pourriez faire tourner Qwen3-8B sur un GPU de 6 Go, avec quelques compromis sur la performance.

Pour vous donner un exemple concret, j’ai d’abord essayé de faire tourner Qwen3-14B sur mon RTX 3080 (10 Go VRAM) et j’ai vite rencontré l’erreur redoutée « CUDA out of memory ». Après avoir appliqué la quantification 4 bits, ça a fonctionné, mais les réponses étaient nettement plus lentes. J’ai ensuite fait évoluer vers un RTX 4090 (24 Go VRAM), qui gère parfaitement le modèle 14B avec une quantification 8 bits.

Option CPU uniquement ?

Oui, techniquement vous pouvez faire tourner les petits modèles Qwen3 (0.6B, peut-être 1.7B) uniquement sur CPU, mais… ne vous attendez pas à des miracles. Quand j’ai essayé Qwen3-0.6B sur mon Core i7 sans accélération GPU, il fallait près de 45 secondes pour générer un simple paragraphe. Pas vraiment en temps réel !

Exigences de stockage

N’oubliez pas l’espace disque ! Vous aurez besoin de :

Petits modèles : 2-5 Go par modèle
Modèles moyens : 8-16 Go par modèle
Grands modèles : 30-60 Go par modèle
Modèles MoE : 60-120 Go ou plus

Je recommande un SSD plutôt qu’un disque dur mécanique pour des temps de chargement beaucoup plus rapides. Mes premières tentatives sur un vieux disque mécanique m’ont fait attendre près de 10 minutes pour charger Qwen3-8B !

Prérequis logiciels

Avant d’attaquer l’installation, assurez-vous d’avoir :

Python 3.10+ : Les versions récentes fonctionnent mieux avec les bibliothèques ML modernes
CUDA Toolkit : Version 11.8+ si vous utilisez des GPU NVIDIA
OS compatible : Linux préféré (Ubuntu 22.04+ fonctionne très bien), Windows aussi supporté
Git : Pour télécharger les dépôts
Outil d’environnement virtuel : Conda ou venv pour gérer les dépendances

Méthode 1 : Exécuter Qwen3 avec Ollama (La voie simple)

Après avoir essayé plusieurs approches, j’ai trouvé Ollama comme la méthode la plus accessible pour débuter avec Qwen3 localement. Il masque beaucoup de complexité et offre une belle interface CLI.

Étape 1 : Installer Ollama

Commencez par télécharger et installer Ollama depuis leur site officiel ou utilisez le terminal :

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

Pour les utilisateurs Windows, téléchargez l’installateur depuis leur site.

Étape 2 : Lancer un modèle Qwen3

La façon la plus simple de commencer est de lancer :

ollama run qwen3:4b

Cette commande fait plusieurs choses :

Télécharge le modèle s’il n’est pas déjà présent
Le charge en mémoire
Démarre une session de chat interactive

Vous pouvez remplacer 4b par n’importe quelle autre variante supportée : 0.6b, 1.7b, 8b, 14b, 32b, ou 30b-a3b.

Ma première exécution a pris environ 15 minutes pour télécharger le modèle, soyez patient ! La bonne nouvelle est que les exécutions suivantes seront beaucoup plus rapides car le modèle est mis en cache.

Étape 3 : Discuter et expérimenter

Une fois lancé, vous pouvez discuter directement avec le modèle dans le terminal. Voici un exemple de conversation que j’ai eue :

> Parle-moi de l’architecture mixture-of-experts dans les LLM.

Mixture-of-Experts (MoE) est une approche architecturale utilisée dans les grands modèles de langage (LLM) qui améliore l’efficacité en activant sélectivement seulement certaines parties du réseau pour chaque entrée.

Dans les modèles transformeurs « denses » traditionnels, tous les paramètres sont utilisés pour chaque token traité. Cela devient coûteux en calcul à mesure que les modèles grandissent. Les modèles MoE résolvent cela en incorporant des sous-réseaux spécialisés appelés « experts », avec un mécanisme de routage qui détermine quels experts activer pour des entrées spécifiques.

Par exemple, dans les modèles MoE de Qwen3 (comme Qwen3-30B-A3B et Qwen3-235B-A22B), chaque couche MoE contient 128 réseaux feed-forward experts, mais seulement 8 sont activés par token. Ce schéma d’activation sparse signifie que même si le nombre total de paramètres est de 235 milliards, seulement environ 22 milliards sont utilisés lors de l’inférence pour chaque token.

Cette approche offre plusieurs avantages :
1. Efficacité computationnelle – seule une fraction des paramètres est calculée lors de l’inférence
2. Évolutivité de la capacité – le modèle peut avoir une énorme capacité totale tout en maintenant des coûts de calcul raisonnables
3. Spécialisation – différents experts peuvent se concentrer sur différents types de connaissances ou tâches

Les composants clés d’une couche MoE incluent :
- Réseaux experts : réseaux feed-forward spécialisés
- Routeur : mécanisme qui décide quels experts doivent traiter chaque token
- Fonction de gating : détermine comment pondérer et combiner les sorties des experts sélectionnés

Cette architecture a permis le développement de modèles de plus en plus grands sans augmentation proportionnelle des besoins en calcul.

Pas mal, non ? La réponse a été générée en environ 15 secondes sur mon RTX 4090.

Étape 4 : Utiliser l’API (optionnel)

Ollama démarre aussi un serveur local (généralement à http://localhost:11434), qui suit un format d’API compatible OpenAI. Cela signifie que vous pouvez interagir avec lui de manière programmatique via curl ou des clients Python.

Voici un exemple rapide en Python :

import requests

response = requests.post('http://localhost:11434/api/generate', 
                       json={
                           'model': 'qwen3:4b',
                           'prompt': 'Écris un court poème sur les réseaux neuronaux.',
                           'stream': False
                       })
print(response.json()['response'])

Cette fonctionnalité facilite la création d’applications basées sur votre modèle Qwen3 local.

Méthode 2 : Exécuter Qwen3 avec vLLM (La voie performance)

Si vous cherchez plus de performance, notamment pour servir des modèles dans un environnement proche de la production, vLLM est la solution. Il est optimisé pour le débit et la latence, utilisant des techniques comme PagedAttention pour maximiser l’utilisation du GPU.

J’ai trouvé vLLM nettement plus rapide qu’Ollama une fois bien configuré, même si la mise en place initiale est plus complexe.

Étape 1 : Installer vLLM

Je recommande d’utiliser un environnement virtuel :

python -m venv venv
source venv/bin/activate  # Sur Windows : venv\Scripts\activate

pip install -U vllm

Assurez-vous d’avoir les pilotes CUDA appropriés installés avant cette étape.

Étape 2 : Servir un modèle Qwen3

Voici où ça devient intéressant. Pour servir le modèle Qwen3-7B :

vllm serve Qwen/Qwen3-7B \
    --enable-reasoning \
    --reasoning-parser deepseek_r1

Pour les modèles plus grands qui ne tiennent pas sur un seul GPU, vous pouvez utiliser le parallélisme tensoriel :

vllm serve Qwen/Qwen3-30B-A3B \
    --enable-reasoning \
    --reasoning-parser deepseek_r1 \
    --tensor-parallel-size 2

Le flag --enable-reasoning active les capacités de pensée hybride de Qwen3, tandis que --reasoning-parser deepseek_r1 garantit que vLLM interprète correctement le format de réflexion du modèle.

Ce qui m’a surpris au début, c’est l’importance du flag --reasoning-parser. Sans lui, mes réponses étaient parfois tronquées ou contenaient des artefacts de formatage étranges.

Étape 3 : Interagir avec le serveur vLLM

Une fois lancé, vLLM héberge un serveur API (par défaut : http://localhost:8000) qui suit la spécification OpenAI API. Vous pouvez interagir avec lui via curl :

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen3-7B",
        "prompt": "Explique l’informatique quantique en termes simples",
        "max_tokens": 150,
        "temperature": 0.7
    }'

Ou avec le client Python OpenAI :

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.completions.create(
  model="Qwen/Qwen3-7B",
  prompt="Écris une fonction Python pour calculer la factorielle récursivement",
  max_tokens=150
)
print(response.choices[0].text)

Considérations de performance avec vLLM

J’ai remarqué quelques comportements intéressants avec vLLM :

La taille des lots compte : Augmenter la taille du batch (ex. --max-batch-size 8) peut améliorer significativement le débit pour plusieurs requêtes simultanées.
Premier appel plus lent : La première requête après le démarrage est souvent plus lente car le modèle se « chauffe ».
Gestion mémoire efficace : Le mécanisme PagedAttention de vLLM gère les contextes longs bien plus efficacement que d’autres frameworks que j’ai testés.

Quantification : Faire tenir les grands modèles sur du matériel grand public

Quand j’ai essayé de faire tourner Qwen3-32B, mon ordinateur m’a essentiellement dit « belle tentative, mais non ». C’est là que la quantification est venue à la rescousse.

La quantification réduit la précision des poids du modèle, échangeant un peu de précision contre une réduction significative de l’utilisation mémoire. Voici les options courantes :

FP16 (16 bits) : Par défaut, meilleure précision mais usage VRAM élevé
INT8 (8 bits) : Réduit la VRAM d’environ 50 % avec une perte de qualité minimale
INT4 (4 bits) : Réduit la VRAM d’environ 75 % avec un impact sur la qualité plus notable mais souvent acceptable

Utiliser la quantification avec Ollama

Ollama applique une certaine quantification automatiquement, mais vous pouvez spécifier des réglages personnalisés via un Modelfile :

# Créez un fichier nommé Modelfile
FROM qwen3:14b
PARAMETER num_gpu_layers 35
PARAMETER quantization_method q4_0

Puis construisez et lancez votre modèle quantifié personnalisé :

ollama create qwen3-14b-quantized -f Modelfile
ollama run qwen3-14b-quantized

Utiliser la quantification avec vLLM

vLLM supporte plusieurs méthodes de quantification via des flags en ligne de commande :

vllm serve Qwen/Qwen3-14B \
    --enable-reasoning \
    --reasoning-parser deepseek_r1 \
    --quantization awq

Les options incluent awq, gptq et squeezellm. J’ai trouvé que AWQ offre le meilleur compromis compression/qualité pour les modèles Qwen3.

Performances réelles : mes benchmarks

J’ai réalisé quelques benchmarks informels sur ma configuration (RTX 4090, 32 Go RAM, Ryzen 9 5900X) pour vous donner une idée des performances réelles :

Modèle	Quantification	Tokens/seconde	Temps de chargement	Contexte max	Usage VRAM
Qwen3-0.6B	Aucune (FP16)	42.3	6 secondes	32K	1.9 Go
Qwen3-4B	Aucune (FP16)	28.7	18 secondes	32K	9.2 Go
Qwen3-4B	4 bits (Q4_0)	26.1	12 secondes	32K	3.4 Go
Qwen3-14B	8 bits (AWQ)	15.2	45 secondes	128K	11.3 Go
Qwen3-14B	4 bits (GPTQ)	12.8	38 secondes	128K	7.1 Go

Ces chiffres utilisent vLLM et varieront selon votre matériel et les tâches exécutées.

Fait intéressant, j’ai constaté que pour certains types de tâches créatives et de génération de code, même les modèles quantifiés en 4 bits fonctionnent remarquablement bien. Pour des tâches de raisonnement complexes, la dégradation de qualité avec la quantification 4 bits devient plus perceptible.

Fonctionnalités avancées : mode pensée hybride

Une des fonctionnalités les plus intrigantes de Qwen3 est sa capacité de pensée hybride, que vous pouvez contrôler dans vos interactions.

Avec Ollama, vous pouvez utiliser des tags spéciaux dans vos prompts :

/think Je dois résoudre cela étape par étape. Quelle est la dérivée de f(x) = x^3 * ln(x) ?

Cela déclenche le mode de raisonnement interne du modèle.

Avec vLLM, le flag --enable-reasoning active cette capacité au niveau serveur, mais vous pouvez toujours la contrôler via le formatage du prompt.

J’ai trouvé le mode réflexion particulièrement utile pour les problèmes mathématiques et les tâches de raisonnement logique, où le modèle peut dérouler sa pensée avant de fournir une réponse.

Résolution des problèmes courants

Au cours de mon expérience avec Qwen3, j’ai rencontré et (finalement) résolu plusieurs problèmes fréquents :

Erreurs CUDA Out of Memory

Problème : Vous voyez des erreurs comme « CUDA out of memory » ou « RuntimeError: CUDA error: out of memory »
Solution : Essayez :

Une méthode de quantification plus agressive
Réduire la taille du batch ou la longueur du contexte
Vider le cache CUDA entre les exécutions : torch.cuda.empty_cache()

J’ai rencontré ce problème à plusieurs reprises jusqu’à ce que je réalise qu’il fallait fermer d’autres applications utilisant le GPU (oui, y compris ces onglets Chrome en arrière-plan avec du contenu WebGL !).

Première inférence lente

Problème : La première requête prend beaucoup plus de temps que les suivantes
Solution : C’est normal ! Le modèle est en cours de chargement et d’optimisation. Les requêtes suivantes seront plus rapides.

Formatage étrange des sorties

Problème : Les sorties contiennent des artefacts de formatage bizarres ou sont tronquées
Solution : Pour vLLM, assurez-vous d’utiliser le bon flag --reasoning-parser. Pour Ollama, vérifiez le formatage de vos prompts.

Échecs d’installation

Problème : Erreurs lors de l’installation des bibliothèques, notamment avec vLLM
Solution : Vérifiez la compatibilité de votre version CUDA, et que vous utilisez Python 3.10+. Sur Linux, vous pourriez avoir besoin de bibliothèques système supplémentaires :

sudo apt-get install python3-dev

Conclusion : vaut-il la peine d’exécuter Qwen3 localement ?

Après plusieurs semaines à explorer Qwen3 sur mon matériel local, ma réponse est un grand « oui » – avec quelques réserves.

Faire tourner ces modèles localement vous donne un contrôle sans précédent, la confidentialité, et la satisfaction d’avoir une IA de pointe directement sur votre machine. L’équipe Qwen a fait un travail remarquable pour rendre ces modèles accessibles, et des outils comme Ollama et vLLM ont rendu le déploiement local de plus en plus abordable.

Cependant, cela nécessite un matériel correct, surtout si vous voulez faire tourner les modèles plus grands sans quantification lourde. Pour beaucoup d’utilisateurs, le compromis idéal sera d’exécuter Qwen3-4B ou Qwen3-8B avec une quantification modérée sur un GPU grand public comme un RTX 3080 ou mieux.

Si vous débutez, je recommande :

Commencer avec Ollama pour la simplicité
Tester d’abord les petits modèles (0.6B, 1.7B, 4B)
Expérimenter la quantification pour trouver votre équilibre optimal
Passer à vLLM quand vous avez besoin de plus de performance

Le paysage du déploiement local d’IA évolue rapidement, et ce qui semblait impossible il y a un an est désormais réalisable sur du matériel grand public. Avec l’amélioration continue des techniques d’optimisation, je m’attends à ce que faire tourner des modèles encore plus grands localement devienne de plus en plus accessible.

Avez-vous essayé de faire tourner Qwen3 ou d’autres grands modèles de langage localement ? J’aimerais beaucoup connaître vos expériences et astuces !

FAQ : Vos questions sur le déploiement local de Qwen3

Puis-je faire tourner Qwen3 sur des GPU AMD ?

Oui, mais avec des limitations. Des bibliothèques comme ROCm offrent un support pour les GPU AMD, mais la compatibilité et les performances peuvent varier significativement. Je ne l’ai pas testé personnellement, mais des retours communautaires suggèrent que c’est possible, bien plus complexe qu’avec des GPU NVIDIA.

Combien d’espace disque faut-il pour tous les modèles Qwen3 ?

Si vous vouliez faire tourner toutes les variantes localement (peu courant), il vous faudrait environ 250-300 Go d’espace disque. La plupart des utilisateurs n’auront besoin que du modèle spécifique qu’ils souhaitent utiliser, généralement entre 5 et 60 Go selon la taille.

Puis-je fine-tuner Qwen3 localement ?

Oui, mais cela demande plus de ressources que l’inférence. Pour les petits modèles (jusqu’à 4B), le fine-tuning avec LoRA ou QLoRA est faisable sur du matériel grand public. Les modèles plus grands nécessiteront des ressources plus importantes.

Comment les modèles Qwen3 se comparent-ils à d’autres modèles open source comme Llama 3 ou Mistral ?

Dans mes tests, les modèles Qwen3 excellent particulièrement dans les tâches multilingues et les capacités de raisonnement. Ils sont comparables à des modèles de taille similaire d’autres familles, chacun ayant ses forces dans différents domaines.

Le déploiement local est-il adapté à un usage en production ?

Cela peut l’être, surtout avec les optimisations de vLLM, mais nécessite une réflexion approfondie sur la fiabilité, la montée en charge et la supervision. Pour un usage sérieux en production, il faudra mettre en place une gestion des erreurs, du monitoring, et potentiellement un équilibrage de charge entre plusieurs serveurs.