🥝Kimi K2.5 : guide d'exécution locale

Guide pour exécuter Kimi-K2.5 sur votre propre appareil local !

Kimi-K2.5 est le nouveau modèle de Moonshot qui atteint des performances SOTA en vision, en codage, et pour les tâches agentiques et de chat. Le modèle de raisonnement hybride à 1T paramètres nécessite 600 Go d’espace disque, tandis que la version quantifiée Unsloth Dynamic 1,8 bits réduit cela à 240 Go (-60 % de taille): Kimi-K2.5-GGUF

Tous les téléchargements utilisent Unsloth Dynamic 2.0 pour des performances SOTA sur Aider et en 5-shot MMLU. Voyez comment nos GGUF dynamiques 1–2 bits se comportent sur les benchmarks de codage.

⚙️ Configuration recommandée

Vous avez besoin de >240 Go d’espace disque pour exécuter la quantification 1 bit !

Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier du modèle quantifié que vous téléchargez. Si ce n'est pas le cas, llama.cpp peut toujours fonctionner via un déchargement vers SSD/HDD, mais l'inférence sera plus lente.

La quantification 1,8 bit (UD-TQ1_0) fonctionnera sur un seul GPU de 24 Go si vous déchargez toutes les couches MoE vers la RAM système (ou un SSD rapide). Avec ~256 Go de RAM, attendez-vous à ~10 jetons/s. Le modèle Kimi K2.5 complet fait 630 Go et nécessite généralement au moins 4× GPU H200.

Si le modèle tient, vous obtiendrez >40 jetons/s avec un B200.

Pour exécuter le modèle en précision quasi complète, vous pouvez utiliser les quantifications 4 bits ou 5 bits. Vous pouvez utiliser toute valeur supérieure pour être sûr.

Pour de bonnes performances, visez >240 Go de mémoire unifiée (ou RAM+VRAM combinées) afin d’atteindre 10+ jetons/s. Si vous êtes en dessous, cela fonctionnera quand même, mais la vitesse diminuera (llama.cpp peut toujours fonctionner via mmap/déchargement sur disque) et peut passer d’environ 10 jetons/s à <2 jetons/s.

Nous recommandons UD-Q2_K_XL (375 Go) comme bon équilibre taille/qualité. La meilleure règle empirique : RAM+VRAM ≈ taille de la quantification ; sinon cela fonctionnera quand même, juste plus lentement à cause du déchargement.

🥝 Guide pour exécuter Kimi K2.5

Kimi-K2.5 nécessite différents paramètres d’échantillonnage selon les cas d’utilisation.

Actuellement, il n’y a pas de prise en charge de la vision pour le modèle, mais il faut espérer que llama.cpp la prendra en charge bientôt.

Pour exécuter le modèle en pleine précision, il vous suffit d’utiliser les GGUF dynamiques 4 bits ou 5 bits (par ex. UD_Q4_K_XL) car le modèle a été initialement publié au format INT4.

Vous pouvez choisir une quantification à plus grand nombre de bits par sécurité, au cas où de petites différences de quantification apparaîtraient, mais dans la plupart des cas, cela est inutile.

🌙 Guide d’utilisation :

Selon Moonshot AI, voici les paramètres recommandés pour l’inférence Kimi K2.5 :

Paramètres par défaut (mode instantané)

Mode réflexion

température = 0.6

température = 1.0

top_p = 0.95

min_p = 0,01

Réglez température 1,0 pour réduire les répétitions et les incohérences.
Longueur de contexte suggérée = 98 304 (jusqu’à 256K)
Remarque : l’utilisation d’outils différents peut nécessiter des paramètres différents

Nous recommandons de régler min_p à 0,01 pour supprimer l’apparition de jetons improbables avec de faibles probabilités. Et désactivez ou réglez repeat penalty = 1,0 si nécessaire.

Modèle de chat pour Kimi K2.5

En exécutant tokenizer.apply_chat_template([{"role": "user", "content": "Combien font 1+1 ?"},]) on obtient :

<|im_system|>système<|im_middle|>Vous êtes Kimi, un assistant IA créé par Moonshot AI.<|im_end|><|im_user|>utilisateur<|im_middle|>Combien font 1+1 ?<|im_end|><|im_assistant|>assistant<|im_middle|><think>

🦥 Exécuter Kimi-K2.5 dans Unsloth Studio

