# GGUFs Unsloth Dynamic 2.0 Nous sommes ravis de présenter [Unsloth](https://github.com/unslothai/unsloth) la quantification dynamique v2.0 — une mise à niveau majeure de nos quantifications précédentes. Cette nouvelle méthode surpasse les principales méthodes de quantification et établit de nouveaux repères pour [Aider Polglot](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot), MMLU en 5 tirs et divergence KL. Cela signifie que vous pouvez désormais exécuter + affiner [des LLM quantifiés](https://unsloth.ai/docs/fr/modeles/tutorials) tout en préservant autant de précision que possible ! Vous pouvez exécuter les GGUF 2.0 sur la plupart des moteurs d’inférence comme llama.cpp, [Unsloth Studio](https://unsloth.ai/docs/fr/nouveau/studio) etc. {% columns %} {% column %} [**Mise à jour du 27 fév. 2026 :**](https://unsloth.ai/docs/fr/modeles/qwen3.5/gguf-benchmarks) **Qwen3.5** est sorti et nous avons corrigé certains problèmes de modèles de chat pour l’appel d’outils et évalué chaque GGUF sur la perplexité et la divergence KL. [Voir les benchmarks !](https://unsloth.ai/docs/fr/modeles/qwen3.5/gguf-benchmarks) L **avantage clé** d’utiliser le [package Unsloth](https://github.com/unslothai/unsloth) et les quantifications est notre rôle actif dans la correction de bugs dans les grands modèles. Nous avons collaboré directement avec les équipes derrière [Qwen3](https://www.reddit.com/r/LocalLLaMA/comments/1kaodxu/qwen3_unsloth_dynamic_ggufs_128k_context_bug_fixes/), [Meta (Llama 4)](https://github.com/ggml-org/llama.cpp/pull/12889), [Mistral (Devstral)](https://app.gitbook.com/o/HpyELzcNe0topgVLGCZY/s/xhOjnexMCB3dmuQFQ2Zq/~/changes/618/basics/tutorials-how-to-fine-tune-and-run-llms/devstral-how-to-run-and-fine-tune), [Google (Gemma 1–3)](https://news.ycombinator.com/item?id=39671146) et [Microsoft (Phi-3/4)](https://simonwillison.net/2025/Jan/11/phi-4-bug-fixes), en contribuant à des corrections qui augmentent la précision. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% hint style="success" %} Les GGUF dynamiques d’Unsloth peuvent désormais être exécutés en [Unsloth Studio](https://unsloth.ai/docs/fr/nouveau/studio) ✨ {% endhint %} {% hint style="success" %} [mise à jour du 10 sept. 2025 :](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot) Vous avez demandé des benchmarks plus difficiles, alors voici les résultats d’Aider Polyglot ! Notre GGUF Dynamic 3 bits DeepSeek V3.1 obtient **75.6%**, dépassant de nombreux LLM SOTA en précision complète. [Lire la suite.](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot) DeepSeek-V3.2 Thinking Aider BenchmarksLlama 4 5-shot MMLU Benchmarks {% endhint %} Vous pouvez également consulter des benchmarks d’usage réel réalisés par Benjamin Marie pour LiveCodeBench v6, MMLU Pro, etc. :
Vous pouvez voir comment les GGUF d’Unsloth obtiennent de meilleurs résultats que les quantifications non-Unsloth malgré une taille d’environ 8 Go plus petite. Analyse détaillée de nos benchmarks et de l’évaluation plus bas. ### 💡 Quoi de neuf dans Dynamic v2.0 ? * **Sélection des couches remaniée pour les GGUF + safetensors :** Unsloth Dynamic 2.0 quantifie désormais de manière beaucoup plus intelligente et plus étendue les couches de façon sélective. Plutôt que de modifier uniquement certaines couches, nous ajustons désormais dynamiquement le type de quantification de chaque couche possible, et les combinaisons différeront pour chaque couche et chaque modèle. * Les GGUF actuellement sélectionnés et tous les futurs téléchargements utiliseront Dynamic 2.0 et notre nouveau jeu de données de calibration. Le jeu de données contient plus de >1,5 M **tokens** (selon le modèle) et se compose de données de haute qualité, sélectionnées et nettoyées à la main — afin d’améliorer considérablement les performances des conversations de chat. * Auparavant, notre quantification dynamique (GGUF DeepSeek-R1 1,58 bit) n’était efficace que pour les architectures MoE. **La quantification Dynamic 2.0 fonctionne désormais sur tous les modèles (y compris les MOE et les non-MOE)**. * **Quantifications spécifiques au modèle :** Chaque modèle utilise désormais un schéma de quantification sur mesure. Par exemple, les couches quantifiées dans Gemma 3 diffèrent sensiblement de celles de Llama 4. * Pour maximiser l’efficacité, en particulier sur Apple Silicon et les appareils ARM, nous ajoutons désormais également les formats Q4\_NL, Q5.1, Q5.0, Q4.1 et Q4.0. Pour garantir un benchmarking précis, nous avons créé un cadre d’évaluation interne afin de faire correspondre les scores MMLU 5 tirs officiellement rapportés de Llama 4 et Gemma 3. Cela a permis des comparaisons équitables entre pleine précision vs. Dynamic v2.0, **QAT** et les quantifications GGUF standard **imatrix** .
Tous les futurs téléchargements GGUF utiliseront Unsloth Dynamic 2.0, et nos quantifications safetensor dynamiques 4 bits en bénéficieront également à l’avenir. ## 📊 Pourquoi la divergence KL ? [La précision n’est pas tout ce qu’il vous faut](https://arxiv.org/pdf/2407.09141) montre comment l’élagage des couches, même en sélectionnant celles qui sont inutiles, entraîne encore de vastes différences en termes de « flips ». Un « flip » est défini comme un changement de réponse, d’incorrecte à correcte ou inversement. L’article montre que le score MMLU peut ne pas diminuer lorsque nous élaguons des couches ou effectuons une quantification, mais c’est parce que certaines réponses incorrectes peuvent avoir « basculé » pour devenir correctes. Notre objectif est de reproduire le modèle d’origine, donc mesurer les « flips » est une bonne métrique.
{% hint style="info" %} **La divergence KL** devrait être **l’une des références absolues pour signaler les erreurs de quantification** selon l’article de recherche « Accuracy is Not All You Need ». **Utiliser la perplexité est incorrect** car les valeurs des tokens de sortie peuvent s’annuler, nous devons donc utiliser la KLD ou des benchmarks plus difficiles comme [Aider](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot). {% endhint %} L’article montre aussi qu’il est intéressant de noter que la divergence KL est fortement corrélée aux flips, et notre objectif est donc de réduire la divergence KL moyenne tout en augmentant le moins possible l’espace disque de la quantification. ## ⚖️ Surapprentissage du jeu de données de calibration La plupart des frameworks rapportent la perplexité et la divergence KL en utilisant un ensemble de test d’articles Wikipédia. Cependant, nous avons remarqué que l’utilisation du jeu de données de calibration, qui est également lié à Wikipédia, entraîne un surapprentissage des quantifications et l’obtention de scores de perplexité plus faibles. Nous utilisons [Calibration\_v3](https://gist.github.com/bartowski1182/eb213dccb3571f863da82e99418f81e8) et [Calibration\_v5](https://gist.github.com/tristandruyen/9e207a95c7d75ddf37525d353e00659c/) comme jeux de données pour des tests équitables, qui incluent notamment certaines données wikitext parmi d’autres données. **De plus, les modèles instruct ont des modèles de chat uniques, et l’utilisation de jeux de données de calibration textuels seuls n’est pas efficace pour les modèles instruct** (les modèles de base, oui). En fait, la plupart des GGUF imatrix sont généralement calibrés avec ces problèmes. Par conséquent, ils obtiennent naturellement de meilleurs résultats sur les benchmarks de divergence KL qui utilisent également des données Wikipédia, puisque le modèle est essentiellement optimisé pour ce domaine. Pour garantir une évaluation équitable et contrôlée, nous n’utilisons pas notre propre jeu de données de calibration (qui est optimisé pour les performances de chat) lors de l’évaluation de la divergence KL. À la place, nous avons effectué des tests avec les mêmes jeux de données Wikipédia standard, ce qui nous a permis de comparer directement les performances de notre méthode Dynamic 2.0 à l’approche imatrix de base. ## :1234: L’aventure de réplication de MMLU * Reproduire le MMLU 5 tirs était cauchemardesque. Nous **n’avons pas pu** reproduire les résultats MMLU pour de nombreux modèles, y compris Llama 3.1 (8B) Instruct, Gemma 3 (12B) et d’autres, en raison de **problèmes subtils d’implémentation**. Par exemple, Llama 3.1 (8B) devrait obtenir environ 68,2 %, alors qu’en utilisant des implémentations incorrectes on peut atteindre **35 % de précision.**

