Publié le 12 avril 2026 · Lecture : 16 min

Qwen3 avec Ollama en Python : architecture MoE, thinking mode et benchmarks

1. Pourquoi Qwen3 change la donne

Depuis la sortie de Llama 2 en 2023, le paysage des LLM open source a évolué par vagues successives. Chaque génération apportait des gains incrémentaux : plus de paramètres, plus de données, meilleure instruction-following. Qwen3 marque une rupture plus profonde, sur deux plans distincts.

Le premier est l'échelle du pré-entraînement : 36 trillions de tokens, couvrant 119 langues, soit le double de Qwen2.5. Le second — et c'est là l'innovation architecturale majeure — est l'intégration native d'un mode de raisonnement étendu (thinking mode) dans le même modèle que le mode conversationnel standard. Avant Qwen3, les modèles de raisonnement (o1, DeepSeek-R1) et les modèles conversationnels rapides étaient séparés. Qwen3 fusionne les deux dans un seul poids.

2. Famille de modèles : dense vs MoE

Qwen3 propose deux familles architecturales distinctes, couvrant des besoins allant du déploiement sur edge device jusqu'au datacenter.

2.1 Modèles denses

Les six modèles denses activent l'intégralité de leurs paramètres à chaque forward pass. Ils sont plus simples à déployer et prévisibles en termes de consommation mémoire.

Source : Qwen3 Technical Report, Table 1 — arXiv 2505.09388

2.2 Modèles MoE — la vraie nouveauté

Les deux modèles MoE (Mixture-of-Experts) sont architecturalement différents : chaque couche de feedforward est remplacée par un ensemble de 128 experts spécialisés, dont seulement 8 sont activés par token via un mécanisme de routage. Le résultat : un modèle de 30 milliards de paramètres qui n'en utilise que ~3 milliards à chaque inférence.

3. Architecture interne — GQA, experts et contexte 128K

Trois choix architecturaux méritent une attention particulière pour comprendre les performances de Qwen3.

3.1 Grouped Query Attention (GQA)

Toute la famille Qwen3 utilise le Grouped Query Attention. Dans l'attention multi-têtes classique (MHA), chaque tête de requête possède sa propre tête K/V. GQA regroupe plusieurs têtes de requête partageant les mêmes têtes K/V. Conséquence directe : la taille du cache KV (qui croît linéairement avec la longueur de séquence) est réduite d'un facteur égal au ratio Q/KV.

Sur Qwen3-32B, ce ratio est 64/8 = 8× : le cache KV est 8 fois plus petit qu'en MHA classique pour le même nombre de paramètres d'attention. Cela permet des séquences longues (128K tokens) sans exploser la mémoire GPU.

3.2 Vocabulaire et tokenisation

Qwen3 utilise un vocabulaire de 151 669 tokens — significativement plus large que LLaMA (32K) ou Mistral (32K). Un vocabulaire large améliore l'efficacité de tokenisation pour les langues non-latines, réduit la longueur des séquences et améliore les performances multilingues. Le modèle hérite du tokenizer de la famille Qwen, basé sur tiktoken avec un traitement spécial des espaces.

3.3 Curriculum de pré-entraînement en 3 stages

4. Thinking mode : GRPO, RL à grande échelle et budget de raisonnement

C'est l'innovation la plus significative de Qwen3. Là où des modèles comme o1 ou DeepSeek-R1 sont des modèles de raisonnement purs (lents, coûteux), et où les modèles conversationnels sont des modèles de réponse rapide sans chaîne de pensée, Qwen3 fusionne les deux dans un seul jeu de poids.

4.1 Pipeline de post-training en 4 étapes

4.2 Budget de raisonnement — comment ça fonctionne

En thinking mode, le modèle génère d'abord un bloc de raisonnement interne (entre des balises <think> et </think>) avant de produire sa réponse finale. Ce bloc de raisonnement est de taille variable — il s'adapte à la complexité du problème. La performance s'améliore de façon continue et prévisible lorsqu'on alloue plus de budget de raisonnement — comportement dit de scalable test-time compute.