Kimi-K2.5 peut être exécuté dans Unsloth Studio, notre nouvelle interface web open source pour l’IA locale. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur MacOS, Windows, Linux et :

Rechercher, télécharger, exécuter des GGUF et des modèles safetensor
Auto-réparation appel d’outils + recherche web
Exécution de code (Python, Bash)
Inférence automatique réglage des paramètres (temp, top-p, etc.)
Inférence rapide CPU + GPU via llama.cpp
Entraîner des LLM 2x plus vite avec 70 % de VRAM en moins

Installer Unsloth

Exécutez dans votre terminal :

MacOS, Linux, WSL :

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

Windows PowerShell :

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

L’installation sera rapide et prendra environ 1 à 2 min.

Lancer Unsloth

MacOS, Linux, WSL et Windows :

unsloth studio -H 0.0.0.0 -p 8888

Puis ouvrez http://localhost:8888 dans votre navigateur.

Rechercher et télécharger Kimi-K2.5

Au premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d’intégration pour choisir un modèle, un jeu de données et les paramètres de base. Vous pouvez le passer à tout moment et aller directement au chat.

Ensuite, allez dans l’onglet Studio Chat onglet et recherchez Kimi-K2.5 dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités. Assurez-vous d’avoir suffisamment de calcul pour exécuter le modèle.

Exécuter Kimi-K2.5

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio ; toutefois, vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de conversation et d’autres réglages.

Pour plus d’informations, vous pouvez consulter notre guide d’inférence Unsloth Studio.

✨ Exécuter Kimi K2.5 dans llama.cpp

Pour ce guide, nous utiliserons la plus petite quantification 1 bit, qui fait 240 Go. N’hésitez pas à changer le type de quantification en 2 bits, 3 bits, etc. Pour exécuter le modèle en précision quasi quasi complète, vous pouvez utiliser les quantifications 4 bits ou 5 bits. Vous pouvez utiliser toute valeur supérieure pour être sûr.

Obtenez la dernière version llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

Si vous souhaitez utiliser llama.cpp directement pour charger les modèles, vous pouvez faire ce qui suit : (:UD-TQ1_0) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp pour enregistrer à un emplacement spécifique.

LLAMA_SET_ROWS=1 rend llama.cpp un peu plus rapide ! Utilisez-le ! --fit on adapte automatiquement les modèles de façon optimale sur tous vos GPU et CPU.

export LLAMA_CACHE="unsloth/Kimi-K2.5-GGUF"
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \
    -hf unsloth/Kimi-K2.5-GGUF:UD-TQ1_0\
    --temp 1.0 \
    --min-p 0.01 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407

--fit on adaptera automatiquement le modèle à votre système. Si vous n’utilisez pas --fit on et que vous avez environ 360 Go de mémoire GPU combinée, supprimez -ot ".ffn_.*_exps.=CPU" pour obtenir une vitesse maximale.

Utilisez --fit on pour l’adaptation automatique sur les GPU et les CPU. Si cela ne fonctionne pas, voir ci-dessous :

Veuillez essayer -ot ".ffn_.*_exps.=CPU" pour décharger toutes les couches MoE vers le CPU ! Cela permet effectivement de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l'expression regex pour faire tenir davantage de couches si vous disposez de plus de capacité GPU.

Si vous avez un peu plus de mémoire GPU, essayez -ot ".ffn_(up|down)_exps.=CPU" Cela décharge les couches MoE de projection montante et descendante.

Essayez -ot ".ffn_(up)_exps.=CPU" si vous avez encore plus de mémoire GPU. Cela décharge uniquement les couches MoE de projection montante.

Et enfin, déchargez toutes les couches via -ot ".ffn_.*_exps.=CPU" Cela utilise le moins de VRAM.

Vous pouvez aussi personnaliser la regex, par exemple -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" signifie décharger les couches MoE gate, up et down, mais uniquement à partir de la 6e couche.

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Nous recommandons d’utiliser notre quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer taille et précision. Toutes les versions sur : huggingface.co/unsloth/Kimi-K2.5-GGUF Si les téléchargements restent bloqués, voir Hugging Face Hub, débogage XET

pip install -U huggingface_hub
hf download unsloth/Kimi-K2.5-GGUF \
    --local-dir unsloth/Kimi-K2.5-GGUF \
    --include "*UD-TQ1_0*" # Utilisez "*UD-Q2_K_XL*" pour le 2 bits dynamique

