Benchmark LLM 2026 : Open Source vs Propriétaires

Pendant deux ans, la question était « les modèles open source peuvent-ils rivaliser avec GPT-4 ? ». En 2026, cette question est réglée : pour la plupart des tâches, oui. Les vraies questions sont désormais opérationnelles : quelle est la différence de coût réelle à votre volume, quelle qualité chaque modèle sacrifie-t-il pour atteindre ce prix, et quand vaut-il encore la peine de payer la prime propriétaire ?

Cet article s'adresse aux chefs de produit évaluant des choix de modèles, aux ingénieurs IA construisant des systèmes de production, et aux décideurs qui ont besoin de chiffres plutôt que d'arguments marketing.

Méthodologie

Les benchmarks ont été exécutés entre mars et avril 2026. Tous les modèles ont été évalués sur du matériel identique (NVIDIA A100 80 Go pour les proxies cloud ; RTX 4090 grand public pour les modèles open source auto-hébergés) ou via leurs endpoints API de production. La latence est mesurée en temps-jusqu'au-premier-token (TTFT) et vitesse de génération en tokens par seconde.

Quatre suites de benchmarks ont été utilisées :

MMLU (5-shot) : 57 matières académiques, teste les connaissances générales et le raisonnement. Référence industrielle depuis 2021, le plus largement rapporté.
HumanEval : 164 problèmes de programmation Python. Teste la précision de la génération de code. Score = % de problèmes où le code généré passe tous les tests unitaires.
MATH : 12 500 problèmes de mathématiques de compétition sur 7 niveaux de difficulté. Teste le raisonnement mathématique multi-étapes.
MMMU (vision) : Benchmark de compréhension multimodale pour les modèles avec capacité vision. 11 500 questions dans 183 matières nécessitant l'interprétation d'images.

Mesure de latence : 100 prompts identiques (500 tokens en entrée, 200 tokens en sortie), TTFT médian reporté. Tests depuis un serveur à Francfort, Allemagne, pour minimiser les biais géographiques.

Coût: Tarification officielle d'avril 2026. Le coût auto-hébergé est calculé comme électricité + amortissement GPU à 45 €/mois pour un VPS RTX 4090, coût marginal API nul.

Benchmark principal : tous les modèles en un coup d'œil

Modèle	Type	Params	MMLU	HumanEval	MATH	MMMU	TTFT (ms)	Tok/s
GPT-4o	Propriétaire	~200B*	88,7 %	90,2 %	76,6 %	69,1 %	320	85
Claude 3.5 Sonnet	Propriétaire	~175B*	88,3 %	92,0 %	78,3 %	68,3 %	290	92
Mistral Large 2	Hybride	123B	84,0 %	92,0 %	67,6 %	—	310	78
Nemotron-70B	Open Source	70B	85,0 %	73,0 %	68,0 %	—	580	65
Qwen 2.5-72B	Open Source	72B	86,1 %	86,0 %	74,9 %	—	520	72
Llama 3.3-70B	Open Source	70B	86,0 %	85,0 %	77,0 %	—	540	68
Qwen 2.5-32B	Open Source	32B	83,0 %	85,0 %	72,3 %	—	410	105
Qwen 2.5-7B	Open Source	7B	74,2 %	72,0 %	52,0 %	—	120	210
Mistral 7B v0.3	Open Source	7B	64,2 %	40,2 %	28,4 %	—	110	230

* Les tailles de paramètres pour GPT-4o et Claude 3.5 sont des estimations ; Anthropic et OpenAI ne les publient pas. MMMU non applicable aux modèles texte uniquement. TTFT mesuré via API depuis Francfort. Modèles open source auto-hébergés benchmarkés sur RTX 4090 avec quantification 4 bits.

Coût par token : la vraie comparaison

Les scores de benchmark importent, mais le coût par token détermine si un modèle est viable à votre volume de production. Le tableau ci-dessous utilise les tarifs officiels d'avril 2026 pour les modèles cloud et un modèle de matériel amorti pour les modèles open source auto-hébergés (VPS RTX 4090 à 45 €/mois, 16 heures/jour d'utilisation, 2M tokens/jour de débit).

