# Enregistrement en GGUF

{% tabs %}
{% tab title="Localement" %}
Pour sauvegarder en GGUF, utilisez ce qui suit pour sauvegarder localement :

```python
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")
```

Pour pousser vers le hub Hugging Face :

```python
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")
```

Toutes les options de quantification prises en charge pour `quantization_method` sont listées ci-dessous :

```python
# https://github.com/ggml-org/llama.cpp/blob/master/examples/quantize/quantize.cpp#L19
ALLOWED_QUANTS = \
{
    "not_quantized"  : "Recommandé. Conversion rapide. Inférence lente, fichiers volumineux.",
    "fast_quantized" : "Recommandé. Conversion rapide. Inférence correcte, taille de fichier correcte.",
    "quantized"      : "Recommandé. Conversion lente. Inférence rapide, fichiers petits.",
    "f32"     : "Non recommandé. Conserve 100 % de précision, mais très lent et gourmand en mémoire.",
    "f16"     : "Conversion la plus rapide + conserve 100 % de précision. Lent et gourmand en mémoire.",
    "q8_0"    : "Conversion rapide. Utilisation élevée des ressources, mais généralement acceptable.",
    "q4_k_m"  : "Recommandé. Utilise Q6_K pour la moitié des tenseurs attention.wv et feed_forward.w2, sinon Q4_K",
    "q5_k_m"  : "Recommandé. Utilise Q6_K pour la moitié des tenseurs attention.wv et feed_forward.w2, sinon Q5_K",
    "q2_k"    : "Utilise Q4_K pour les tenseurs attention.vw et feed_forward.w2, Q2_K pour les autres tenseurs.",
    "q3_k_l"  : "Utilise Q5_K pour les tenseurs attention.wv, attention.wo et feed_forward.w2, sinon Q3_K",
    "q3_k_m"  : "Utilise Q4_K pour les tenseurs attention.wv, attention.wo et feed_forward.w2, sinon Q3_K",
    "q3_k_s"  : "Utilise Q3_K pour tous les tenseurs",
    "q4_0"    : "Méthode de quantification originale, 4 bits.",
    "q4_1"    : "Précision supérieure à q4_0 mais pas aussi élevée que q5_0. Cependant, inférence plus rapide que les modèles q5.",
    "q4_k_s"  : "Utilise Q4_K pour tous les tenseurs",
    "q4_k"    : "alias pour q4_k_m",
    "q5_k"    : "alias pour q5_k_m",
    "q5_0"    : "Précision supérieure, utilisation des ressources plus élevée et inférence plus lente.",
    "q5_1"    : "Précision encore plus élevée, utilisation des ressources et inférence plus lentes.",
    "q5_k_s"  : "Utilise Q5_K pour tous les tenseurs",
    "q6_k"    : "Utilise Q8_K pour tous les tenseurs",
    "iq2_xxs" : "Quantification 2.06 bpw",
    "iq2_xs"  : "Quantification 2.31 bpw",
    "iq3_xxs" : "Quantification 3.06 bpw",
    "q3_k_xs" : "Quantification 3 bits extra petite",
}
```

{% endtab %}

{% tab title="Sauvegarde manuelle" %}
Sauvegardez d'abord votre modèle en 16 bits :

```python
model.save_pretrained_merged("merged_model", tokenizer, save_method = "merged_16bit",)
```

Ensuite, utilisez le terminal et faites :

{% code overflow="wrap" %}

```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-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

python llama.cpp/convert-hf-to-gguf.py FOLDER --outfile OUTPUT --outtype f16
```

{% endcode %}

Ou suivez les étapes sur <https://rentry.org/llama-cpp-conversions#merging-loras-into-a-model> en utilisant le nom de modèle "merged\_model" pour fusionner en GGUF.
{% endtab %}
{% endtabs %}

### L'exécution dans Unsloth fonctionne bien, mais après exportation et exécution sur d'autres plateformes, les résultats sont médiocres

Vous pouvez parfois rencontrer un problème où votre modèle fonctionne et produit de bons résultats sur Unsloth, mais lorsque vous l'utilisez sur une autre plateforme comme Ollama ou vLLM, les résultats sont médiocres ou vous obtenez des charabias, des générations infinies/sans fin *ou* sorties répétée&#x73;**.**

* La cause la plus fréquente de cette erreur est l'utilisation d'un <mark style="background-color:blue;">**modèle de chat incorrect**</mark>**.** Il est essentiel d'utiliser LE MÊME modèle de chat qui a été utilisé lors de l'entraînement du modèle dans Unsloth et plus tard lorsque vous l'exécutez dans un autre framework, tel que llama.cpp ou Ollama. Lors de l'inférence à partir d'un modèle sauvegardé, il est crucial d'appliquer le bon modèle.
* Vous devez utiliser le bon `jeton eos`. Sinon, vous pourriez obtenir du charabia lors de générations longues.
* Cela peut aussi être dû au fait que votre moteur d'inférence ajoute un jeton "début de séquence" inutile (ou au contraire l'absence de celui-ci), assurez-vous donc de vérifier les deux hypothèses !
* <mark style="background-color:green;">**Utilisez nos notebooks conversationnels pour forcer le modèle de chat - cela corrigera la plupart des problèmes.**</mark>
  * Notebook conversationnel Qwen-3 14B [**Ouvrir dans Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb)
  * Notebook conversationnel Gemma-3 4B [**Ouvrir dans Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\).ipynb)
  * Notebook conversationnel Llama-3.2 3B [**Ouvrir dans Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_\(1B_and_3B\)-Conversational.ipynb)
  * Notebook conversationnel Phi-4 14B [**Ouvrir dans Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Phi_4-Conversational.ipynb)
  * Notebook conversationnel Mistral v0.3 7B [**Ouvrir dans Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Mistral_v0.3_\(7B\)-Conversational.ipynb)
  * **Plus de notebooks dans notre** [**documentation des notebooks**](https://unsloth.ai/docs/fr/commencer/unsloth-notebooks)

### La sauvegarde en GGUF / vLLM 16 bits plante

Vous pouvez essayer de réduire l'utilisation maximale du GPU pendant la sauvegarde en modifiant `maximum_memory_usage`.

La valeur par défaut est `model.save_pretrained(..., maximum_memory_usage = 0.75)`. Réduisez-la à, par exemple, 0.5 pour utiliser 50 % de la mémoire GPU maximale ou moins. Cela peut réduire les crashs OOM lors de la sauvegarde.

### Comment sauvegarder manuellement en GGUF ?

Sauvegardez d'abord votre modèle en 16 bits via :

```python
model.save_pretrained_merged("merged_model", tokenizer, save_method = "merged_16bit",)
```

Compilez llama.cpp à partir des sources comme ci-dessous :

{% code overflow="wrap" %}

```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-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

{% endcode %}

Ensuite, sauvegardez le modèle en F16 :

```bash
python llama.cpp/convert_hf_to_gguf.py merged_model \
    --outfile model-F16.gguf --outtype f16 \
    --split-max-size 50G
```

```bash
# Pour BF16 :
python llama.cpp/convert_hf_to_gguf.py merged_model \
    --outfile model-BF16.gguf --outtype bf16 \
    --split-max-size 50G
    
# Pour Q8_0 :
python llama.cpp/convert_hf_to_gguf.py merged_model \
    --outfile model-Q8_0.gguf --outtype q8_0 \
    --split-max-size 50G
```