Si vous constatez que les téléchargements restent bloqués à 90 à 95 % environ, veuillez consulter notre guide de dépannage.

Exécutez n’importe quelle invite.
Modifier --ctx-size 16384 pour la longueur de contexte. Vous pouvez également omettre cela pour la découverte automatique de la longueur de contexte via --fit on

LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \
    --temp 1.0 \
    --min-p 0.01 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407

Par exemple, essayez : "Créer un jeu Flappy Bird en HTML", et vous obtiendrez :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            background: #222;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Segoe UI', sans-serif;
            overflow: hidden;
            touch-action: none;
        }
        
        #game-container {
            position: relative;
            width: 400px;
            height: 600px;
            background: linear-gradient(to bottom, #70c5ce 0%, #70c5ce 80%, #c23810 80%, #c23810 100%);
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
            overflow: hidden;
        }
        
        canvas {
            display: block;
        }
        
        .overlay {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            text-align: center;
            color: white;
            text-shadow: 2px 2px 0 #000;
            font-weight: bold;
            pointer-events: none;
        }
        
        .game-title {
            font-size: 48px;
            margin-bottom: 20px;
        }
        
        .score-display {
            font-size: 36px;
            margin-bottom: 10px;
        }
        
        .best-score {
            font-size: 24px;
            color: #ffe;
        }
        
        .instruction {
            font-size: 20px;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0 %, 100 % { opacity: 1; }
            50 % { opacity: 0.5; }
        }
        
        .hidden { display: none; }
    </style>