# Exemple de sortie en thinking mode
<think>
Analysons le problème. On cherche le nombre de façons de...
[raisonnement interne — longueur variable selon la complexité]
Donc la réponse est 42 car...
</think>

La réponse est 42. En effet, en appliquant le principe...

5. Benchmarks vérifiés — AIME, GPQA, LiveCodeBench

Les chiffres ci-dessous proviennent du rapport technique officiel Qwen3 (arXiv 2505.09388) et du blog Qwen. Toute comparaison avec des modèles propriétaires doit être lue avec la réserve habituelle : les benchmarks sont mesurés en conditions contrôlées et peuvent varier selon les prompts, la température, et la version du modèle.

5.1 Modèle phare (Qwen3-235B-A22B) — thinking vs non-thinking

5.2 Base model vs concurrents (Qwen3-235B-A22B-Base)

Source : Qwen3 Technical Report, Table 3 — arXiv 2505.09388. Comparaisons sur les modèles de base (pré-entraînement uniquement, sans instruction tuning).

6. Installation avec Ollama — quel modèle choisir

Tous les modèles Qwen3 sont disponibles sur la bibliothèque Ollama. La commande est standardisée :

# Modèles denses
ollama pull qwen3:0.6b
ollama pull qwen3:1.7b
ollama pull qwen3:4b
ollama pull qwen3:8b       # Recommandé pour GPU 8-12 GB
ollama pull qwen3:14b      # Recommandé pour GPU 16 GB
ollama pull qwen3:32b      # RTX 4090 24 GB

# Modèles MoE (meilleur rapport qualité/VRAM)
ollama pull qwen3:30b      # MoE ~3B actifs — très efficace
ollama pull qwen3:235b     # MoE ~22B actifs — niveau frontier

7. Thinking mode en pratique avec Ollama

Ollama gère nativement le thinking mode de Qwen3. Il y a trois façons de le contrôler.

7.1 En ligne de commande (CLI)

ollama run qwen3:14b

# Activer le thinking mode (raisonnement étendu)
/set think

# Désactiver — réponses rapides
/set nothink

# Vérifier le mode actuel
/show info

7.2 Via le paramètre think (méthode recommandée)

import ollama

# Thinking mode activé — think=True (recommandé)
response = ollama.chat(
    model="qwen3:14b",
    messages=[{
        "role": "user",
        "content": "Démontre que la somme des n premiers entiers vaut n(n+1)/2."
    }],
    think=True
)
print(response["message"]["thinking"])  # Raisonnement interne
print(response["message"]["content"])   # Réponse finale

# Non-thinking mode — think=False (réponse rapide)
response = ollama.chat(
    model="qwen3:14b",
    messages=[{
        "role": "user",
        "content": "Résume ce texte en 3 points."
    }],
    think=False
)
print(response["message"]["content"])

# Certains templates de modèles reconnaissent aussi les préfixes /think et /nothink
# directement dans le message — comportement dépendant du template, pas garanti.

8. API Python complète — Ollama SDK et OpenAI-compatible

8.1 Ollama Python SDK

import ollama

"""
pip install ollama
Prérequis : Ollama en cours d'exécution + ollama pull qwen3:14b
"""

# Chat simple avec thinking mode activé
response = ollama.chat(
    model="qwen3:14b",
    messages=[
        {"role": "system", "content": "Tu es un expert en Python. Réponds en français."},
        {"role": "user", "content": "Explique le GIL Python et ses implications sur le multithreading."}
    ],
    think=True,                # Thinking mode — interface officielle Ollama
    options={
        "temperature": 0.6,      # Recommandé pour le thinking mode
        "top_p": 0.95,
        "num_ctx": 8192,
    }
)
print(response["message"]["thinking"])  # Raisonnement interne
print(response["message"]["content"])   # Réponse finale

# Streaming — affichage token par token
for chunk in ollama.chat(
    model="qwen3:14b",
    messages=[{"role": "user", "content": "Écris une fonction Python de tri rapide (quicksort)."}],
    stream=True
):
    print(chunk["message"]["content"], end="", flush=True)

8.2 API OpenAI-compatible (drop-in replacement)