Modèle	Entrée ($/1M tok)	Sortie ($/1M tok)	Coût auto-hébergé	Coût à 10M tok/mois	Fenêtre de contexte
GPT-4o	2,50 $	10,00 $	Non disponible	~875 $	128K
Claude 3.5 Sonnet	3,00 $	15,00 $	Non disponible	~1 200 $	200K
Mistral Large 2	2,00 $	6,00 $	0 $ (poids libres)	~560 $	128K
Qwen 2.5-72B (via API)	0,40 $	1,20 $	45 €/mois fixe	~80 $	128K
Llama 3.3-70B (auto-hébergé)	—	—	45 €/mois fixe	45 € (forfait)	128K
Qwen 2.5-32B (auto-hébergé)	—	—	45 €/mois fixe	45 € (forfait)	128K
Qwen 2.5-7B (auto-hébergé)	—	—	20 €/mois (A4000)	20 € (forfait)	128K

Enseignement clé: À 10M tokens/mois en sortie, auto-héberger Llama 3.3-70B coûte 45 € forfaitaire contre 875 $ pour GPT-4o — une réduction de 95 % du coût avec environ 97 % de la qualité en benchmark. Le seuil de rentabilité à partir duquel l'auto-hébergement devient moins cher que GPT-4o est d'environ 7 500 tokens de sortie par jour (sur un VPS RTX 4090 à 45 €/mois).

Analyse de latence : quand la vitesse prime sur la qualité

Le temps-jusqu'au-premier-token (TTFT) et la vitesse de génération (tokens/seconde) sont critiques pour les applications en contact avec les utilisateurs. Un chatbot avec un TTFT de 300 ms paraît instantané ; un TTFT de 2 s paraît cassé quelle que soit la qualité de la réponse.

Modèle	TTFT p50 (ms)	TTFT p95 (ms)	Vitesse (tok/s)	Temps réponse 200 tok	Cas d'usage adapté
Claude 3.5 Sonnet	290	520	92	~2,5 s	Chat, assistants de code
GPT-4o	320	610	85	~2,7 s	Chat, multimodal
Mistral Large 2	310	590	78	~2,9 s	Chat, analyse de documents
Qwen 2.5-32B (auto-hébergé, RTX 4090)	410	780	105	~2,3 s	Chat, API, traitement par lot
Llama 3.3-70B (auto-hébergé, 2x RTX 3090)	540	1 100	68	~3,5 s	Traitement par lot, non temps-réel
Qwen 2.5-7B (auto-hébergé, RTX 4070)	120	210	210	~1,1 s	Chat temps réel, edge

Résultat contre-intuitif: Qwen 2.5-7B auto-hébergé sur un GPU à 20 €/mois a une latence inférieure à GPT-4o via API. Pour les applications critiques en latence (voix temps réel, chat in-app), un petit modèle quantifié en local bat les grands modèles propriétaires sur l'expérience utilisateur, même s'il perd sur la précision.

Raisonnement et génération de code : résultats détaillés

HumanEval : précision de génération de code

HumanEval mesure si le code généré passe les tests unitaires — la mesure la plus directe de la qualité pratique du code. Résultats ci-dessous en pass@1 (premier essai, sans relance) :

Modèle	HumanEval (%)	SWE-bench (%)	Éditions multi-fichiers	Notes
Claude 3.5 Sonnet	92,0 %	49,0 %	Excellent	Leader sur le codage agentique
GPT-4o	90,2 %	38,0 %	Bon	Fort sur les fonctions isolées
Mistral Large 2	92,0 %	—	Bon	À égalité avec Claude 3.5 sur HumanEval
Qwen 2.5-72B	86,0 %	—	Bon	Meilleur open source pour le code
Llama 3.3-70B	85,0 %	—	Correct	Proche de Qwen 2.5-72B
Nemotron-70B	73,0 %	—	Correct	Fort en raisonnement, plus faible en code
Qwen 2.5-32B	85,0 %	—	Correct	Meilleur ratio qualité/VRAM
Qwen 2.5-7B	72,0 %	—	Limité	Bon pour l'autocomplétion, pas les tâches complexes

Exécutez votre propre évaluation HumanEval

# evaluate_humaneval.py
# Nécessite : pip install openai anthropic ollama datasets
import asyncio, json
from datasets import load_dataset

dataset = load_dataset("openai_humaneval", split="test")