</head>
<body>
    <div id="game-container">
        <canvas id="canvas" width="400" height="600"></canvas>
        
        <!-- Écran de démarrage -->
        <div id="start-screen" class="overlay">
            <div class="game-title">FLAPPY BIRD</div>
            <div class="instruction">Cliquez ou appuyez sur Espace pour voler</div>
        </div>
        
        <!-- Écran de fin de partie -->
        <div id="game-over-screen" class="overlay hidden">
            <div class="game-title">FIN DE PARTIE</div>
            <div class="score-display">Score : <span id="final-score">0</span></div>
            <div class="best-score">Meilleur : <span id="best-score">0</span></div>
            <div class="instruction">Cliquez pour recommencer</div>
        </div>
        
        <!-- Compteur de score -->
        <div id="current-score" class="overlay hidden" style="top: 10%; font-size: 72px; color: white; text-shadow: 4px 4px 0 #000;">
            0
        </div>
    </div>

    <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        
        // Constantes du jeu
        const GRAVITY = 0.4;
        const JUMP_STRENGTH = -7;
        const PIPE_SPEED = 3;
        const PIPE_SPAWN_RATE = 120; // images
        const PIPE_GAP = 120;
        
        // État du jeu
        let bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
        let pipes = [];
        let score = 0;
        let bestScore = localStorage.getItem('flappyBest') || 0;
        let frameCount = 0;
        let isGameOver = false;
        let isPlaying = false;
        
        // Éléments DOM
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const currentScoreDisplay = document.getElementById('current-score');
        const finalScoreEl = document.getElementById('final-score');
        const bestScoreEl = document.getElementById('best-score');
        
        // Gestion des entrées
        function handleInput(e) {
            if (!isPlaying) {
                if (isGameOver) {
                    resetGame();
                }
                startGame();
            } else if (!isGameOver) {
                bird.velocity = JUMP_STRENGTH;
                bird.wingState = 1;
            }
        }
        
        document.addEventListener('keydown', (e) => {
            if (e.code === 'Space' || e.code === 'ArrowUp') handleInput(e);
        });
        canvas.addEventListener('pointerdown', handleInput);
        
        function startGame() {
            isPlaying = true;
            isGameOver = false;
            startScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function resetGameState() {
            bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
            pipes = [];
            score = 0;
            frameCount = 0;
            currentScoreDisplay.textContent = score;
        }
        
        function resetGame() {
            isGameOver = false;
            isPlaying = true;
            gameOverScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function spawnPipe() {
            const minHeight = 100;
            const maxHeight = 400;
            const topHeight = Math.floor(Math.random() * (maxHeight - minHeight + 1) + minHeight);
            const bottomHeight = canvas.height - topHeight - PIPE_GAP;
            
            pipes.push({
                x: canvas.width,
                topHeight: topHeight,
                bottomY: topHeight + PIPE_GAP,
                bottomHeight: bottomHeight,
                passed: false
            });
        }
        
        function update() {
            if (isGameOver) return;
            
            // Physique de l’oiseau
            bird.velocity += GRAVITY;
            bird.y += bird.velocity;
            
            // Collision avec le sol/le plafond
            if (bird.y + bird.radius > canvas.height || bird.y - bird.radius < 0) {
                gameOver();
                return;
            }
            
            // Apparition des tuyaux
            frameCount++;
            if (frameCount % PIPE_SPAWN_RATE === 0) {
                spawnPipe();
            }
            
            // Mouvement des tuyaux et collision
            for (let i = pipes.length - 1; i >= 0; i--) {
                const pipe = pipes[i];
                pipe.x -= PIPE_SPEED;
                
                // Supprimer les tuyaux hors écran
                if (pipe.x + 60 < 0) {
                    pipes.splice(i, 1);
                    continue;
                }
                
                // Détection des collisions (rectangle-cercle simplifié)
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // L’oiseau est un cercle, les tuyaux sont des rectangles
                const birdLeft = bird.x - bird.radius + 4; // +4 pour le décalage du bec
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // Vérification de collision horizontale
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // Collision avec le tuyau supérieur
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // Collision avec le tuyau inférieur
                    if (birdBottom > pipe.bottomY) {
                        gameOver();
                        return;
                    }
                }
                
                // Comptage des points
                if (pipe.x + pipeWidth < bird.x && !pipe.passued) {
                    pipe.passed = true;
                    score++;
                    currentScoreDisplay.textContent = score;
                }
            }
            
            // Animer les ailes
            if (bird.wingState > 0) {
                bird.wingState = (bird.wingState + 0.2) % 2;
            }
        }
        
        function draw() {
            // Effacer le canevas
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // Dessiner les tuyaux
            pipes.forEach(pipe => {
                // Tuyau supérieur
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, 0, 60, pipe.topHeight);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.topHeight - 20, 60, 20); // Capuchon
                
                // Tuyau inférieur
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, pipe.bottomY, 60, canvas.height - pipe.bottomY);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.bottomY - 20, 60, 20); // Capuchon
            });
            
            // Dessiner l’oiseau (cercle avec bec)
            ctx.fillStyle = '#e3bc4e';
            ctx.beginPath();
            ctx.arc(bird.x, bird.y, bird.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // Bec
            ctx.fillStyle = '#e04c4c';
            ctx.beginPath();
            ctx.moveTo(bird.x + bird.radius - 4, bird.y - 4);
            ctx.lineTo(bird.x + bird.radius + 10, bird.y);
            ctx.lineTo(bird.x + bird.radius - 4, bird.y + 4);
            ctx.fill();
            
            // Yeux
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(bird.x + 5, bird.y - 6, 3, 0, Math.PI * 2);
            ctx.fill();
            
            // Ailes
            ctx.fillStyle = '#c4a';
            ctx.beginPath();
            ctx.ellipse(bird.x - 5, bird.y + 5, 10, 6, 0, 0, Math.PI * 2);
            ctx.fill();
        }
        
        function gameOver() {
            isGameOver = true;
            isPlaying = false;
            
            // Mettre à jour le meilleur score
            if (score > bestScore) {
                bestScore = score;
                localStorage.setItem('flappyBest', bestScore);
            }
            
            // Afficher l’écran de fin de partie
            currentScoreDisplay.classList.add('hidden');
            gameOverScreen.classList.remove('hidden');
            finalScoreEl.textContent = score;
            bestScoreEl.textContent = bestScore;
        }
        
        function gameLoop() {
            if (!isPlaying) return;
            
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }
        
        // Dessin initial
        draw();
    </script>
</body>
</html>

✨ Déployer avec llama-server et la bibliothèque de complétion d'OpenAI

L'utilisation de --kv-unified peut rendre le service d’inférence plus rapide dans llama.cpp ! Voir https://www.reddit.com/r/LocalLLaMA/comments/1qnwa33/glm_47_flash_huge_performance_improvement_with_kvu/

Après avoir installé llama.cpp comme indiqué dans Kimi K2.5, vous pouvez utiliser ce qui suit pour lancer un serveur compatible OpenAI :

