> 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/notions-de-base/dynamic-3.0-ggufs.md). # GGUF dynamiques 3.0 d'Unsloth [**Unsloth**](https://github.com/unslothai/unsloth) **Dynamic v3.0** est la prochaine itération de notre quantification Dynamic et une amélioration majeure par rapport à Dynamic v2.0. Aujourd’hui, nous lançons [**Qwen3.8-27B**](/docs/fr/modeles/qwen3.8.md) des quants Dynamic v3.0 qui offrent **>10 % de précision top-1 en plus à taille égale** comparé à **tous les autres fournisseurs**. Il s’agit d’une mise à jour de notre premier **aperçu anticipé** version de Dynamic v3.0. Les nouveaux GGUF 3.0 fonctionnent avec la plupart des moteurs d’inférence, y compris **llama.cpp** et [**Unsloth Desktop**](/docs/fr/desktop.md). {% columns %} {% column width="41.66666666666667%" %} Dynamic v3.0 préserve globalement davantage la qualité du modèle tout en conservant la même taille, avec de meilleurs résultats sur des métriques comme **Divergence-300** @32 et **divergence KL**. Un immense merci aussi pour tout votre soutien ! Nous avons dépassé 5,1 millions de téléchargements d’Unsloth Qwen3.8 en seulement 5 jours ! {% endcolumn %} {% column width="58.33333333333333%" %}

Voir ci-dessous pour plus de graphiques/benchmarks et d’analyses