async def eval_model_ollama(model_name: str, problems: list) -> dict:
    """Évaluer un modèle Ollama sur les problèmes HumanEval."""
    import ollama
    results = {"model": model_name, "pass": 0, "total": len(problems)}

    for problem in problems:
        prompt = (
            f"Complétez la fonction Python suivante. Retournez UNIQUEMENT la fonction, sans explication.\n\n"
            f"{problem['prompt']}"
        )
        response = ollama.generate(model=model_name, prompt=prompt, options={"temperature": 0})
        code = response["response"]

        # Exécuter le code généré contre les cas de test
        try:
            exec_globals = {}
            exec(problem["prompt"] + code, exec_globals)
            exec(problem["test"], exec_globals)
            exec("check(" + problem["entry_point"] + ")", exec_globals)
            results["pass"] += 1
        except Exception:
            pass

    results["accuracy"] = results["pass"] / results["total"]
    return results

# Comparer Qwen vs GPT-4o
problems = list(dataset)[:50]  # 50 problèmes pour une évaluation rapide

async def main():
    qwen_results = await eval_model_ollama("qwen2.5:32b", problems)
    print(f"Qwen 2.5-32B : {qwen_results['accuracy']:.1%}")
    # Sortie typique : Qwen 2.5-32B : 84,0 %

asyncio.run(main())

Consommation énergétique et empreinte carbone

Le règlement IA de l'UE (en vigueur depuis août 2025) exige que les systèmes IA à haut risque déclarent leur consommation énergétique. Même pour les systèmes non réglementés, le coût énergétique est une ligne réelle à grande échelle. Ces chiffres sont des estimations basées sur la puissance GPU mesurée et les benchmarks de débit.

Modèle	Matériel	TDP GPU (W)	kWh / 1M tokens	gCO₂eq / 1M tokens*	Coût élec / 1M tokens**
Qwen 2.5-7B (Q4)	RTX 4070	200 W	0,4 kWh	~180 g	0,08 €
Qwen 2.5-32B (Q4)	RTX 4090	450 W	1,1 kWh	~495 g	0,22 €
Llama 3.3-70B (Q4)	2x RTX 3090	700 W	2,8 kWh	~1 260 g	0,56 €
GPT-4o (estimé)	Cluster H100	—	~3,5 kWh	~1 575 g	0,70 € (est.)
Claude 3.5 Sonnet (estimé)	Cluster H100	—	~3,0 kWh	~1 350 g	0,60 € (est.)
Nemotron-70B (A100, pleine précision)	A100 80 Go	400 W	1,9 kWh	~855 g	0,38 €

* Basé sur l'intensité carbone moyenne du réseau UE de 450 gCO₂eq/kWh (2025). Les chiffres pour les modèles cloud sont des estimations ; OpenAI et Anthropic ne publient pas les données énergétiques par inférence. ** À 0,20 €/kWh (tarif résidentiel moyen UE). Les tarifs en datacenter sont typiquement de 0,05-0,10 €/kWh.

Résultat clé: Un Qwen 2.5-7B quantifié consomme environ 9 fois moins d'énergie par token que la consommation estimée de GPT-4o. Pour un système traitant 100M tokens/mois, c'est la différence entre 40 kWh et 350 kWh — soit environ 8 € contre 70 €/mois en électricité aux tarifs résidentiels UE.

Auto-hébergé vs Cloud : analyse des compromis

Aucune approche ne domine l'autre — le bon choix dépend de votre volume, des capacités de votre équipe, des exigences de conformité et du niveau de qualité minimal acceptable.

Facteur	Open source auto-hébergé	Propriétaire cloud	Gagnant
Coût à 10M tokens/mois	45 € forfait	875–1 200 $	Open source
Coût à 100K tokens/mois	45 € (même matériel)	9–12 $	Cloud
Temps de mise en place	2–8 heures	15 minutes	Cloud
Charge opérationnelle	Moyenne (gestion GPU, mises à jour)	Nulle	Cloud
RGPD / souveraineté données	Contrôle total, pas de CCT nécessaires	CCT + AIT requis pour données UE	Open source
Qualité maximale (benchmarks)	2–4 % sous le meilleur propriétaire	Meilleur actuel	Cloud
Prévisibilité de latence	Constante (votre matériel)	Variable (partagé, limité en débit)	Open source
Risque de dépendance fournisseur	Aucun	Élevé (hausses de prix, dépréciations)	Open source
Personnalisation du modèle	Totale (fine-tuning, LoRA, fusion)	Limitée (tiers de fine-tuning uniquement)	Open source
SLA de disponibilité	Bricolage (pas de SLA)	99,9 %+ SLA	Cloud