Ollama expose une API REST compatible OpenAI sur le port 11434. Tout code utilisant le SDK openai fonctionne sans modification en changeant uniquement la base URL.

from openai import OpenAI

# Pointe vers Ollama local au lieu d'OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Valeur arbitraire — Ollama ne vérifie pas la clé
)

response = client.chat.completions.create(
    model="qwen3:14b",
    messages=[
        {"role": "user", "content": "Résous : intégrale de x*sin(x) dx"}
    ],
    temperature=0.6,
    max_tokens=4096,
    stream=False,
    reasoning_effort="high"  # Thinking mode — champ OpenAI-compatible Ollama
)
print(response.choices[0].message.content)

# Listing des modèles disponibles
models = client.models.list()
for m in models.data:
    print(m.id)

8.3 Intégration LangChain

from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage, SystemMessage

llm = ChatOllama(
    model="qwen3:14b",
    temperature=0.6,
    num_ctx=8192,
    reasoning=True,  # Thinking mode — paramètre natif langchain_ollama
)

messages = [
    SystemMessage(content="Tu es un expert en mathématiques."),
    HumanMessage(content="Prouve l'irrationalité de √2."),
]

response = llm.invoke(messages)
print(response.content)

9. Comparatif VRAM et tokens/s par GPU

Estimations pratiques observées sur Ollama avec Q4_K_M (sources communautaires : localaimaster.com, willitrunai.com). Ces ordres de grandeur ne sont pas des chiffres officiels Qwen — ils varient selon la quantization, le driver, la VRAM disponible et le contexte actif.

10. Qwen3 dans un pipeline RAG et agents

Qwen3 s'intègre nativement dans les architectures RAG et agents grâce à sa compatibilité OpenAI. Si vous avez déjà un pipeline RAG Ollama (voir notre guide RAG), il suffit de changer le modèle.

10.1 Qwen3 dans un pipeline RAG LangChain

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain

# LLM : Qwen3 avec thinking mode pour les requêtes complexes
llm = ChatOllama(model="qwen3:14b", temperature=0.6, reasoning=True)

# Embeddings : nomic-embed-text (inchangé)
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Charger la base vectorielle existante
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings
)

prompt = ChatPromptTemplate.from_template(
    """Tu es un assistant expert. Réponds uniquement à partir des documents fournis.
Si la réponse est absente, indique-le clairement.

Contexte :
{context}

Question : {input}

Réponse :"""
)

chain = create_retrieval_chain(
    vectorstore.as_retriever(search_kwargs={"k": 3}),
    create_stuff_documents_chain(llm, prompt)
)

result = chain.invoke({"input": "Quelle est la politique de remboursement ?"})
print(result["answer"])

10.2 Agent avec tool use

from langchain_ollama import ChatOllama
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import tool

@tool
def calculer(expression: str) -> str:
    """Évalue une expression mathématique Python (ex: '2**32 + 17')."""
    try:
        return str(eval(expression, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"Erreur : {e}"

llm = ChatOllama(model="qwen3:14b", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant mathématique. Utilise les outils disponibles."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, [calculer], prompt)
executor = AgentExecutor(agent=agent, tools=[calculer], verbose=True)

result = executor.invoke({"input": "Calcule 2^32 et dis-moi si ce nombre est premier."})
print(result["output"])

11. Limites et points de vigilance

FAQ

Conclusion

Qwen3 représente une étape significative dans la maturation des LLM open source. L'innovation principale — la fusion du thinking mode et du mode conversationnel dans un seul modèle — résout un vrai problème pratique : choisir entre un modèle lent et précis ou un modèle rapide mais superficiel. Qwen3 donne ce choix à l'utilisateur à l'exécution, pour chaque requête.

Sur le plan technique, l'architecture MoE sans shared experts et l'unification des modes thinking / non-thinking font de Qwen3 une des sorties open-weight les plus marquantes de 2025–2026. Les benchmarks (AIME'25 à 81.5, CodeForces ELO à 2056 en thinking mode) positionnent le 235B-A22B dans la même ligue que les meilleurs modèles propriétaires sur les tâches de raisonnement formel.