Enregistrement au format GGUF

Enregistrer les modèles en 16 bits pour GGUF afin que vous puissiez l’utiliser pour Unsloth Studio, Ollama, llama.cpp et plus encore !

En local

Pour enregistrer 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 publier sur 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 सूचीé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, 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. Forte utilisation 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.wv 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 plus élevée que 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 de q4_k_m",
    "q5_k"    : "alias de q5_k_m",
    "q5_0"    : "Précision plus élevée, utilisation plus importante des ressources et inférence plus lente.",
    "q5_1"    : "Précision encore plus élevée, utilisation des ressources et inférence plus lente.",
    "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 extra petite à 3 bits",
}

Enregistrement manuel

Enregistrez d’abord votre modèle en 16 bits :

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

Ensuite, utilisez le terminal et faites :

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

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.

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

Il peut parfois arriver que votre modèle s’exécute et produise de bons résultats dans 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 des sorties répétées.

• La cause la plus courante de cette erreur est l’utilisation d’un mauvais modèle de chat. 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 ensuite 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 enregistré, 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 plus longues.

• Cela peut aussi être dû au fait que votre moteur d’inférence ajoute un jeton de « début de séquence » inutile (ou, à l’inverse, qu’il n’en ajoute pas), alors assurez-vous de vérifier les deux hypothèses !

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

  • Notebook conversationnel Qwen-3 14B Ouvrir dans Colab

  • Notebook conversationnel Gemma-3 4B Ouvrir dans Colab

  • Notebook conversationnel Llama-3.2 3B Ouvrir dans Colab

  • Notebook conversationnel Phi-4 14B Ouvrir dans Colab

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

  • Plus de notebooks dans notre documentation des notebooks

L’enregistrement en GGUF / vLLM 16 bits plante

Vous pouvez essayer de réduire l’utilisation maximale du GPU pendant l’enregistrement 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 % du pic de mémoire du GPU ou moins. Cela peut réduire les plantages OOM pendant l’enregistrement.

Comment enregistrer 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 à partir des 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