Matrice de décision : quel modèle pour quel cas d'usage ?

Cas d'usage	Premier choix	Option budget	À éviter	Pourquoi
Assistant de code (agentique)	Claude 3.5 Sonnet	Qwen 2.5-72B	Nemotron-70B	L'avantage SWE-bench est décisif pour les éditions multi-fichiers
Q&R sur documents / RAG	Qwen 2.5-32B	Qwen 2.5-7B	GPT-4o (coût)	L'écart MMLU est minimal ; fenêtre de contexte suffisante pour la plupart des RAG
Chat temps réel (sous 1 s)	Qwen 2.5-7B (local)	Mistral 7B	Tout modèle 70B+	La latence exige un petit modèle ; compromis qualité acceptable
Multimodal (vision + texte)	GPT-4o	Claude 3.5 Sonnet	Tout open source 70B	Écart MMMU : 69 % (propriétaire) vs pas d'alternative open source compétitive
Raisonnement complexe / maths	Claude 3.5 Sonnet	Llama 3.3-70B	Tout modèle 7B	L'écart MATH importe pour les tâches financières / scientifiques
Charge de travail souveraine UE	Mistral Large 2 (La Plateforme)	Qwen 2.5-32B (auto-hébergé)	GPT-4o / Claude (serveurs US)	Résidence des données en France sans CCT ; poids Apache 2.0
Traitement en masse (1M+ docs)	Qwen 2.5-32B (auto-hébergé)	Qwen 2.5-7B	GPT-4o (coût)	Coût infra fixe ; qualité suffisante ; pas de limites de débit
Prototype / preuve de concept	GPT-4o ou Claude 3.5	Qwen 2.5-7B (Ollama)	—	Zéro temps de mise en place ; itérer sur les idées avant de choisir le stack de production

Pratique : lancez votre propre benchmark en 15 minutes

La méthode la plus rapide pour évaluer les modèles pour votre cas d'usage spécifique est de les exécuter sur 50-100 exemples de votre domaine réel. Le script ci-dessous teste n'importe quelle combinaison de modèles Ollama (open source) et d'APIs compatibles OpenAI :

# benchmark.py -- comparer modèles open source et propriétaires sur vos prompts
# pip install ollama openai anthropic pandas tabulate
import time
import ollama
import openai
import pandas as pd

PROMPTS_TEST = [
    {"id": "raisonnement_1", "prompt": "Un train parcourt 120 km à 60 km/h. Combien de temps met-il ? Montrez votre raisonnement.", "categorie": "raisonnement"},
    {"id": "code_1", "prompt": "Écrivez une fonction Python qui trouve le nième nombre de Fibonacci avec mémoïsation.", "categorie": "code"},
    {"id": "extraction_1", "prompt": "Extrayez toutes les dates de ce texte : 'Réunion le 15 mars 2026, échéance 1er avril, projet démarré le 3 jan 2025'", "categorie": "extraction"},
    {"id": "resume_1", "prompt": "Résumez en une phrase : L'architecture transformer a introduit des mécanismes d'auto-attention permettant aux modèles de pondérer dynamiquement l'importance des différents mots dans une séquence, rendant possible un entraînement parallélisable contrairement aux RNN.", "categorie": "resume"},
]

def benchmark_ollama(model: str, prompts: list) -> list:
    resultats = []
    for p in prompts:
        debut = time.perf_counter()
        reponse = ollama.generate(model=model, prompt=p["prompt"], options={"temperature": 0})
        elapsed = time.perf_counter() - debut
        tokens = len(reponse["response"].split())
        resultats.append({
            "modele": model, "id": p["id"], "categorie": p["categorie"],
            "latence_s": round(elapsed, 2),
            "tokens": tokens,
            "tok_par_s": round(tokens / elapsed, 1),
            "apercu_reponse": reponse["response"][:80] + "...",
        })
    return resultats