LLAMA_SET_ROWS=1 ./llama.cpp/llama-server \
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \
    --special \
    --alias "unsloth/Kimi-K2.5" \
    --min-p 0.01 \
    --ctx-size 16384 \
    --port 8001 \
    --kv-unified

Ensuite, utilisez la bibliothèque Python d'OpenAI après pip install openai :

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Kimi-K2.5",
    messages = [{"role": "user", "content": "Combien font 1+1 ?"},],
)
print(completion.choices[0].message.content)

Et nous obtenons :

Et dans l’autre fenêtre de llama-server :

📊 Benchmarks

Vous pouvez voir ci-dessous d'autres benchmarks sous forme de tableau :

Raisonnement et connaissances

Benchmark

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

HLE-Full

30.1

34.5

30.8

37.5

25.1†

HLE-Full (avec outils)

50.2

45.5

43.2

45.8

40.8†

AIME 2025

96.1

100

92.8

95.0

93.1

HMMT 2025 (févr.)

95.4

99.4

92.9*

97.3*

92.5

IMO-AnswerBench

81.8

86.3

78.5*

83.1*

78.3

GPQA-Diamond

87.6

92.4

87.0

91.9

82.4

MMLU-Pro

87.1

86.7*

89.3*

90.1

85.0

Image et vidéo

Benchmark

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

MMMU-Pro

78.5

79.5*

74.0

81.0

69.3

CharXiv (RQ)

77.5

82.1

67.2*

81.4

66.1

MathVision

84.2

83.0

77.1*

86.1*

74.6

MathVista (mini)

90.1

82.8*

80.2*

89.8*

85.8

ZeroBench

ZeroBench (avec outils)

12*

OCRBench

92.3

80.7*

86.5*

90.3*

87.5

OmniDocBench 1.5

88.8

85.7

87.7*

88.5

82.0*

InfoVQA (val)

92.6

84*

76.9*

57.2*

89.5

SimpleVQA

71.2

55.8*

69.7*

56.8*

WorldVQA

46.3

28.0

36.8

47.4

23.5

VideoMMMU

86.6

85.9

84.4*

87.6

80.0

MMVU

80.4

80.8*

77.3

77.5

71.1

MotionBench

70.4

64.8

60.3

70.3

VideoMME

87.4

86.0*

88.4*

79.0

LongVideoBench

79.8

76.5*

67.2*

77.7*

65.6*

LVBench

75.9

73.5*

63.6

Codage

Benchmark

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

SWE-Bench Verified

76.8

80.0

80.9

76.2

73.1

SWE-Bench Pro

50.7

55.6

55.4*

SWE-Bench Multilingual

73.0

72.0

77.5

65.0

70.2

Terminal Bench 2.0

50.8

54.0

59.3

54.2

46.4

PaperBench

63.5

63.7*

72.9*

47.1

CyberGym

41.3

50.6

39.9*

17.3*

SciCode

48.7

52.1

49.5

56.1

38.9

OJBench (cpp)

57.4

54.6*

68.5*

54.7*

LiveCodeBench (v6)

85.0

82.2*

87.4*

83.3

Contexte long

Benchmark

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

Longbench v2

61.0

54.5*

64.4*

68.2*

59.8*

AA-LCR

70.0

72.3*

71.3*

65.3*

64.3*

Recherche agentique

Benchmark

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

BrowseComp

60.6

65.8

37.0

37.8

51.4

BrowseComp (avec gestion du contexte)

74.9

65.8

57.8

59.2

67.6

BrowseComp (Essaim d’agents)

78.4

WideSearch (item-f1)

72.7

76.2*

57.0

32.5*

WideSearch (item-f1 Essaim d’agents)

79.0

DeepSearchQA

77.1

71.3*

76.1*

63.2*

60.9*

FinSearchCompT2&T3

67.8

66.2*

49.9

59.1*

Seal-0

57.4

45.0

47.7*

45.5*

49.5*

Notes

* = score réévalué par les auteurs (non disponible publiquement auparavant).
† = le score de DeepSeek V3.2 correspond à son sous-ensemble texte uniquement (comme indiqué dans les notes de bas de page).
- = non évalué / non disponible.

PrécédentGLM-4.7-Flash Suivantgpt-oss

Mis à jour il y a 2 mois

Ce contenu vous a-t-il été utile ?