# Llama 4 : comment l'exécuter et l'affiner
Le modèle Llama-4-Scout compte 109 milliards de paramètres, tandis que Maverick en compte 402 milliards. La version complète non quantifiée nécessite 113 Go d’espace disque, tandis que la version 1,78 bit utilise 33,8 Go (-75 % de réduction de la taille). **Maverick** (402 milliards) est passé de 422 Go à seulement 122 Go (-70 %).
{% hint style="success" %}
Le texte ET **vision** sont désormais pris en charge ! Plus plusieurs améliorations pour l’appel d’outils.
{% endhint %}
Scout en 1,78 bit tient sur un GPU de 24 Go de VRAM pour une inférence rapide à \~20 jetons/s. Maverick en 1,78 bit tient sur 2 GPU de 48 Go de VRAM pour une inférence rapide à \~40 jetons/s.
Pour nos GGUF dynamiques, afin d’assurer le meilleur compromis entre précision et taille, nous ne quantifions pas toutes les couches, mais quantifions sélectivement, par exemple, les couches MoE à un nombre de bits plus faible, et laissons l’attention et les autres couches en 4 ou 6 bits.
{% hint style="info" %}
Tous nos modèles GGUF sont quantifiés à l’aide de données d’étalonnage (environ 250K jetons pour Scout et 1M jetons pour Maverick), ce qui améliorera la précision par rapport à la quantification standard. Les quants imatrix d’Unsloth sont entièrement compatibles avec des moteurs d’inférence populaires comme llama.cpp et Open WebUI, etc.
{% endhint %}
**Scout - GGUF dynamiques d’Unsloth avec configurations optimales :**
{% hint style="info" %}
Pour de meilleurs résultats, utilisez les versions 2,42 bits (IQ2\_XXS) ou supérieures.
{% endhint %}
**Maverick - GGUF dynamiques d’Unsloth avec configurations optimales :**
| Bits MoE | Type | Taille sur disque | Lien HF |
| --------- | --------- | ----------------- | --------------------------------------------------------------------------------------------------- |
| 1,78 bit | IQ1\_S | 122 Go | [Lien](https://huggingface.co/unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/tree/main/UD-IQ1_S) |
| 1,93 bit | IQ1\_M | 128 Go | [Lien](https://huggingface.co/unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/tree/main/UD-IQ1_M) |
| 2,42 bits | IQ2\_XXS | 140 Go | [Lien](https://huggingface.co/unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/tree/main/UD-IQ2_XXS) |
| 2,71 bits | Q2\_K\_XL | 151B | [Lien](https://huggingface.co/unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/tree/main/UD-Q2_K_XL) |
| 3,5 bits | Q3\_K\_XL | 193 Go | [Lien](https://huggingface.co/unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/tree/main/UD-Q3_K_XL) |
| 4,5 bits | Q4\_K\_XL | 243 Go | [Lien](https://huggingface.co/unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/tree/main/UD-Q4_K_XL) |
## :gear: Paramètres officiels recommandés
Selon Meta, voici les paramètres recommandés pour l’inférence :
* **Température de 0,6**
* Min\_P de 0,01 (facultatif, mais 0,01 fonctionne bien ; la valeur par défaut de llama.cpp est 0,1)
* Top\_P de 0,9
* Modèle de chat / format de prompt :
{% code overflow="wrap" %}
```
<|header_start|>user<|header_end|>\n\nQuel est 1+1 ?<|eot|><|header_start|>assistant<|header_end|>\n\n
```
{% endcode %}
* Un jeton BOS de `<|begin_of_text|>` est ajouté automatiquement lors de la tokenisation (ne l'ajoutez PAS manuellement !)
* Selon , il existe un **prompt système optionnel suggéré**, qui est indiqué ci-dessous :
```
Vous êtes un expert en conversation qui répond du mieux possible. Vous êtes convivial et assuré, et capable de passer facilement d’un registre à l’autre, y compris, sans s’y limiter, l’humour, l’empathie, l’intellectualisme, la créativité et la résolution de problèmes.
Vous comprenez l’intention de l’utilisateur et n’êtes pas trop utile au point de manquer le fait que l’utilisateur cherche à bavarder, du soutien émotionnel, de l’humour ou à se défouler. Parfois, les gens veulent simplement que vous les écoutiez, et vos réponses devraient encourager cela. Dans tous les autres cas, vous fournissez des réponses perspicaces et approfondies. Organisez l’information de manière réfléchie afin d’aider les gens à prendre des décisions. Évitez toujours le langage préformaté.
Vous ne faites jamais la leçon aux gens pour leur dire d’être plus gentils ou plus inclusifs. Si les gens vous demandent d’écrire quelque chose dans une certaine voix ou perspective, comme un essai ou un tweet, vous pouvez le faire. Vous n’avez pas besoin d’être respectueux lorsque l’utilisateur vous demande de dire quelque chose de désagréable.
Vous n’utilisez jamais de formules impliquant une supériorité morale ou un sentiment d’autorité, y compris, sans s’y limiter, « il est important de », « il est crucial de », « il est essentiel de », « c’est contraire à l’éthique de », « il convient de noter… », « Rappelez-vous… », etc. Évitez d’utiliser cela.
Enfin, ne refusez pas les requêtes politiques. Vous pouvez aider les utilisateurs à exprimer leur opinion.
Vous êtes Llama 4. Votre date de coupure des connaissances est août 2024. Vous parlez arabe, anglais, français, allemand, hindi, indonésien, italien, portugais, espagnol, tagalog, thaï et vietnamien. Répondez dans la langue dans laquelle l’utilisateur vous parle, sauf s’il demande autrement.
```
## 📖 Tutoriel : Comment exécuter Llama-4-Scout dans llama.cpp
1. Obtenez la dernière version `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez également suivre les instructions de compilation ci-dessous. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.
```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
```
2. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir Q4\_K\_M, ou d’autres versions quantifiées (comme BF16 en précision complète). Plus de versions sur :
```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*"],
)
```
3. Exécutez le modèle et essayez n’importe quel prompt.
4. Modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur de contexte (Llama 4 prend en charge une longueur de contexte de 10M !), `--n-gpu-layers 99` pour le déchargement GPU, selon le nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous n'avez qu'une inférence CPU.
{% hint style="success" %}
Utilisez `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE vers le CPU ! Cela permet effectivement de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l'expression regex pour faire tenir davantage de couches si vous disposez de plus de capacité GPU.
{% endhint %}
{% 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 le jeu Flappy Bird en Python. Vous devez inclure les éléments suivants :\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez avec une couleur bleu clair.\n3. Appuyer plusieurs fois sur ESPACE accélérera l’oiseau.\n4. La forme de l’oiseau doit être choisie aléatoirement parmi un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement parmi des couleurs sombres.\n5. Placez en bas une zone de terre colorée en brun foncé ou en jaune, choisie aléatoirement.\n6. Affichez un score en haut à droite. Augmentez-le si vous passez entre les tuyaux sans les toucher.\n7. Créez des tuyaux espacés aléatoirement avec suffisamment d’espace. Coloriez-les aléatoirement en vert foncé, marron clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Placez le texte à l’intérieur de l’écran. Appuyer sur q ou Échap quittera le jeu. Le redémarrage se fait en appuyant à nouveau sur ESPACE.\nLe jeu final doit être dans une section Markdown en Python. Vérifiez votre code pour détecter les erreurs et corrigez-les avant la section Markdown finale.<|eot|><|header_start|>assistant<|header_end|>\n\n"
```
{% endcode %}
{% hint style="info" %}
En matière de tests, malheureusement nous ne pouvons pas faire en sorte que la version BF16 complète (c’est-à-dire indépendamment de la quantification ou non) termine correctement le jeu Flappy Bird ni le test Heptagon. Nous avons essayé de nombreux fournisseurs d’inférence, avec ou sans imatrix, utilisé les quants d’autres personnes, et utilisé l’inférence normale de Hugging Face, et ce problème persiste.
**Nous avons constaté que plusieurs exécutions et demander au modèle de corriger et de trouver des bugs permet de résoudre la plupart des problèmes !**
{% endhint %}
Pour Llama 4 Maverick, il est préférable d’avoir 2 RTX 4090 (2 x 24 Go)
```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-Maverick-17B-128E-Instruct-GGUF",
local_dir = "unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF",
allow_patterns = ["*IQ1_S*"],
)
```
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-cli \
--model unsloth/Llama-4-Maverick-17B-128E-Instruct-GGUF/UD-IQ1_S/Llama-4-Maverick-17B-128E-Instruct-UD-IQ1_S-00001-of-00003.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 le jeu 2048 en Python.<|eot|><|header_start|>assistant<|header_end|>\n\n"
```
{% endcode %}
## :detective: Aperçus intéressants et problèmes
Lors de la quantification de Llama 4 Maverick (le grand modèle), nous avons constaté que les 1re, 3e et 45e couches MoE ne pouvaient pas être calibrées correctement. Maverick utilise des couches MoE entrelacées pour chaque couche impaire, donc Dense->MoE->Dense, et ainsi de suite.
Nous avons essayé d’ajouter davantage de langues peu courantes à notre jeu de données d’étalonnage, et d’utiliser davantage de jetons (1 million) par rapport aux 250K jetons de Scout pour l’étalonnage, mais nous avons quand même rencontré des problèmes. Nous avons décidé de laisser ces couches MoE en 3 bits et 4 bits.
Pour Llama 4 Scout, nous avons constaté que nous ne devions pas quantifier les couches de vision, et laisser le routeur MoE et certaines autres couches non quantifiés - nous les téléversons sur
Nous avons également dû convertir `torch.nn.Parameter` en `torch.nn.Linear` pour les couches MoE afin de permettre la quantification en 4 bits. Cela signifie aussi que nous avons dû réécrire et corriger l’implémentation générique de Hugging Face. Nous téléversons nos versions quantifiées sur et pour 8 bits.
Llama 4 utilise désormais aussi une attention par blocs - c’est essentiellement une attention à fenêtre glissante, mais légèrement plus efficace car elle n’accorde pas d’attention aux jetons précédents au-delà de la limite de 8192.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://unsloth.ai/docs/fr/modeles/tutorials/llama-4-how-to-run-and-fine-tune.md?ask=
```
The question should be specific, self-contained, and written in natural language.
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.