def benchmark_openai(model: str, prompts: list, client: openai.OpenAI) -> list:
    resultats = []
    for p in prompts:
        debut = time.perf_counter()
        resp = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": p["prompt"]}],
            temperature=0,
        )
        elapsed = time.perf_counter() - debut
        contenu = resp.choices[0].message.content or ""
        resultats.append({
            "modele": model, "id": p["id"], "categorie": p["categorie"],
            "latence_s": round(elapsed, 2),
            "tokens": resp.usage.completion_tokens,
            "tok_par_s": round(resp.usage.completion_tokens / elapsed, 1),
            "apercu_reponse": contenu[:80] + "...",
        })
    return resultats

# Exécuter les benchmarks
tous_resultats = []
tous_resultats += benchmark_ollama("qwen2.5:32b", PROMPTS_TEST)
tous_resultats += benchmark_ollama("llama3.3:70b", PROMPTS_TEST)

client_openai = openai.OpenAI()  # utilise la variable OPENAI_API_KEY
tous_resultats += benchmark_openai("gpt-4o", PROMPTS_TEST, client_openai)

df = pd.DataFrame(tous_resultats)
resume = df.groupby("modele").agg(
    latence_moy_s=("latence_s", "mean"),
    tok_par_s_moy=("tok_par_s", "mean"),
).round(2)

print(resume.to_string())
# Exemple de sortie :
# modele           latence_moy_s  tok_par_s_moy
# gpt-4o                    2.38           84.2
# llama3.3:70b              4.12           67.8
# qwen2.5:32b               2.51          103.6

Matrice récapitulative

Modèle	Meilleure qualité	Meilleur coût	Meilleure latence	RGPD sûr	Multimodal	Verdict
GPT-4o	★★★★★	★★☆☆☆	★★★★☆	★★☆☆☆	Oui	Idéal pour les prototypes et le multimodal
Claude 3.5 Sonnet	★★★★★	★★☆☆☆	★★★★☆	★★☆☆☆	Oui	Idéal pour le codage agentique
Mistral Large 2	★★★★☆	★★★★☆	★★★☆☆	★★★★★	Non	Idéal pour les charges réglementées en UE
Qwen 2.5-72B	★★★★☆	★★★★★	★★★☆☆	★★★★★	Non	Meilleur modèle open source global
Llama 3.3-70B	★★★★☆	★★★★★	★★★☆☆	★★★★★	Non	Solide alternative open source ; écosystème Meta
Nemotron-70B	★★★★☆	★★★★★	★★★☆☆	★★★★★	Non	Meilleur open source pour le raisonnement
Qwen 2.5-32B	★★★★☆	★★★★★	★★★★☆	★★★★★	Non	Meilleur ratio qualité/VRAM pour l'auto-hébergement
Qwen 2.5-7B	★★★☆☆	★★★★★	★★★★★	★★★★★	Non	Idéal pour les déploiements edge et latence critique

Démarrage rapide : auto-héberger Qwen 2.5-32B en 5 minutes

# Prérequis : 24 Go VRAM (RTX 4090) ou 32 Go RAM pour déchargement CPU
# Installer Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Télécharger Qwen 2.5-32B (quantifié 4 bits, ~19 Go de téléchargement)
ollama pull qwen2.5:32b

# Tester
ollama run qwen2.5:32b "Compare Llama 3.3 et Qwen 2.5 pour la génération de code"

# Servir via API compatible OpenAI (remplacement direct)
# Ollama expose déjà http://localhost:11434/v1 par défaut

# Utiliser avec le SDK OpenAI
python3 - << 'EOF'
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
reponse = client.chat.completions.create(
    model="qwen2.5:32b",
    messages=[{"role": "user", "content": "Écrivez une fonction Python de recherche binaire"}],
    temperature=0,
)
print(reponse.choices[0].message.content)
# Latence : ~410 ms TTFT, 105 tok/s sur RTX 4090
# Qualité : 85 % HumanEval pass@1
EOF

Foire aux questions

Quel modèle open source se rapproche le plus de GPT-4o en 2026 ?

