> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/deepseek-v4.1-flash.md).

# DeepSeek-V4.1-Flash : Guide d'exécution locale

Exécutez DeepSeek-V4.1-Flash-1017 localement avec les GGUF d'Unsloth et le déchargement n-gram d'Engram.

**DeepSeek-V4.1-Flash-1017** est la nouvelle mise à jour de V4.1-Flash, qui en fait le **modèle ouvert le plus puissant** à ce jour pour le codage, les tâches agentiques et bien plus encore. Avec un contexte de 1M, son **552B** paramètres de base + **196B paramètres Engram** permettent le déportage vers un SSD afin de réduire les besoins en RAM/VRAM. Ce guide explique comment exécuter DeepSeek-V4.1 en local avec Unsloth [Dynamic V3.1](#dynamic-v3.1-update-october-30th-2026) GGUF, qui offrent une **précision accrue de 10 à 15 %** et **une utilisation des jetons réduite de 30 %** par rapport aux autres quantifications de même taille.

[Unsloth Desktop](/docs/fr/desktop.md) + llama.cpp permet une inférence DeepSeek-V4.1 environ**3 fois plus rapide** que les autres dépôts CPU/VRAM/ngram. DeepSeek s’exécute localement sur des configurations avec au moins 128 Go de RAM, ou 64 Go de RAM (plus lentement). `UD-Q8_K_XL` (sans perte) pèse **508,4 Go**, tandis que `UD-Q4_K_XL` (quasi sans perte) pèse **500,7 Go**. GGUF : [**DeepSeek-V4.1-Flash-1017-GGUF**](https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF)

<a href="/docs/fr/modeles/deepseek-v4.1-flash.md#usage-guide" class="button primary">Tutoriels pour exécuter DeepSeek-V4.1</a>

### Mise à jour de Dynamic V3.1 (2 novembre 2026)

Nous publions de nouveaux GGUF DeepSeek-V4.1-Flash-1017 qui utilisent notre nouvel [**Unsloth Dynamic**](/docs/fr/notions-de-base/dynamic-3.0-ggufs.md) **algorithme V3.1 (préversion)** qui améliore les quantifications Unsloth dans presque tous les benchmarks et se classe parmi les meilleurs fournisseurs.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FXC2NHQCS4KKsMoY4IjpT%2Fimage.png?alt=media&amp;token=67fb9d55-8fbb-4f35-a13f-83465cee8475" alt="" width="563"><figcaption></figcaption></figure>

Si nous évaluons également le modèle Coder d’ISTA, nous constatons que le modèle Coder élagué obtient des résultats bien moins bons sur les tâches agentiques : Aider Polyglot atteint une précision de 47,6 %, contre 78,2 %, pour une taille réduite de seulement 20 %. Cela signifie en partie que chaque réduction de taille de 1 % est associée à une baisse de précision d’environ 1 %.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fe3HYFau6qEpkFwkLVwru%2FCoder%20benchmark.png?alt=media&amp;token=59e2ab09-3f42-4226-bd03-3b5a8d109e6a" alt="" width="563"><figcaption></figcaption></figure>

**Nous avons réalisé des benchmarks agentiques, notamment Terminal Bench 2.1, DeepSWE v1.1,** Automation Bench v1.0.6, Aider Polyglot, ainsi que des benchmarks généraux comme SciCode, HLE Diamond (texte uniquement), LiveCodeBench v6, GPQA Diamond, MMLU-Pro, AIME25, IFEval, MATH-500 (niveau 5), HMMT 2025 et HMMT 2026. Nous avons corrigé certains problèmes signalés à propos de ces nouveaux benchmarks :

* Un contexte de 32K était trop court : nous avons utilisé **un contexte de 512K pour les tâches agentiques** + 128K pour les tâches générales
* Benchmarks saturés : nouveaux benchmarks **agentiques non saturés** notamment Terminal Bench, DeepSWE et Automation Bench
* Les benchmarks sont bruités : nous avons effectué **35,1 milliards de jetons de tests, contre 1,3 milliard auparavant, soit 27 fois plus de données**. Voir [#benchmark-runs-per-model](#benchmark-runs-per-model "mention") où nous avons effectué 64 exécutions d’AIME 2025, 3 de DeepSWE, 3 de TB, et bien plus.
* Nos évaluateurs se trompent : nous avons utilisé [Math Verify](https://huggingface.co/blog/math_verify_leaderboard), amélioré les évaluateurs, utilisé gpt-6-luna xhigh pour HLE et utilisé les évaluateurs officiels pour Terminal Bench (Harbor), DeepSWE et les autres. Voir [#graders](#graders "mention") et [#infrastructure-and-benchmark-issues-and-fixes](#infrastructure-and-benchmark-issues-and-fixes "mention")

Les résultats complets des benchmarks sont également fournis. Le premier graphique présente la récupération de précision en pourcentage par rapport à la référence, moyennée sur les 14 benchmarks (sans pondération). Cette mesure indique approximativement la précision conservée par chaque quant par rapport au modèle DeepSeek de référence.

Pour une [analyse complète de nos benchmarks, voir ici.](#gguf-benchmark-breakdown)

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FQumjSkZM3UWgSRSa5taa%2Fimage.png?alt=media&amp;token=23092c27-abae-4376-b44a-7ae91f918705" alt="" width="563"><figcaption></figcaption></figure>

#### Nous ne parvenons toujours pas à reproduire les chiffres de récupération de GSQ-RCO

GSQ-RCO IQ1\_M revendique une récupération de 98.7 %, mais nous avons mesuré 97.24 \[96.23, 98.21] avec une **valeur p de 0.0013** (statistiquement significatif, donc extrêmement improbable)

La récupération de 100 % revendiquée pour GSQ-RCO IQ2\_XS est possible avec une valeur p de 0.21. Nous avons mesuré 98.38 % \[97.52, 99.22].

GSQ-RCO IQ2\_XXS revendique une récupération de 99.80 %, mais nous avons mesuré 98.38 \[97.52, 99.22] avec une **valeur p de 0.0001 (extrêmement significatif)**.

Récupération revendiquée testée directement par rapport à notre mesure (définition de la fiche : somme des 3 scores / somme de la référence, par rapport aux modèles officiels FP8/FP4) : p (aucune perte) = test de permutation apparié par inversion de signe pour une récupération de 100 % ; p (récupération >= revendication) = bootstrap apparié unilatéral sur les questions.

|                  | Récupération revendiquée | Récupération mesurée \[IC à 95 %] | p (aucune perte) | p (récupération >= revendication) |
| ---------------- | -----------------------: | --------------------------------: | ---------------: | --------------------------------: |
| GSQ-RCO IQ1\_M   |                    98.70 |             97.24 \[96.23, 98.21] |          0.00002 |                            0.0013 |
| GSQ-RCO IQ2\_XXS |                   100.00 |             98.38 \[97.52, 99.22] |           0.0003 |                            0.0001 |
| GSQ-RCO IQ2\_XS  |                    99.80 |            99.54 \[98.88, 100.18] |             0.16 |                              0.21 |

Récupération revendiquée et réelle par benchmark, toutes comparées aux modèles officiels FP8/FP4 (la référence de la fiche). Revendiquée = score de la fiche / référence de la fiche ; réelle = moyenne de nos mesures sur 12 à 64 échantillons par question / moyenne du modèle officiel sur les mêmes questions, avec IC bootstrap apparié à 95 %. p (réelle >= revendiquée) : bootstrap apparié unilatéral, probabilité que la récupération réelle atteigne le chiffre revendiqué. p (aucune perte) : test de permutation apparié bilatéral pour une récupération réelle de 100 % (la quantification de chaque question et la paire officielle sont permutées au hasard). Quants Unsloth (mesurés uniquement) à titre de référence pour des tailles similaires.

<details>

<summary>Cliquez pour consulter l’analyse détaillée du tableau</summary>

| Modèle           |                           |                  AIME25 |                  GPQA-D |                  LCB v6 | 3 benchmarks (définition de la fiche) |
| ---------------- | ------------------------- | ----------------------: | ----------------------: | ----------------------: | ------------------------------------: |
| GSQ-RCO IQ1\_M   | revendiquée (fiche)       |                  100.00 |                   97.22 |                   98.73 |                                 98.69 |
|                  | réelle (mesurée)          |   98.37 \[97.06, 99.53] |   96.83 \[94.60, 98.89] |   96.44 \[94.69, 98.08] |                 97.24 \[96.24, 98.21] |
|                  | p (réelle >= revendiquée) |                  0.0028 |                    0.38 |                  0.0027 |                                0.0014 |
|                  | p (aucune perte)          |                   0.019 |                  0.0041 |                 <0.0001 |                               <0.0001 |
| GSQ-RCO IQ2\_XXS | revendiquée (fiche)       |                  100.00 |                  100.00 |                  100.00 |                                100.00 |
|                  | réelle (mesurée)          |  99.53 \[98.84, 100.21] |   97.73 \[95.80, 99.61] |   97.80 \[96.08, 99.39] |                 98.38 \[97.52, 99.23] |
|                  | p (réelle >= revendiquée) |                     0.1 |                  0.0092 |                  0.0027 |                               <0.0001 |
|                  | p (aucune perte)          |                    0.25 |                   0.022 |                  0.0085 |                               0.00025 |
| GSQ-RCO IQ2\_XS  | revendiquée (fiche)       |                  100.00 |                   99.44 |                  100.00 |                                 99.82 |
|                  | réelle (mesurée)          |  99.58 \[98.53, 100.47] |  99.45 \[98.12, 100.73] |  99.58 \[98.47, 100.70] |                99.54 \[98.88, 100.17] |
|                  | p (réelle >= revendiquée) |                    0.21 |                    0.51 |                    0.24 |                                  0.19 |
|                  | p (aucune perte)          |                    0.48 |                    0.43 |                    0.52 |                                  0.17 |
| UD IQ1\_S        | réelle (mesurée)          |  99.58 \[98.96, 100.21] |   97.42 \[95.41, 99.39] | 100.21 \[99.03, 101.38] |                 99.08 \[98.29, 99.85] |
|                  | p (aucune perte)          |                    0.26 |                   0.011 |                    0.73 |                                 0.023 |
| UD IQ1\_M        | réelle (mesurée)          |  99.68 \[98.94, 100.42] |   98.37 \[96.95, 99.76] | 100.37 \[99.15, 101.61] |                99.48 \[98.82, 100.14] |
|                  | p (aucune perte)          |                    0.52 |                   0.025 |                    0.56 |                                  0.13 |
| UD IQ2\_XXS      | réelle (mesurée)          | 100.00 \[99.32, 100.58] |  99.53 \[98.36, 100.68] | 100.47 \[99.27, 101.74] |               100.00 \[99.40, 100.58] |
|                  | p (aucune perte)          |                       1 |                    0.45 |                    0.46 |                                     1 |
| UD Q2\_K\_XL     | réelle (mesurée)          |  99.79 \[99.16, 100.37] |  99.74 \[98.69, 100.77] | 100.89 \[99.90, 101.93] |               100.13 \[99.63, 100.65] |
|                  | p (aucune perte)          |                    0.63 |                    0.66 |                   0.076 |                                  0.62 |
| UD-Q8\_K\_XL     | réelle (mesurée)          |  99.47 \[97.94, 100.53] | 100.28 \[99.52, 101.09] | 100.89 \[99.95, 101.95] |               100.19 \[99.53, 100.77] |
|                  | p (aucune perte)          |                    0.73 |                    0.48 |                   0.084 |                                  0.59 |

</details>

#### Questions d’AIME 2025 auxquelles GSQ-RCO IQ1\_M a répondu incorrectement

GSQ-RCO IQ1\_M obtient un score de 97.34 % à AIME 2025 (51 réponses incorrectes sur 1,920 échantillons, 64 par question) et manque au moins un échantillon sur 15 des 30 questions ; une exécution unique avec un score de 30/30 se produit donc environ 43 % du temps. Chaque réponse incorrecte est une valeur réellement erronée (2 ont atteint la limite de 128K sans réponse finale). À titre de référence, voici le nombre de réponses correctes obtenues par les autres modèles sur les mêmes questions :

<details>

<summary>Cliquez pour consulter l’analyse détaillée du tableau</summary>

| Question (réponse) | GSQ IQ1\_M : erreurs / échantillons | Réponses incorrectes données                          | Réponses correctes du modèle officiel | Réponses correctes de UD-Q8\_K\_XL | Réponses correctes de UD IQ1\_S | Réponses correctes de GSQ IQ2\_XS |
| ------------------ | ----------------------------------: | ----------------------------------------------------- | ------------------------------------: | ---------------------------------: | ------------------------------: | --------------------------------: |
| Q15 (735)          |                                9/64 | 637 x2, 833 x2, 271, 636, 613, 52, 539                |                                 31/32 |                              60/64 |                           59/64 |                             56/64 |
| Q28 (248)          |                                8/64 | 888, 256, 608, 808, 632, 592, 136, 448                |                                 31/32 |                              63/64 |                           60/64 |                             64/64 |
| Q22 (237)          |                                6/64 | 57, 993, 945, 249, 473, 125                           |                                 32/32 |                              63/64 |                           62/64 |                             64/64 |
| Q13 (204)          |                                5/64 | \frac{587}{3}, 154, \frac{662}{3}, \frac{562}{3}, 179 |                                 31/32 |                              64/64 |                           63/64 |                             63/64 |
| Q24 (149)          |                                5/64 | 150 x4, 145                                           |                                 30/32 |                              48/64 |                           63/64 |                             55/64 |
| Q5 (279)           |                                4/64 | 9 x2, 135, 423                                        |                                 32/32 |                              63/64 |                           63/64 |                             63/64 |
| Q4 (117)           |                                3/64 | 119 x3                                                |                                 31/32 |                              64/64 |                           62/64 |                             64/64 |
| Q11 (259)          |                                2/64 | 23, 261                                               |                                 32/32 |                              64/64 |                           64/64 |                             64/64 |
| Q14 (60)           |                                2/64 | aucune réponse finale (limite de 128K) x2             |                                 31/32 |                              64/64 |                           63/64 |                             64/64 |
| Q18 (82)           |                                2/64 | 106, 712                                              |                                 32/32 |                              63/64 |                           64/64 |                             64/64 |
| Q2 (588)           |                                1/64 | 1176                                                  |                                 32/32 |                              64/64 |                           64/64 |                             64/64 |
| Q3 (16)            |                                1/64 | 520                                                   |                                 31/32 |                              63/64 |                           62/64 |                             63/64 |
| Q7 (821)           |                                1/64 | 271                                                   |                                 32/32 |                              63/64 |                           63/64 |                             63/64 |
| Q19 (106)          |                                1/64 | 317                                                   |                                 32/32 |                              63/64 |                           63/64 |                             63/64 |
| Q29 (104)          |                                1/64 | 55                                                    |                                 32/32 |                              64/64 |                           64/64 |                             62/64 |

</details>

Q28 et Q22 sont des artefacts de quantification (IQ1\_M se trompe sur 8 et 6 réponses sur 64 ; GSQ IQ2\_XS et le modèle officiel ne le font presque jamais) ; Q15 et Q24 sont difficiles pour tous les modèles (UD-Q8\_K\_XL répond correctement à Q24 dans 48 cas sur 64, en répondant souvent 150 au lieu de 149).

### Mise à jour de Dynamic V3.1 (30 octobre 2026)

Nous avons exécuté AIME25, Aider Polyglot, LiveCodeBench v6, HMMT 2026, GPQA Diamond, MMLU-Pro, IFEval et d'autres tests sur toutes nos quantifications de UDv3 et UD3.1, en comparaison avec les variantes GSQ-RCO, qui prétendent rétablir un score de 100 % sur AIME25 pour toutes les quantifications. Nous n'avons toutefois pas pu reproduire ces résultats.

Nous fournissons une moyenne complète de 6 benchmarks (sans Aider Polyglot — si on l'inclut, la différence est encore plus marquée) et montrons que UD3.1 obtient d'excellents résultats sur presque toutes les tâches.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FOuLKE4mwn1xkCJchptDN%2Ftotal_ista.png?alt=media&amp;token=cdc15dba-6b30-4ca3-8318-94138acf6d27" alt=""><figcaption></figcaption></figure>

#### Nous ne parvenons pas à reproduire les résultats de GSQ-RCO

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgEHmQB9WBKLJ1vMssB6N%2Fclaims_ista.png?alt=media&amp;token=838ee657-1085-4c00-bcdb-66abbe2862c1" alt=""><figcaption></figcaption></figure>

Les quantifications GSQ-RCO DeepSeek-V4.1-Flash-1017, créées par ISTA-DASLab, auraient obtenu un score de 100 % sur AIME25 pour toutes les quantifications. Nous n'avons pas pu reproduire ce résultat. Sur AIME25, après plusieurs exécutions et calcul de la moyenne, nous constatons que **GSQ-RCO conserve 94,64 % des résultats de référence (et non 100 %)**. Nous avons également mis à l'échelle tous les résultats de référence dans le deuxième graphique afin de tenir compte des différences de méthodologie.

<div><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FMFdsiPUHkPAXMYPblKDx%2Fgsq_rco_claims_vs_true_bars(1).png?alt=media&amp;token=99b6f559-52fe-481f-911a-92b559cfd01f" alt=""><figcaption></figcaption></figure> <figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FDHa3imd8XoDXehkvATcC%2Fgsq_rco_claims_vs_true_bars_recovery.png?alt=media&amp;token=244b229c-1b23-47e3-bfa5-d0b9631f426b" alt=""><figcaption></figcaption></figure></div>

Pour AIME25 en particulier, ISTA a indiqué une précision de 100 % pour les 3 quantifications. Pourtant, en testant chacune d'elles 16 fois par question sur AIME25 — soit 30 problèmes × 16 échantillons = 480 réponses par quantification, avec une température de 1,0 et un effort de raisonnement de 50 —, nous observons une nette dégradation des quantifications, qui n'atteignent aucunement une précision de 100 % quelle que soit la largeur en bits.&#x20;

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FtcF0k9ss042lXLgvDyIt%2Faime25.png?alt=media&amp;token=8025e417-e669-43cb-bf8f-ce69a9254aca" alt="" width="375"><figcaption></figcaption></figure>

Les benchmarks GSQ-RCO sont réalisés avec un effort de raisonnement de 50, conformément également au fichier README.md

#### La DKL est une mesure raisonnable

Certaines affirmations récentes prétendent que la DKL n'est pas une bonne mesure. La divergence de Kullback-Leibler (DKL) mesure l'écart entre les prédictions du prochain jeton d'un modèle quantifié et celles d'un modèle de référence, pour un même texte.

$$
\text{min  } D\_{KL} \large( \theta, \hat{\theta}\large)
$$

**L'objectif principal de la quantification est de ramener la DKL à 0 tout en réduisant l'espace disque occupé par le modèle quantifié** (on peut également optimiser d'autres critères, comme la vitesse de génération, par exemple).

Si la DKL est égale à 0, le modèle a parfaitement reconstitué les logits de sortie, et le modèle quantifié produit donc exactement les mêmes résultats que le modèle d'origine.

On voit clairement que GSQ-RCO présente une DKL plus élevée et un taux de concordance dans le top 1 % plus faible que même nos anciennes quantifications Unsloth v3 ; v3.1 améliore encore ces résultats.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F0YkDIvosvnP6nRVlhNy5%2FKLD%20ISTA.png?alt=media&amp;token=a4601232-2858-4b8d-a618-8991a48eeb6d" alt="" width="563"><figcaption></figcaption></figure>

Certaines personnes affirment qu'on peut « manipuler » la DKL ou optimiser excessivement les benchmarks en la calculant sur le jeu de test, ou en utilisant un seul jeu de données. Pour vérifier cette hypothèse, nous avons effectué des tests sur plusieurs jeux de données réservés à l'évaluation et montré que UDv3.1 fait mieux que GSQ-RCO dans tous les domaines.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FBBJeFPqCiW0Al9IvGNsC%2Fsize_vs_kld_per_axis(2).png?alt=media&amp;token=08452280-2005-4fa9-bdc7-a37f162b49e7" alt=""><figcaption></figcaption></figure>

Nous fournissons également le taux de concordance dans le top 1 % pour tous les tests réservés à l'évaluation :

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FcCroCNVfybzFZ7lAMHVy%2Fsize_vs_top1_per_axis(2).png?alt=media&amp;token=a7f50164-e15c-45ef-911b-e73882436845" alt=""><figcaption></figcaption></figure>

#### La quantification allonge les raisonnements

Nous avons également vérifié si les quantifications à faible nombre de bits entraînent des raisonnements plus longs. Nous avons fixé la longueur du contexte de tous les tests à 32K et écarté les quantifications dont le raisonnement était trop long. Nous avons aussi exécuté LiveCodeBench avec une limite de 128K jetons ; les résultats sont similaires. Nous indiquons le nombre de réponses tronquées sur les 6 benchmarks et montrons que les quantifications Unsloth sont beaucoup moins souvent tronquées que celles de GSQ (elles raisonnent donc moins longtemps).

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FEKPO459yFA9vQwKohCR0%2Ftruncation.png?alt=media&amp;token=e8ddafad-7f4e-4891-a329-511ffd177365" alt="" width="375"><figcaption></figcaption></figure>

Cela montre toutefois que la quantification allonge les raisonnements ; prévoyez donc un budget de raisonnement plus élevé pour les quantifications avec moins de bits.

#### Retrait d'Engram pour les benchmarks

Nous avons également retiré Engram pour la génération des graphiques, mais cela ne change rien, car toutes les quantifications à faible nombre de bits utilisent IQ4\_NL comme Engram — Q2\_K\_XL et IQ2\_XXS utilisent Q5\_K.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fzggh3ij4y2HInPA0LU80%2Fremove%20engram.png?alt=media&amp;token=5900687a-ad79-4d69-8650-318fa3a17d61" alt=""><figcaption></figcaption></figure>

#### Résultats complets des benchmarks

<details>

<summary>Cliquez pour consulter l’analyse détaillée du tableau</summary>

| Quantification           | Taille (Go) | AIME25 | HMMT Feb26 | GPQA-D | MMLU-Pro | IFEval | LCB v6 (32K) | Moyenne sur 6 | Aider pass\@1 | Tronquées % (6) |
| ------------------------ | ----------: | -----: | ---------: | -----: | -------: | -----: | -----------: | ------------: | ------------: | --------------: |
| UD-Q8\_K\_XL (référence) |       508.4 |  97.08 |      68.94 |  90.47 |    88.61 |  95.10 |        85.90 |         87.68 |             - |            1.48 |
| UD-Q2\_K\_XL (v3.1)      |       334.8 |  97.50 |      69.89 |  89.58 |    88.28 |  94.92 |        84.76 |         87.49 |             - |            2.10 |
| UD-IQ2\_XXS (v3.1)       |       300.5 |  96.88 |      67.61 |  88.95 |    87.53 |  95.19 |        83.62 |         86.63 |         44.38 |            2.71 |
| UD-IQ1\_M (v3.1)         |       250.4 |  95.00 |      62.88 |  88.38 |    87.53 |  95.10 |        84.38 |         85.55 |         42.13 |            2.91 |
| UD-IQ1\_S (v3.1)         |       233.0 |  92.92 |      57.01 |  87.63 |    86.62 |  94.92 |        82.10 |         83.53 |         36.52 |            4.15 |
| GSQ-RCO IQ2\_XS          |       265.8 |  95.00 |      64.39 |  88.64 |    86.62 |  94.27 |        84.95 |         85.64 |         41.57 |            2.83 |
| GSQ-RCO IQ2\_XXS         |       248.8 |  95.21 |      57.95 |  85.80 |    86.53 |  93.72 |        82.86 |         83.68 |         36.52 |            4.00 |
| GSQ-RCO IQ1\_M           |       231.3 |  91.88 |      53.60 |  85.10 |    85.49 |  91.77 |        82.86 |         81.78 |         29.78 |            4.69 |

</details>

#### Méthodologies complètes d’évaluation comparative

<details>

<summary>Cliquez pour consulter l’analyse détaillée du tableau</summary>

| Benchmark       | Source (révision)                          | Éléments |                    Échantillons / élément | Nombre maximal de tokens | Graine de base      | Invite                                                                              | Évaluateur                                                                         |
| --------------- | ------------------------------------------ | -------: | ----------------------------------------: | -----------------------: | ------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| AIME25          | MathArena/aime\_2025 (c94da77e)            |       30 |                                        16 |                   32,768 | 20261029            | problème + "Please reason step by step, and put your final answer within \boxed{}." | math\_verify sur le dernier \boxed{}, avec repli sur un entier exact               |
| HMMT Feb26      | MathArena/hmmt\_feb\_2026                  |       33 |                                        16 |                   32,768 | 20261029            | comme AIME25                                                                        | math\_verify                                                                       |
| GPQA-D          | Idavidrein/gpqa diamond (633f5ee8)         |      198 | 8 (4 + 4 ; téléversements antérieurs : 4) |                   32,768 | 20261026 + 20261029 | Modèle de questions à choix multiples d’OpenAI simple-evals                         | dernier "Answer: X", solutions de repli : \boxed{X}, "answer is (X)", lettre seule |
| MMLU-Pro        | Sous-ensemble stratifié de 1 203 éléments  |    1,203 |                                         2 |                   32,768 | 20261029            | style simple-evals, jusqu’à 10 options                                              | dernier "Answer: X"                                                                |
| IFEval          | google/IFEval                              |      541 |                                         2 |                   32,768 | 20261029            | invite brute                                                                        | instruction\_following\_eval officiel, strict, au niveau de l’invite               |
| LCB v6 (32K)    | livecodebench/code\_generation\_lite test6 |      175 |                                         3 |                   32,768 | 20261026            | invite système + invite utilisateur officielles de LCB                              | extract\_code + run\_test officiels, 6 s par test, sous-processus isolé            |
| Moyenne sur 6   | Tous les benchmarks ci-dessus              |          |                                           |                          |                     |                                                                                     | moyenne des 9 valeurs de pass\@1                                                   |
| Aider pass\@1   | Aider Polyglot                             |      225 |                                   1 essai |       32 768 par réponse | sans objet          | benchmark officiel d’aider dans Docker                                              | les tests unitaires de l’exercice                                                  |
| Tronquées % (6) | les 6 benchmarks                           |          |                                           |                   32,768 |                     |                                                                                     | proportion des réponses qui s’arrêtent à la limite de tokens                       |

</details>

### ⚙️ Guide d’utilisation

**DeepSeek-V4.1-Flash-1017** associe MoE à **la mémoire conditionnelle Engram** : les n-grammes de jusqu’à quatre tokens accèdent à quelques lignes de la table par token ; il n’est donc pas nécessaire de conserver la table en mémoire GPU. Pour l’inférence, il est préférable d’utiliser Unsloth, qui permet d’obtenir jusqu’à **3 fois plus rapide** inférence de DeepSeek-V4.1 que d’autres dépôts axés sur le CPU, la VRAM ou les n-grammes, grâce à une optimisation par-dessus llama.cpp.

1 bit `UD-IQ1_S` fonctionnera sur des configurations avec 128 Go de RAM, comme un MacBook, un DGX Spark ou un RTX Spark, tandis que la version 3 bits `UD-IQ3_XXS` fonctionnera sur des configurations avec 256 Go de RAM, comme un Mac Studio.

Comme les couches PLE / n-grammes de notre [Qwen3.8-Flash-Next](/docs/fr/modeles/qwen3.8-next.md) guide, la table Engram de 110,6 à 202,8 Go peut rester sur SSD grâce à mmap. Les lignes sont chargées à la demande dans le cache du système d’exploitation, ce qui économise de la RAM/VRAM tout en conservant la même exigence d’espace disque.

#### **Configuration requise pour DeepSeek-V4.1-Flash-1017 :**

**Tableau : configuration matérielle requise** (RAM + VRAM, ou mémoire unifiée ; Engram sur SSD).

| 1 bit      | 2 bits     | 3 bits     | 4 bits | 8 bits |
| ---------- | ---------- | ---------- | ------ | ------ |
| 128–145 Go | 176–205 Go | 256–290 Go | 305 Go | 315 Go |

Les estimations prévoient environ 5 à 10 Go de plus que pour les poids sans Engram. L’exécution et le contexte peuvent nécessiter davantage.

**Stockage des n-grammes :** Les formats de recherche et les tailles des poids sont indiqués ci-dessous. « Rest GB » correspond à la quantité minimale absolue de RAM/VRAM requise.

| Quantification | Format n-gramme / Go | Go restants |
| -------------- | -------------------- | ----------- |
| UD-IQ1\_S      | IQ4\_NL / 110.6      | 122.4       |
| UD-IQ1\_M      | IQ4\_NL / 110.6      | 139.8       |
| UD-IQ2\_XXS    | Q5\_K / 135.2        | 165.3       |
| UD-Q2\_K\_XL   | Q5\_K / 135.2        | 199.6       |
| UD-IQ3\_XXS    | Q6\_K / 161.3        | 233.5       |
| UD-IQ3\_S      | Q6\_K / 161.3        | 262.3       |
| UD-Q3\_K\_XL   | MXFP8 / 202.8        | 282.3       |
| UD-Q4\_K\_XL   | MXFP8 / 202.8        | 297.9       |
| UD-Q8\_K\_XL   | MXFP8 / 202.8        | 305.6       |

### Paramètres recommandés

DeepSeek recommande une température de 1.0, un top-p de 1.0 et la désactivation de top-k et de min-p :

| Paramètre                    | Valeur             |
| ---------------------------- | ------------------ |
| `temperature`                | `1.0`              |
| `top_p`                      | `1.0`              |
| Fenêtre de contexte maximale | `1,048,576` jetons |

DeepSeek recommande de prévoir **au moins 256K jetons de sortie** pour sa configuration de génération longue.

#### **Niveau d’effort de réflexion**

La réflexion est activée par défaut, avec `reasoning_effort=75` (« élevé »). Vous pouvez définir un entier compris entre **1 et 100** . Des valeurs plus élevées demandent au modèle de raisonner plus en profondeur ; elles ne correspondent pas à une limite de tokens. Le modèle de chat inclus accepte également `low` = 50, `medium` = 62, `high` = 75 et `max` = 100.

Par exemple, ajoutez l’une de ces options à votre commande de lancement :

```bash
# Effort de réflexion par défaut
--chat-template-kwargs '{"reasoning_effort":75}'

# Effort de réflexion maximal
--chat-template-kwargs '{"reasoning_effort":100}'

# Désactiver la réflexion
--chat-template-kwargs '{"enable_thinking":false}'
```

## Exécutez **DeepSeek-V4.1-Flash-1017** Tutoriels :

Pour ce tutoriel, nous utilisons `UD-Q2_K_XL`. Unsloth sélectionne automatiquement les configurations optimales, ou presque, pour le déchargement de DeepSeek-V4.1, les n-grammes, etc., afin que votre installation offre les meilleures performances possibles.

### 🦥 Guide Unsloth

[Unsloth Desktop](https://unsloth.ai/docs/desktop) est notre interface open source pour l’IA locale sur macOS, Windows et Linux. Vous pouvez rechercher et télécharger des fichiers GGUF, configurer le déchargement vers le processeur et la carte graphique, régler les paramètres d’inférence et connecter des outils depuis une seule application.

{% stepper %}
{% step %}

#### Installer Unsloth

Le moyen le plus simple de commencer est de télécharger la [application de bureau Unsloth](/docs/fr/desktop.md). Fonctionne sur [macOS](/docs/fr/commencer/install/mac.md), [Windows](/docs/fr/commencer/install/windows-installation.md), et [Linux](/docs/fr/commencer/install/linux.md).

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Télécharger Unsloth</a>

* <i class="fa-apple">:apple:</i> [Télécharger pour macOS](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Télécharger pour Windows](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Télécharger pour Linux](https://unsloth.ai/download/linux)

Ou, si vous préférez installer manuellement :
{% endstep %}

{% step %}

#### Recherchez et téléchargez DeepSeek-V4.1-Flash-1017

Allez sur [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) ou dans Model hub, recherchez **DeepSeek-V4.1-Flash-1017** et sélectionnez [unsloth/DeepSeek-V4.1-Flash-1017-GGUF](https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF). Téléchargez la quantification souhaitée en utilisant les tailles et exigences mémoire ci-dessus.
{% endstep %}

{% step %}

#### Exécutez DeepSeek-V4.1-Flash-1017

Le raisonnement est activé par défaut avec `75`, vous pouvez le modifier avec notre interrupteur. Unsloth sélectionne automatiquement les configurations de déchargement, n-gramme, etc. quasi optimales pour DeepSeek-V4.1, garantissant à votre configuration la vitesse la plus proche du meilleur possible.

Pour plus d'informations, vous pouvez consulter notre [guide d'inférence Unsloth](/docs/fr/nouveau/studio/chat.md).

Avec UD-IQ1\_S, le téléchargement de 233,0 Go comprend une table n-gramme Engram de 110,6 Go et 122,4 Go d’autres poids. Utilisez le chargement à la demande d’Engram pour conserver la table de recherche sur SSD, avec de la RAM/VRAM supplémentaire pour les lignes mises en cache, le contexte et les tampons d’exécution. Suivez le guide d’utilisation ci-dessus pour les exigences mémoire.
{% endstep %}

{% step %}

#### Servez DeepSeek-V4.1-Flash-1017 avec l’API Unsloth

Vous pouvez utiliser `unsloth run` la commande et servir DeepSeek-V4.1-Flash-1017 via une API en utilisant `llama-server` les options d'exécution, notamment le dimensionnement du contexte, les couches GPU, le multithreading, l'échantillonnage, le réseau et la configuration des outils. Pour plus d'infos, consultez nos [docs API](/docs/fr/notions-de-base/api.md) ou [unsloth start](/docs/fr/integrations/unsloth-start.md).

{% code overflow="wrap" %}

```bash
unsloth run --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF:UD-Q2_K_XL \
    --temp 1.0 \
    --top-p 1.0 \
    --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":75}'
```

{% endcode %}

Utilisez un runtime avec DeepSeek-V4.1-1017 et la prise en charge du chargement à la demande d’Engram. Appliquez les paramètres de déchargement sur SSD et de mémoire du guide d’utilisation lorsque vous conservez la table n-gramme sur disque.
{% endstep %}

{% step %}

#### Unsloth est maintenant prêt

Vous pouvez connecter DeepSeek-V4.1-Flash-1017 à vos outils via Unsloth Desktop. Unsloth prend également en charge les flux de travail suivants :

* **Connecter des outils :** [Claude Code](/docs/fr/notions-de-base/claude-code.md), [Codex](/docs/fr/notions-de-base/codex.md), [recherche web](/docs/fr/nouveau/studio/chat.md#advanced-web-search), [MCP](/docs/fr/notions-de-base/mcp.md) et plus encore
* **Entraîner des modèles :** Affinez d'autres modèles pris en charge de texte, de diffusion, [d'embedding](/docs/fr/notions-de-base/embedding-finetuning.md), et plus encore
* **Générer des médias :** Créer et entraîner [des images](/docs/fr/notions-de-base/diffusion-image.md), des vidéos, [TTS](/docs/fr/notions-de-base/text-to-speech-tts-fine-tuning.md) en local

<div align="center"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FYShiiub5gs5pCQLX6d4U%2FScreenshot%202026-08-15%20at%2012.18.24%E2%80%AFAM.png?alt=media&amp;token=d6996797-a144-4113-b4c3-155cca6c39a0" alt="Unsloth Desktop Agents settings interface example" width="563"><figcaption><p>Paramètres Agents d'Unsloth Desktop (exemple d'interface). Sélectionnez DeepSeek-V4.1-Flash-1017 et votre quantification téléchargée lors de la connexion d'un outil.</p></figcaption></figure></div>
{% endstep %}
{% endstepper %}

### 🦙 Exécuter DeepSeek-V4.1-Flash dans llama.cpp

{% stepper %}
{% step %}
Nous devons utiliser notre PR spécifique pour llama.cpp [ici](https://github.com/ggml-org/llama.cpp/pull/30817). Vous pouvez également suivre les instructions de compilation ci-dessous. Remplacez `-DGGML_CUDA=ON` par `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous souhaitez simplement effectuer l’inférence sur le processeur. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis poursuivez comme d’habitude : la prise en charge de Metal est activée par défaut.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev git -y
git clone https://github.com/ggml-org/llama.cpp
git -C llama.cpp fetch origin pull/30817/head:deepseek41
git -C llama.cpp checkout deepseek41
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
```

{% endstep %}

{% step %}
Pour exécuter le modèle, vous pouvez lancer :

```bash
pip install -U "huggingface_hub[cli]"
hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --local-dir unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --include "*UD-Q2_K_XL*"
```

Conservez les sept fragments dans le même dossier et indiquez `--model` le premier fragment. llama.cpp charge automatiquement les fragments restants.
{% endstep %}

{% step %}
Puis, pour l’exécuter :

```bash
./llama.cpp/llama-cli \
    --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF/UD-Q2_K_XL/DeepSeek-V4.1-Flash-1017-UD-Q2_K_XL-00001-of-00007.gguf \
    --temp 1.0 \
    --top-p 1.0 \
    --top-k 0 \
    --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":75}' \
    --load-mode mmap \
    --lazy-mode on \
    --override-tensor "per_layer_token_embd.weight=CPU"
```

Cet exemple charge à la demande la table de n-grammes Engram depuis le SSD. Gardez `--load-mode mmap` et `--lazy-mode on` activés pour le déport vers le SSD.
{% endstep %}
{% endstepper %}

### ⚡**DSpark** - Décodage spéculatif

DeepSeek-V4.1 inclut **DSpark**, une architecture de décodage spéculatif qui propose plusieurs jetons avant que le modèle principal ne les vérifie. Cette fonctionnalité est distincte de la table de consultation de n-grammes Engram : **Engram fournit une mémoire apprise ; DSpark accélère le décodage**. L’option de décodage spéculatif par n-grammes, au nom similaire, est également une fonctionnalité distincte.

Pour utiliser DSpark, associez le modèle principal à un **modèle brouillon V4.1-1017** compatible et à un environnement d’exécution prenant en charge DSpark. Veillez à ce que les versions du modèle brouillon et du point de contrôle principal correspondent, et prévoyez de la mémoire supplémentaire pour le modèle brouillon. Les exemples CLI et serveur de ce guide utilisent le décodage standard.

**DSpark permet d’accélérer d’environ 1,3 à 1,5 fois le décodage avec DeepSeek-V4.1-Flash-GGUF !**

Nous proposons un module DSpark Q8\_0 de 8 Go et un module BF16 complet de 8,5 Go.

### :checkered\_flag:Combiner différentes précisions Engram

Vous pouvez également choisir la précision Engram de DeepSeek-V4.1 selon vos préférences.

| Précision Engram  | Taille (Go) |
| ----------------- | ----------- |
| MXFP8 (d’origine) | 202,8 Go    |
| Q6\_K             | 161,3 Go    |
| Q5\_K             | 135,2 Go    |
| IQ4\_NL           | 110,6 Go    |

llama.cpp b12233 ou version ultérieure peut charger directement une table avec `--ple` ([PR #31185](https://github.com/ggml-org/llama.cpp/pull/31185)), sans `set_split.py` ni renommage. Téléchargez la table souhaitée et ajoutez `--ple` à votre commande habituelle. Exemple : UD-IQ1\_S avec la table Q6\_K :

```bash
hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --local-dir unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --include "engram/*Q6_K*"
./llama.cpp/llama-server \
    --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF/UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00001-of-00005.gguf \
    --ple unsloth/DeepSeek-V4.1-Flash-1017-GGUF/engram/DeepSeek-V4.1-Flash-1017-engram-Q6_K.gguf_file
```

llama.cpp ignore alors la table propre à la quantification, qui est l’un des fichiers de cette quantification (`-00005-of-00005` pour UD-IQ1\_S ; le [README d’Engram](https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF/blob/main/engram/README.md) la répertorie pour chaque quantification). Supprimer ce fichier ou ne pas le télécharger avec `--exclude "UD-IQ1_S/*-00005-of-00005.gguf"`permet d’économiser 110,6 Go. Sans `--ple`la quantification revient à sa propre table, ou ne démarre pas si ce fichier est absent. La compilation PR #30817 ci-dessus ne comporte pas `--ple` ; avec cette compilation, suivez les étapes ci-dessous. llama.cpp b12233 et les versions ultérieures lisent les tables MXFP8, notamment celles de UD-Q3\_K\_XL, UD-Q4\_K\_XL et UD-Q8\_K\_XL, comme un type différent (F8\_E4M3) et produisent des résultats incorrects sans signaler d’erreur. Pour MXFP8, utilisez donc la compilation PR #30817.

Par exemple, après avoir téléchargé la quantification dynamique 1 bit IQ1\_S, qui utilise par défaut l’Engram IQ4\_NL, vous pouvez la remplacer par la version MXFP8 en téléchargeant uniquement l’Engram MXFP8 à l’adresse <https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF/tree/main/engram> nommé `DeepSeek-V4.1-Flash-1017-engram-MXFP8.gguf_file` Pour ce faire, suivez le script ci-dessous :

```bash
# 1. récupérer la table et le script
hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
  --include "engram/*MXFP8*" "engram/set_split.py" --local-dir .

# 2. l’indiquer comme fragment 5 sur 5 (emplacement de la table de UD-IQ1_S)
python engram/set_split.py engram/DeepSeek-V4.1-Flash-1017-engram-MXFP8.gguf_file 5 5

# 3. mettre l’ancienne table de côté, puis renommer la nouvelle avec le nom du fragment de table
mv UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00005-of-00005.gguf UD-IQ1_S/engram-IQ4_NL.bak
mv engram/DeepSeek-V4.1-Flash-1017-engram-MXFP8.gguf_file \
   UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00005-of-00005.gguf

# 4. exécuter comme d’habitude
llama-server -m UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00001-of-00005.gguf
```

## 📊 Évaluations comparatives

### 📊 Analyse de la quantification

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FZbUjhpI7wJTjf3pM1uwu%2Fsize_vs_top1(1).png?alt=media&amp;token=4e133008-8026-4e93-baa7-d7f2e2b81ecc" alt=""><figcaption></figcaption></figure>

Les résultats sont comparés à la référence officielle de DeepSeek sur wiki1100 et long17k. Une KL plus faible signifie que les probabilités du prochain jeton sont plus proches ; un top-1 plus élevé signifie que davantage de prédictions correspondent.

DeepSeek mélange **MXFP4**, FP8 et BF16. Q4 et Q8 conservent les **MXFP4** experts et la même table Engram ; leurs appellations ne décrivent pas la précision de chaque tenseur. Q4 stocke de nombreux poids hors experts en Q8\_0 ; Q8 utilise BF16.

Nous présentons également les résultats obtenus en faisant varier la précision d’Engram, d’IQ4\_NL à Q5\_K, puis Q6\_K et MXFP8, et proposons des **Engrams autonomes pour vous permettre de les combiner librement.**

<details>

<summary>Cliquez pour consulter l’analyse détaillée du tableau</summary>

| Quantification | Taille totale | wiki1100 KL / top-1 | long17k KL / top-1 |
| -------------- | ------------- | ------------------- | ------------------ |
| UD-IQ1\_S      | 233,0 Go      | 0.457 / 82.8%       | 0.364 / 85.1%      |
| UD-IQ1\_M      | 250,4 Go      | 0.314 / 87.1%       | 0.241 / 88.2%      |
| UD-IQ2\_XXS    | 300,5 Go      | 0.203 / 90.5%       | 0.142 / 91.2%      |
| UD-Q2\_K\_XL   | 334,8 Go      | 0.138 / 91.5%       | 0.0879 / 93.3%     |
| UD-IQ3\_XXS    | 394,7 Go      | 0.0625 / 94.6%      | 0.043 / 95.1%      |
| UD-IQ3\_S      | 423,6 Go      | 0.0316 / 96.0%      | 0.0195 / 96.8%     |
| UD-Q3\_K\_XL   | 485,1 Go      | 0.0204 / 96.5%      | 0.0114 / 97.4%     |
| UD-Q4\_K\_XL   | 500,7 Go      | 9.00e-03 / 98.2%    | 4.46e-03 / 98.5%   |
| UD-Q8\_K\_XL   | 508,4 Go      | 4,76e-03 / 98,5 %   | 2,81e-03 / 98,7 %  |

</details>

**Choisir une quantification :** IQ1\_S économise environ 54 % d’espace disque par rapport à Q8. IQ1\_M ajoute 17,4 Go et améliore l’accord top-1 de 4,3 points sur wiki1100 et de 3,1 sur long17k. Les variantes IQ3 atteignent un accord de 94,6 à 96,8 %.

### **Benchmarks KLD et top-1 % des GGUF**

Nos quantifications affichent un accord top-1 de 82,8 à 98,5 % par rapport à la référence officielle F32 sur wiki1100, et de 85,1 à 98,7 % sur long17k. UD-Q4\_K\_XL économise 7,7 Go par rapport à UD-Q8\_K\_XL, avec un écart d’accord de 0,3 point de pourcentage sur wiki1100 et de 0,2 sur long17k. Q8 présente également une divergence KL plus faible sur les deux ensembles.

**Nous modifions également la précision de la table engram, d’IQ4\_NL à Q5\_K, Q6\_K et MXFP8, et montrons l’effet sur la KLD**

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FdIFvyiUQafZ2upn6VdhJ%2Fsize_vs_kld(1).png?alt=media&amp;token=e5d14eab-9143-4d0a-b1a6-f5427d995808" alt=""><figcaption></figcaption></figure>

### **Benchmarks officiels**

DeepSeek rapporte les résultats suivants pour **V4.1-Flash-1017** par rapport à la version précédente V4.1-Flash. Il s’agit des résultats officiels du modèle, et non de mesures des GGUF présentés dans ce guide. Source : [la fiche de modèle de DeepSeek pour la version 1017](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017).

| Benchmark                    | V4.1-Flash-1017 | V4.1-Flash   |
| ---------------------------- | --------------- | ------------ |
| HLE sans outils              | 42.6 (44.0†)    | 36.8 (39.1†) |
| Terminal-Bench 4.0           | 42.3            | 31.2         |
| DeepSWE v1.1                 | 77.0            | 74.2         |
| ProgramBench                 | 29.1            | 20.3         |
| NL2Repo-Bench                | 68.2            | 65.4         |
| Automation-Bench v1.0.6      | 60.5            | 54.8         |
| Agents’ Last Exam            | 35.4            | 31.8         |
| Apex Bench v1.1              | 72.1            | 64.6         |
| Chartography (avec outils)   | 83.0            | 78.9         |
| BabyVision (avec outils)     | 92.5            | 89.6         |
| ZeroBench-main (avec outils) | 51.0            | 49.0         |

† Sous-ensemble de HLE limité au texte. DeepSeek utilise le dispositif Claude Code pour Terminal-Bench 4.0 et Mini-SWE-V2 pour DeepSWE v1.1. Les scores dépendent de la configuration d’évaluation, de l’effort de raisonnement et du budget de contexte.

### Détail des benchmarks GGUF

**Évaluateurs :**

Voir [GGUFs dynamiques 3.1](/docs/fr/notions-de-base/dynamic-3.0-ggufs/ggufs-dynamiques-3.1.md#graders-used-for-benchmarks)

**Problèmes d’infrastructure et de benchmark, et correctifs :**

Voir [GGUFs dynamiques 3.1](/docs/fr/notions-de-base/dynamic-3.0-ggufs/ggufs-dynamiques-3.1.md#infrastructure-and-benchmark-issues-and-fixes)

**Configuration de DeepSWE pour les benchmarks :**

Voir [GGUFs dynamiques 3.1](/docs/fr/notions-de-base/dynamic-3.0-ggufs/ggufs-dynamiques-3.1.md#deepswe-setup-for-benchmarks)

**Configuration de Terminal Bench pour les benchmarks :**

Voir [GGUFs dynamiques 3.1](/docs/fr/notions-de-base/dynamic-3.0-ggufs/ggufs-dynamiques-3.1.md#terminal-bench-setup-for-benchmarks)

**Tâches de Terminal Bench exclues en raison de problèmes :**

Voir [GGUFs dynamiques 3.1](/docs/fr/notions-de-base/dynamic-3.0-ggufs/ggufs-dynamiques-3.1.md#excluded-terminal-bench-tasks-due-to-issues)

#### Exécutions des benchmarks par modèle

Nous avons effectué plusieurs exécutions afin d’assurer l’équité : Terminal Bench et DeepSWE, 3 fois par quantification ; AIME 2025, 64 fois par quantification ; LiveCodeBench, 12 fois par quantification, et plus encore. Certains essais ont dû être relancés pour corriger des problèmes d’infrastructure (délais d’expiration, surcharge du processeur, etc.) ; sinon, ils auraient été considérés comme des échecs. Ces cas ne concernent que quelques questions au total.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/modeles/deepseek-v4.1-flash.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
