Sauvegarde en GGUF

Sauvegarder des modèles en 16 bits pour GGUF afin de pouvoir les utiliser avec Ollama, Jan AI, Open WebUI et plus encore !

Localement

Pour sauvegarder en GGUF, utilisez ce qui suit pour enregistrer localement :

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 :

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 :

# 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, petits fichiers.",
    "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, l'inférence est plus rapide que les modèles q5.",
    "q4_k_s"  : "Utilise Q4_K pour tous les tenseurs",
    "q4_k"    : "alias de q4_k_m",
    "q5_k"    : "alias de q5_k_m",
    "q5_0"    : "Précision plus élevée, utilisation des ressources plus importante 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 small",
}

Sauvegarde manuelle

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

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 pouvez obtenir du charabia, des générations infinies/sans fin ou sorties répétées.

• La cause la plus courante de cette erreur est l'utilisation d'un modèle de chat incorrect. 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 également être dû au fait que votre moteur d'inférence ajoute un jeton « début de séquence » inutile (ou à l'inverse l'absence de celui-ci), alors assurez-vous de vérifier les deux hypothèses !

• Utilisez nos notebooks conversationnels pour forcer le modèle de chat - cela corrigera la plupart des problèmes.

  • Carnet conversationnel Qwen-3 14B Ouvrir dans Colab

  • Carnet conversationnel Gemma-3 4B Ouvrir dans Colab

  • Carnet conversationnel Llama-3.2 3B Ouvrir dans Colab

  • Carnet conversationnel Phi-4 14B Ouvrir dans Colab

  • Carnet conversationnel Mistral v0.3 7B Ouvrir dans Colab

  • Plus de notebooks dans notre documentation des notebooks

Sauvegarder en GGUF / vLLM 16 bits plante

Vous pouvez essayer de réduire l'utilisation maximale du GPU lors de 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 plantages OOM pendant la sauvegarde.

Comment sauvegarder manuellement en GGUF ?

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

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

Compilez llama.cpp depuis les sources comme ci-dessous :

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

Ensuite, enregistrez le modèle en F16 :

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

# 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