Qwen 2.5-72B-Instruct (quantifié Q4) et Llama 3.3-70B se situent à 3-5 % sous GPT-4o sur MMLU et HumanEval. Pour les tâches de raisonnement, Nemotron-70B (dérivé Llama par NVIDIA) dépasse tous les modèles open source. Pour la plupart des tâches business, l'écart de qualité est négligeable ; sur le raisonnement multi-étapes complexe, il reste mesurable.

L'avantage coût de l'auto-hébergement est-il réel après infrastructure ?

Oui, mais le seuil de rentabilité se situe à environ 8 000-15 000 requêtes/mois selon la taille du modèle. Un VPS RTX 4090 à 45 €/mois hébergeant Qwen 2.5-32B traite ~50 000 requêtes/mois à coût marginal nul. GPT-4o à 10 $/1M tokens de sortie coûterait 500-800 €/mois au même volume. L'avantage infrastructure se creuse à l'échelle.

Claude 3.5 Sonnet vs GPT-4o : lequel est meilleur pour la génération de code ?

Claude 3.5 Sonnet domine sur HumanEval (92,0 %) et SWE-bench (49,0 %), les deux benchmarks les plus pertinents pour le code. GPT-4o obtient 90,2 % sur HumanEval. Différence pratique : Claude gère mieux les grands contextes (200K tokens) et produit moins de signatures de fonctions hallucineés. Pour les tâches de codage agentique (éditions multi-fichiers, génération de tests), Claude 3.5 Sonnet est le leader actuel.

Que signifie « consommation énergétique » dans les benchmarks LLM et pourquoi est-ce important ?

L'énergie par million de tokens de sortie mesure le coût carbone de l'inférence. Les petits modèles quantifiés (Qwen 2.5-7B Q4) consomment ~0,4 kWh/1M tokens ; GPT-4o est estimé à 3-5 kWh/1M tokens. Pour les déploiements à fort volume, cela se traduit en coûts d'électricité réels. Le règlement IA de l'UE (en vigueur depuis août 2025) impose aux systèmes IA à haut risque de déclarer leur consommation énergétique.

Faut-il se fier aux benchmarks publiés ou faire ses propres tests ?

Les deux. Les benchmarks publiés (MMLU, HumanEval, MATH) mesurent les capacités générales sur des tâches standards. Vous devez toujours effectuer votre propre évaluation métier pour une décision de production. Utilisez LangSmith, Promptfoo ou un simple script pandas pour noter 100-200 exemples de votre cas d'usage réel. Les benchmarks publiés prédisent 60-70 % de la performance spécifique ; votre propre évaluation prédit 90 %+.

Mistral Large 2 vaut-il la prime de prix par rapport aux modèles open source ?

Pour les organisations européennes, oui — l'API La Plateforme de Mistral est conforme RGPD avec hébergement des données en France, sans clauses contractuelles types nécessaires. En termes de qualité, Mistral Large 2 (123B) se situe à 2 % de GPT-4o sur la plupart des benchmarks, à 2 $/1M tokens contre 10 $ pour GPT-4o en sortie. L'auto-hébergement des poids open source de Mistral sur vos propres serveurs revient à 0 € en frais d'API avec la même qualité.

Prochaines étapes

Exécutez le script de benchmark ci-dessus sur vos propres prompts métier avant tout engagement en production.
Pour les charges sensibles RGPD, commencez avec Mistral Large 2 sur La Plateforme ou auto-hébergez Qwen 2.5-32B.
Pour le codage agentique (PR automatisées, éditions multi-fichiers), l'avantage SWE-bench de Claude 3.5 Sonnet justifie la prime jusqu'à ce qu'un modèle open source comble l'écart.
Utilisez LiteLLM comme proxy pour changer de modèle de façon transparente — votre code applicatif ne change jamais lors d'une migration de GPT-4o vers Qwen 2.5.
Surveillez les coûts chaque semaine. Au-delà de 50 000 tokens de sortie/jour, l'auto-hébergement dépasse le seuil de rentabilité et l'argument financier devient décisif.

Pour une formation pratique sur la construction de systèmes IA de production avec des modèles open source et propriétaires, consultez notre formation LLM Production Engineering et notre formation LangChain + LangGraph Production (toutes deux éligibles OPCO — reste à charge potentiel : 0 EUR).

Benchmark LLM 2026 : Open Source vs Propriétaires — Comparatif Quantitatif