Problèmes d’implémentation de MMLU

* Llama 3.1 (8B) Instruct a une précision MMLU 5 tirs de 67,8 % avec une implémentation MMLU naïve. Nous constatons cependant que Llama **tokenise « A » et « \_A » (A avec un espace devant) comme des ids de tokens différents**. Si nous considérons à la fois les tokens avec et sans espace, nous obtenons 68,2 % (+0.4%) * Il est intéressant de noter que Llama 3, selon [LLM Harness](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/lm_eval/tasks/llama3/instruct/mmlu/_continuation_template_yaml) d’Eleuther AI, ajoute aussi **« La meilleure réponse est »** à la question, conformément aux benchmarks MMLU originaux de Llama 3. * Il existe de nombreux autres problèmes subtils, et afin de tout benchmarker dans un environnement contrôlé, nous avons conçu notre propre implémentation de MMLU à partir de zéro en examinant [github.com/hendrycks/test](https://github.com/hendrycks/test) directement, et avons vérifié nos résultats sur plusieurs modèles en les comparant aux chiffres rapportés. ## :sparkles: Réplication QAT de Gemma 3, benchmarks L’équipe Gemma a publié deux versions QAT (quantization aware training) de Gemma 3 : 1. GGUF Q4\_0 - quantifie toutes les couches en Q4\_0 via la formule `w = q * block_scale` avec chaque bloc contenant 32 poids. Voir [le wiki llama.cpp ](https://github.com/ggml-org/llama.cpp/wiki/Tensor-Encoding-Schemes)pour plus de détails. 2. version int4 - vraisemblablement [style TorchAO int4](https://github.com/pytorch/ao/blob/main/torchao/quantization/README.md)? Nous avons benchmarké toutes les versions GGUF Q4\_0 et mené des expériences approfondies sur le modèle 12B. Nous constatons que le **modèle QAT 12B Q4\_0 obtient 67,07 %** tandis que la version bfloat16 complète 12B obtient 67,15 % en MMLU 5 tirs. C’est très impressionnant ! Le modèle 27B est presque au même niveau !
Métrique1B4B12B27B
MMLU 5 tirs26.12%55.13%67,07 % (67,15 % BF16)70,64 % (71,5 % BF16)
Espace disque0,93 Go2,94 Go7,52 Go16,05 Go
Efficacité*1.2010.265.592.84
Nous avons conçu une nouvelle **métrique d’efficacité** qui calcule l’utilité du modèle tout en tenant compte de sa taille sur disque et de son score MMLU 5 tirs : $$ \text{Efficiency} = \frac{\text{MMLU 5 shot score} - 25}{\text{Disk Space GB}} $$ {% hint style="warning" %} Nous devons **moins 25** puisque MMLU propose 4 choix multiples — A, B, C ou D. Supposons que nous fabriquions un modèle qui choisit simplement des réponses au hasard — il obtiendra 25 % de précision, et n’occupera que quelques octets sur disque. Mais ce n’est clairement pas un modèle utile. {% endhint %} Concernant la divergence KL par rapport au modèle de base, voici un tableau montrant les améliorations. Rappel : plus la divergence KL est proche de 0, mieux c’est (c’est-à-dire 0 signifie identique au modèle en pleine précision) | Quant | KLD de base | Go | Nouvelle KLD | Go | | --------- | ----------- | ----- | ------------ | ----- | | IQ1\_S | 1.035688 | 5.83 | 0.972932 | 6.06 | | IQ1\_M | 0.832252 | 6.33 | 0.800049 | 6.51 | | IQ2\_XXS | 0.535764 | 7.16 | 0.521039 | 7.31 | | IQ2\_M | 0.26554 | 8.84 | 0.258192 | 8.96 | | Q2\_K\_XL | 0.229671 | 9.78 | 0.220937 | 9.95 | | Q3\_K\_XL | 0.087845 | 12.51 | 0.080617 | 12.76 | | Q4\_K\_XL | 0.024916 | 15.41 | 0.023701 | 15.64 | Si nous traçons le rapport entre l’augmentation de l’espace disque et la variation du ratio de divergence KL, nous pouvons voir un avantage beaucoup plus clair ! Notre Q2\_K\_XL dynamique 2 bits réduit assez nettement la KLD (d’environ 7,5 %).
Tableau tronqué des résultats MMLU pour Gemma 3 (27B). Voir ci-dessous. 1. **Notre version dynamique 4 bits est 2 Go plus petite tout en ayant +1 % de précision supplémentaire par rapport à la version QAT !** 2. Du point de vue de l’efficacité, les versions 2 bits Q2\_K\_XL et autres semblent très bien fonctionner ! | Quant | Unsloth | Unsloth + QAT | Taille disque | Efficacité | | -------------- | --------- | ------------- | ------------- | ---------- | | IQ1\_M | 48.10 | 47.23 | 6.51 | 3.42 | | IQ2\_XXS | 59.20 | 56.57 | 7.31 | 4.32 | | IQ2\_M | 66.47 | 64.47 | 8.96 | 4.40 | | Q2\_K\_XL | 68.70 | 67.77 | 9.95 | 4.30 | | Q3\_K\_XL | 70.87 | 69.50 | 12.76 | 3.49 | | **Q4\_K\_XL** | **71.47** | **71.07** | **15.64** | **2.94** | | **Google QAT** | | **70.64** | **17.2** | **2.65** |
Cliquez ici pour les benchmarks complets QAT de Google Gemma 3 (27B) : | Modèle | Unsloth | Unsloth + QAT | Taille disque | Efficacité | | -------------- | --------- | ------------- | ------------- | ---------- | | IQ1\_S | 41.87 | 43.37 | 6.06 | 3.03 | | IQ1\_M | 48.10 | 47.23 | 6.51 | 3.42 | | IQ2\_XXS | 59.20 | 56.57 | 7.31 | 4.32 | | IQ2\_M | 66.47 | 64.47 | 8.96 | 4.40 | | Q2\_K | 68.50 | 67.60 | 9.78 | 4.35 | | Q2\_K\_XL | 68.70 | 67.77 | 9.95 | 4.30 | | IQ3\_XXS | 68.27 | 67.07 | 10.07 | 4.18 | | Q3\_K\_M | 70.70 | 69.77 | 12.51 | 3.58 | | Q3\_K\_XL | 70.87 | 69.50 | 12.76 | 3.49 | | Q4\_K\_M | 71.23 | 71.00 | 15.41 | 2.98 | | **Q4\_K\_XL** | **71.47** | **71.07** | **15.64** | **2.94** | | Q5\_K\_M | 71.77 | 71.23 | 17.95 | 2.58 | | Q6\_K | 71.87 | 71.60 | 20.64 | 2.26 | | Q8\_0 | 71.60 | 71.53 | 26.74 | 1.74 | | **Google QAT** | | **70.64** | **17.2** | **2.65** |
## :llama: Corrections de bugs + exécution de Llama 4 Nous avons également aidé et corrigé quelques bugs de Llama 4 : * Llama 4 Scout a modifié la configuration RoPE Scaling dans leur dépôt officiel. Nous avons aidé à résoudre des problèmes dans llama.cpp pour permettre ce [changement ici](https://github.com/ggml-org/llama.cpp/pull/12889)
* l’epsilon du QK Norm de Llama 4 pour Scout et Maverick devrait provenir du fichier de configuration — cela signifie utiliser 1e-05 et non 1e-06. Nous avons aidé à résoudre cela dans [llama.cpp](https://github.com/ggml-org/llama.cpp/pull/12889) et [transformers](https://github.com/huggingface/transformers/pull/37418) * L’équipe Llama 4 et vLLM ont également corrigé indépendamment un problème où QK Norm était partagé entre toutes les têtes (ce qui ne devrait pas être le cas) [ici](https://github.com/vllm-project/vllm/pull/16311). La précision MMLU Pro est passée de 68,58 % à 71,53 %. * [Wolfram Ravenwolf](https://x.com/WolframRvnwlf/status/1909735579564331016) a montré comment nos GGUF via llama.cpp atteignent une précision bien supérieure à celle des fournisseurs d’inférence tiers — cela était très probablement dû à une combinaison des problèmes expliqués ci-dessus, et probablement aussi à des problèmes de quantification.
Comme montré dans notre graphique, notre quantification QAT dynamique 4 bits offre de meilleures performances sur le MMLU 5 tirs tout en étant plus compacte. ### Exécution de Llama 4 Scout : Pour exécuter Llama 4 Scout par exemple, commencez par cloner llama.cpp : ```bash 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 -DLLAMA_CURL=ON cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split cp llama.cpp/build/bin/llama-* llama.cpp ``` Puis téléchargez notre nouvelle quantification dynamique v 2.0 pour Scout : ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1" from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF", local_dir = "unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF", allow_patterns = ["*IQ2_XXS*"], ) ``` Et maintenant, faisons l’inférence ! {% code overflow="wrap" %} ```bash ./llama.cpp/llama-cli \ --model unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF/Llama-4-Scout-17B-16E-Instruct-UD-IQ2_XXS.gguf \ --threads 32 \ --ctx-size 16384 \ --n-gpu-layers 99 \ -ot ".ffn_.*_exps.=CPU" \ --seed 3407 \ --prio 3 \ --temp 0.6 \ --min-p 0.01 \ --top-p 0.9 \ -no-cnv \ --prompt "<|header_start|>user<|header_end|>\n\nCréez un jeu Flappy Bird.<|eot|><|header_start|>assistant<|header_end|>\n\n" ``` {% endcode %} {% hint style="success" %} En savoir plus sur l’exécution de Llama 4 ici : {% endhint %}