{% endcolumn %} {% endcolumns %} Notre nouvelle méthodologie se compose de nombreuses nouvelles fonctionnalités et améliorations. Nous utilisons désormais un jeu de données d’étalonnage imatrix de bien meilleure qualité, provenant de sources diverses. Le jeu de données est affiné pour **le codage agentique, le chat**, ainsi que les performances multilingues. Nous avons également amélioré **la sélection des couches** et introduit bien plus de techniques de quantification pour préserver autant que possible la qualité du modèle. Nous **n’entraînons pas sur le jeu de données d’étalonnage imatrix**, et nous n’utilisons PAS **QAT** ou **QAD**. Tout est fait via **quantification post-entraînement**. Le fichier imatrix que nous utilisons est disponible pour que la communauté le teste, l’évalue et l’utilise. Nous encourageons les chercheurs et les développeurs à créer des variantes et des fine-tunes de Qwen3.8 à l’aide de nos quants/imatrix Unsloth. Vous pouvez lire notre [analyse du surapprentissage](#not-overfitting) également. * Nous avons également supprimé le module MTP des plus petits quants de moins de `UD-Q2_K_XL` (8,37 Go et moins) afin d’économiser environ 500 Mo d’espace disque - vous pouvez utiliser le `Q4_0` module MTP séparé si nécessaire * Nous avons également créé des quants UD-1bit plus petits avec `UD-IQ1_S` à 6,2 Go (sans MTP), qui conservent environ 72 % de précision top-1 tout en étant 89 % plus petits. * `UD-Q2_K_XL` est environ 8 % plus précis en top-1 que le suivant et il fait 9,83 Go, et a réussi à créer un programme HTML fonctionnel avec un petit bug JS — auparavant, il plantait.

### 🔀 Divergence-300 @32 Nous rapportons généralement la précision top-1 comme pour Kimi-K3 « Dynamic 1-bit atteint **\~78.9%** une précision top-1 tout en étant **62 % plus petit**." Cependant, le top-1 est un argmax sur une seule prédiction, donc ce n’est pas vraiment efficace pour évaluer l’inférence réelle. Nous avons créé un jeu de données de 300 exemples mis à l’écart (PAS dans le jeu de données d’étalonnage) à partir de Terminal-Bench 2.1 + DeepSWE + Harbor + MathArena 2025-26 + des invites non latines/de longs documents, et nous avons effectué un décodage argmax glouton sur 32 jetons pour BF16 face à tous les quants et fournisseurs. Voir [analyse du surapprentissage](#not-overfitting) pour plus de détails sur le surapprentissage. Cela nous permet d’évaluer s’il y a surapprentissage et si les sorties quantifiées sont similaires aux trajectoires du BF16 sur plusieurs jetons. C’est une meilleure métrique que la précision top-1, car nous étendons le top-1 KLD pour le rapprocher d’un top-1 KLD sur 32 jetons.

### :question:Le 1-bit ne devrait pas être utilisé pour des cas d’usage agentiques Comme on le voit dans [#divergence-300-32](#divergence-300-32 "mention"), on observe une forte chute de UD-Q2\_K\_XL à UD-IQ2\_S pour la prédiction de 32 jetons, d’environ 25 % de précision à moins de 8-10 %. Cette forte chute signifie que l’appel d’outils et les modes sans réflexion deviennent défaillants. Quelques problèmes et atténuations si vous utilisez le 1-bit : 1. **Bouclage excessif**\ Vous verrez beaucoup de bouclage en utilisant des quants inférieurs à UD-Q2\_K\_XL - utilisez `presence_penalty = 1.5` dans tous les cas (ou plus) 2. **Réponses vides**\ Activez toujours le raisonnement, au moins en mode de raisonnement faible, pour les quants 1-bit - les modes sans raisonnement empêchent de toute façon le modèle de produire quoi que ce soit. 3. **Cas d’usage agentiques et appel d’outils**\ N’utilisez pas le modèle pour l’appel d’outils - seulement **les connaissances générales sont conservées** lorsqu’il est fortement quantifié, et le modèle échouera soit à appeler des outils, soit continuera à les appeler, soit ne les appellera même pas. 4. **Les connaissances générales fonctionnent**\ Une récupération top-1 de 77 % ne remplace pas Divergence-300 @32 à 8 %, qui est un meilleur indicateur des charges de travail d’inférence réelles - vous pouvez utiliser le modèle pour de très courtes questions factuelles de connaissances générales, mais il vaut mieux utiliser UD-Q2\_K\_XL. ### 🔀 Benchmarks de divergence KL Nous avons également exécuté des benchmarks KLD pour tous les fournisseurs et rapportons la moyenne Top-1 et KLD. À tous les niveaux, surtout sur les plus petites tailles de quant, les quants Unsloth UD-3 obtiennent jusqu’à +10 % de précision top-1 supplémentaire à espace disque égal ! Tous les graphiques retirent la tête MTP de l’axe x lors du calcul de l’espace disque afin de fournir une comparaison équitable pour tout le monde.

### :dove:Pas de surapprentissage Lors de la comparaison avec notre ancien UD-2 sur Wikitext et Code inédits, nous montrons une nette amélioration du KLD - pas autant pour les plus gros, donc nous utilisons toujours notre ancien UD-2 pour les plus grands quants - nous prévoyons d’expérimenter et de les améliorer aussi ! Nous contrôlons aussi le surapprentissage en utilisant des jeux de données totalement différents pour l’étalonnage et en supprimant autant que possible toutes les fuites. Nous testons le KLD sur ces jeux de données inédits, et nous ne faisons pas non plus de QAD / QAT, seulement du PTQ pur, donc le surapprentissage est moins préoccupant que pour d’autres approches QAD / QAT.

De même [#divergence-300-32](#divergence-300-32 "mention") utilise un jeu de données inédit de 300 invites issues de DeepSWE, Terminal Bench et d’autres, et sert d’autre jeu de données pour évaluer le surapprentissage - et montre que nos nouvelles méthodes UD-3 ne surapprentissent pas. *** ## Dynamic v2.0 (ancien) Nous introduisons [Unsloth](https://github.com/unslothai/unsloth) la quantification Dynamic v2.0 - une amélioration majeure de nos quants précédents. Cette nouvelle méthode surpasse les principales méthodes de quantification et établit de nouveaux repères pour [Aider Polyglot](/docs/fr/notions-de-base/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md), le MMLU 5 shots et la divergence KL. Cela signifie que vous pouvez désormais exécuter + affiner [des LLM quantifiés](/docs/fr/modeles/tutorials.md) 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](/docs/fr/nouveau/studio.md) etc. {% columns %} {% column %} **Mise à jour du 20 avr. 2026 :** Voir nos nouveaux benchmarks GGUF pour [Qwen3.6](/docs/fr/modeles/qwen3.6.md#unsloth-gguf-benchmarks) et [Gemma 4](/docs/fr/modeles/gemma-4.md#unsloth-gguf-benchmarks). [Mise à jour du 27 févr. 2026 :](/docs/fr/modeles/qwen3.5/gguf-benchmarks.md) **Qwen3.5** est sorti et nous avons corrigé certains problèmes de modèle de chat pour l’appel d’outils et benchmarké chaque GGUF sur la perplexité et la divergence KL. [Voir les benchmarks !](/docs/fr/modeles/qwen3.5/gguf-benchmarks.md) Le **principal avantage** de l’utilisation du [package Unsloth](https://github.com/unslothai/unsloth) et des quants 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 apportant des correctifs qui améliorent la précision. {% endcolumn %} {% column %}

Benchmarks Gemma 4 26B A4B (plus bas est meilleur)

{% endcolumn %} {% endcolumns %} {% hint style="success" %} Les GGUF Dynamic d’Unsloth peuvent désormais être exécutés dans [Unsloth Studio](/docs/fr/nouveau/studio.md) ✨

{% endhint %} {% hint style="success" %} [Mise à jour du 10 sept. 2025 :](/docs/fr/notions-de-base/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md) Vous avez demandé des benchmarks plus difficiles, alors voici les résultats d’Aider Polyglot ! Notre GGUF Dynamic 3-bit DeepSeek V3.1 obtient **75.6%**, surpassant de nombreux LLM SOTA en pleine précision. [En savoir plus.](/docs/fr/notions-de-base/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md) DeepSeek-V3.2 Thinking Aider Benchmarks

{% endhint %} Vous pouvez également consulter des benchmarks de cas d’usage réels menés par Benjamin Marie pour LiveCodeBench v6, MMLU Pro, etc. :

Vous pouvez voir comment les GGUF d’Unsloth donnent de meilleurs résultats que les quants non-Unsloth malgré une taille d’environ 8 Go inférieure. Analyse détaillée de nos benchmarks et de notre évaluation plus bas. ### 💡 Quoi de neuf dans Dynamic v2.0 ? * **Sélection des couches repensée pour les GGUF + safetensors :** Unsloth Dynamic 2.0 quantifie désormais les couches de manière sélective, beaucoup plus intelligemment et de façon plus étendue. Plutôt que de modifier seulement certaines couches, nous ajustons désormais dynamiquement le type de quantification de chaque couche possible, et les combinaisons diffèrent pour chaque couche et chaque modèle. * Les GGUF actuellement sélectionnés et tous les futurs téléversements de GGUF utiliseront Dynamic 2.0 et notre nouveau jeu de données d’étalonnage. Le jeu de données contient plus de >1,5 M **jetons** (selon le modèle) et comprend des données de haute qualité, sélectionnées à la main et nettoyées - afin d’améliorer considérablement les performances de chat conversationnel. * Auparavant, notre quantification Dynamic (GGUF DeepSeek-R1 1,58 bits) 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)**. * **Quants 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 considérablement de celles de Llama 4. * Pour maximiser l’efficacité, notamment sur Apple Silicon et les appareils ARM, nous ajoutons désormais aussi les formats Q4\_NL, Q5.1, Q5.0, Q4.1 et Q4.0. Pour garantir des benchmarks précis, nous avons construit un cadre d’évaluation interne afin d’aligner les scores officiels MMLU 5 shots rapportés pour Llama 4 et Gemma 3. Cela a permis des comparaisons équitables entre pleine précision et Dynamic v2.0, **QAT** et les standards **imatrix** quants GGUF.

Tous les futurs téléversements de GGUF utiliseront Unsloth Dynamic 2.0, et nos quants safetensor Dynamic 4 bits en bénéficieront également à l’avenir. ## 📊 Pourquoi la divergence KL ? [La précision ne fait pas tout](https://arxiv.org/pdf/2407.09141) montre comment l’élagage des couches, même en sélectionnant des couches inutiles, produit malgré tout de vastes différences en termes de « flips ». Un « flip » est défini comme un changement de réponse, de incorrect à correct ou vice versa. L’article montre que le MMLU peut ne pas diminuer lorsque nous élaguons des couches ou effectuons de la quantification, mais c’est parce que certaines réponses incorrectes ont pu « basculer » pour devenir correctes. Notre objectif est de faire correspondre le modèle original, donc mesurer les « flips » est une bonne métrique.

{% hint style="info" %} **divergence KL** devrait être **l’un des standards de référence 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 jetons de sortie peuvent s’annuler, nous devons donc utiliser le KLD ou des benchmarks plus difficiles comme [Aider](/docs/fr/notions-de-base/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md). {% endhint %} L’article montre aussi, de manière intéressante, que la divergence KL est fortement corrélée aux flips ; 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 d’étalonnage La plupart des frameworks rapportent la perplexité et la divergence KL à l’aide d’un jeu de test d’articles Wikipédia. Cependant, nous avons remarqué que l’utilisation du jeu de données d’étalonnage, qui est également lié à Wikipédia, pousse les quants au surapprentissage et leur permet d’obtenir de meilleurs scores de perplexité. Nous utilisons [Calibration\_v3](https://gist.github.com/bartowski1182/eb213dccb3571f863da82e99418f81e8) et [Calibration\_v5](https://gist.github.com/tristandruyen/9e207a95c7d75ddf37525d353e00659c/) des jeux de données pour des tests équitables, comprenant 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 d’étalonnage uniquement textuels 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. En conséquence, ils obtiennent naturellement de meilleurs résultats sur les benchmarks de divergence KL qui utilisent aussi des données Wikipédia, puisque le modèle est essentiellement optimisé pour ce domaine. Pour garantir une évaluation juste et contrôlée, nous n’utilisons pas notre propre jeu de données d’étalonnage (optimisé pour les performances de chat) lors des benchmarks de divergence KL. À la place, nous avons effectué des tests en utilisant les mêmes jeux de données Wikipédia standard, ce qui nous permet de comparer directement les performances de notre méthode Dynamic 2.0 à l’approche imatrix de base. ## :1234: Aventure de réplication du MMLU * La réplication du MMLU 5 shots é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 **subtils problèmes d’implémentation**. Llama 3.1 (8B), par exemple, devrait obtenir \~68,2 %, tandis que des implémentations incorrectes peuvent atteindre **35 % de précision.**

* Llama 3.1 (8B) Instruct a une précision MMLU 5 shots de 67,8 % en utilisant une implémentation MMLU naïve. Nous constatons cependant que Llama **tokenise « A » et « \_A » (A avec un espace devant) comme des identifiants de jeton différents**. Si nous considérons les jetons avec et sans espace, nous obtenons 68,2 % (+0.4%) * Fait intéressant, Llama 3 selon le [LLM Harness](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/lm_eval/tasks/llama3/instruct/mmlu/_continuation_template_yaml) 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 du MMLU à partir de zéro en examinant [github.com/hendrycks/test](https://github.com/hendrycks/test) directement, et nous 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` chaque bloc ayant 32 poids. Voir [wiki llama.cpp ](https://github.com/ggml-org/llama.cpp/wiki/Tensor-Encoding-Schemes)pour plus de détails. 2. version int4 - vraisemblablement [style int4 TorchAO](https://github.com/pytorch/ao/blob/main/torchao/quantization/README.md)? Nous avons benchmarké toutes les versions Q4\_0 GGUF et mené des expériences approfondies sur le modèle 12B. Nous voyons que le **modèle QAT Q4\_0 12B obtient 67,07 %** tandis que la version 12B complète en bfloat16 obtient 67,15 % sur le MMLU 5 shots. C’est très impressionnant ! Le modèle 27B y est presque entièrement !

Métrique	1B	4B	12B	27B
MMLU 5 shots	26.12%	55.13%	67,07 % (67,15 % BF16)	70,64 % (71,5 % BF16)
Espace disque	0,93 Go	2,94 Go	7,52 Go	16,05 Go
Efficacité*	1.20	10.26	5.59	2.84

Nous avons conçu une nouvelle **métrique d’efficacité** qui calcule l’utilité du modèle tout en prenant également en compte sa taille sur disque et son score MMLU 5 shots : $$ \text{Efficiency} = \frac{\text{MMLU 5 shot score} - 25}{\text{Disk Space GB}} $$ {% hint style="warning" %} Nous devons **moins 25** puisque le MMLU a 4 choix multiples - A, B, C ou D. Supposons que nous créions un modèle qui choisit simplement des réponses au hasard - il obtiendra 25 % de précision, et occupera quelques octets sur disque. Mais clairement, ce n’est 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.-à-d. 0 signifie identique au modèle en pleine précision) | Quantification | KLD de base | Go | Nouveau 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 ratio de l’augmentation de l’espace disque et la variation du ratio de divergence KL, nous voyons un avantage beaucoup plus clair ! Notre Q2\_K\_XL dynamique 2 bits réduit le KLD de façon notable (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. En termes d’efficacité, le Q2\_K\_XL 2 bits et les autres semblent très bien s’en sortir ! | Quantification | Unsloth | Unsloth + QAT | Taille sur 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** | | **QAT de Google** | | **70.64** | **17.2** | **2.65** |

Cliquez ici pour les benchmarks QAT complets de Gemma 3 (27B) de Google :

| Modèle | Unsloth | Unsloth + QAT | Taille sur 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 | | **QAT de Google** | | **70.64** | **17.2** | **2.65** |

## :llama: Corrections de bugs Llama 4 + exécution Nous avons également aidé à corriger quelques bugs de Llama 4 : * Llama 4 Scout a modifié la configuration de mise à l’échelle RoPE dans son dépôt officiel. Nous avons aidé à résoudre des problèmes dans llama.cpp pour permettre cela [changement ici](https://github.com/ggml-org/llama.cpp/pull/12889)

* L’epsilon du QK Norm de Llama 4, pour Scout et Maverick, doit 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ù le 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 de 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 - il s’agissait très probablement d’une combinaison des problèmes expliqués ci-dessus, et aussi probablement de problèmes de quantification.

Comme le montre notre graphique, notre quantification Dynamic QAT 4 bits offre de meilleures performances sur le MMLU 5 shots tout en étant plus petite. ### Exécution de Llama 4 Scout : Pour exécuter Llama 4 Scout par exemple, commencez d’abord 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 nouveau quant dynamic 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 allons-y pour 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 %} --- # 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/notions-de-base/dynamic-3.0-ggufs.md?ask=&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.