⚡Tutoriel : Comment affiner gpt-oss

Installer Unsloth (dans Colab)

Dans Colab, exécutez les cellules du haut vers le bas. Utilisez Exécuter tout pour la première passe. La première cellule installe Unsloth (et les dépendances associées) et affiche les informations GPU/mémoire. Si une cellule renvoie une erreur, réexécutez-la simplement.

Configuration de gpt-oss et de l'Effort de Raisonnement

Nous chargerons gpt-oss-20b en utilisant la version linéarisée (car aucune autre version ne fonctionnera).

Configurez les paramètres suivants :

• max_seq_length = 1024

  • Recommandé pour des tests rapides et des expériences initiales.

• load_in_4bit = True

  • Utilisez False pour l'entraînement LoRA (remarque : définir ceci sur False nécessitera au moins 43 Go de VRAM). Vous DEVEZ également définir model_name = "unsloth/gpt-oss-20b-BF16"

Vous devriez voir une sortie similaire à l'exemple ci-dessous. Remarque : nous changeons explicitement le dtype en float32 pour garantir un comportement d'entraînement correct.

Hyperparamètres d'affinage (LoRA)

Il est maintenant temps d'ajuster vos hyperparamètres d'entraînement. Pour un examen approfondi de comment, quand et quoi ajuster, consultez notre guide détaillé des hyperparamètres.

Cette étape ajoute des adapteurs LoRA pour un affinage efficace en paramètres. Environ 1% seulement des paramètres du modèle sont entraînés, ce qui rend le processus nettement plus efficace.

Essayer l'inférence

Dans le notebook, il y a une section appelée "Effort de raisonnement" qui démontre l'inférence gpt-oss dans Colab. Vous pouvez sauter cette étape, mais vous devrez quand même exécuter le modèle plus tard une fois l'affinage terminé.

Préparation des données

Pour cet exemple, nous utiliserons le HuggingFaceH4/Multilingual-Thinking. Cet ensemble de données contient des exemples de raisonnement en chaîne (chain-of-thought) dérivés de questions d'utilisateurs traduites de l'anglais vers quatre langues supplémentaires.

C'est le même ensemble de données référencé dans le guide d'affinage d'OpenAI.

L'objectif d'utiliser un ensemble de données multilingue est d'aider le modèle à apprendre et à généraliser des schémas de raisonnement à travers plusieurs langues.

gpt-oss introduit un système d'effort de raisonnement qui contrôle la quantité de raisonnement effectuée par le modèle. Par défaut, l'effort de raisonnement est réglé sur faible, mais vous pouvez le modifier en définissant le reasoning_effort paramètre sur faible, moyen ou élevé.

Exemple :

tokenizer.apply_chat_template(
    text, 
    tokenize = False, 
    add_generation_prompt = False,
    reasoning_effort = "medium",
)

Pour formater l'ensemble de données, nous appliquons une version personnalisée du prompt gpt-oss :

from unsloth.chat_templates import standardize_sharegpt
dataset = standardize_sharegpt(dataset)
dataset = dataset.map(formatting_prompts_func, batched = True,)

Inspectons l'ensemble de données en affichant le premier exemple :

print(dataset[0]['text'])

Une caractéristique unique de gpt-oss est son utilisation du format OpenAI Harmony, qui prend en charge des conversations structurées, la sortie de raisonnement et l'appel d'outils. Ce format inclut des balises telles que <|start|> , <|message|> , et <|return|> .

N'hésitez pas à adapter le prompt et la structure à votre propre ensemble de données ou cas d'utilisation. Pour plus d'orientation, référez-vous à notre guide d'ensemble de données.

Entraîner le modèle

Nous avons présélectionné des hyperparamètres d'entraînement pour des résultats optimaux. Cependant, vous pouvez les modifier en fonction de votre cas d'utilisation spécifique. Consultez notre guide des hyperparamètres.

Dans cet exemple, nous entraînons pendant 60 étapes pour accélérer le processus. Pour un entraînement complet, définissez num_train_epochs=1 et désactivez la limitation d'étapes en définissant max_steps=None.

Pendant l'entraînement, surveillez la perte pour vous assurer qu'elle diminue au fil du temps. Cela confirme que le processus d'entraînement fonctionne correctement.

Inférence : Exécutez votre modèle entraîné

Il est maintenant temps d'exécuter l'inférence avec votre modèle affiné. Vous pouvez modifier l'instruction et l'entrée, mais laissez la sortie vide.

Dans cet exemple, nous testons la capacité du modèle à raisonner en français en ajoutant une instruction spécifique au prompt système, suivant la même structure utilisée dans notre ensemble de données.

Cela devrait produire une sortie similaire à :

Enregistrez/exportez votre modèle

Pour enregistrer votre modèle affiné, vous pouvez exporter votre modèle affiné à la fois en format bf16 , avec notre déquantification à la demande de MXFP4 des modèles de base en utilisant save_method="merged_16bit"ou en MXFP4 format Safetensors en utilisant save_method="mxfp4" .

Le MXFP4 le format de fusion natif offre des améliorations de performance significatives par rapport au format bf16 : il utilise jusqu'à 75% d'espace disque en moins, réduit la consommation de VRAM de 50%, accélère la fusion de 5 à 10×, et permet une conversion beaucoup plus rapide en GGUF format.

Après avoir affiné votre modèle gpt-oss, vous pouvez le fusionner en MXFP4 format avec :

model.save_pretrained_merged(save_directory, tokenizer, save_method="mxfp4)

Si vous préférez fusionner le modèle et pousser directement vers le hub hugging-face :

model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token= hf_token, save_method="mxfp4")

✨ Enregistrement vers Llama.cpp

1. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

   Copier

   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.cp

2. Convertir le MXFP4 modèle fusionné :

   Copier

   python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned-mxfp4.gguf

3. Exécuter l'inférence sur le modèle quantifié :

   Copier

   llama.cpp/llama-cli --model gpt-oss-finetuned-mxfp4.gguf \
       --jinja -ngl 99 --threads -1 --ctx-size 16384 \
       --temp 1.0 --top-p 1.0 --top-k 0 \
        -p "Le sens de la vie et de l'univers est"

Installer Unsloth localement

Assurez-vous que votre appareil est compatible Unsloth et vous pouvez lire notre guide d'installation détaillé.

Vous pouvez également installer Unsloth en utilisant notre image Docker.

Notez que pip install unsloth ne fonctionnera pas pour cette configuration, car nous devons utiliser les dernières versions de PyTorch, Triton et des packages associés. Installez Unsloth en utilisant cette commande spécifique :

# Nous installons les dernières versions de Torch, Triton, les noyaux Triton d'OpenAI, Transformers et Unsloth !
!pip install --upgrade -qqq uv
try: import numpy; install_numpy = f"numpy=={numpy.__version__}"
except: install_numpy = "numpy"
!uv pip install -qqq \
    "torch>=2.8.0" "triton>=3.4.0" {install_numpy} \
    "unsloth_zoo[base] @ git+https://github.com/unslothai/unsloth-zoo" \
    "unsloth[base] @ git+https://github.com/unslothai/unsloth" \
    torchvision bitsandbytes \
    git+https://github.com/huggingface/transformers \
    git+https://github.com/triton-lang/triton.git@05b2c186c1b6c9a08375389d5efe9cb4c401c075#subdirectory=python/triton_kernels

Configuration de gpt-oss et de l'Effort de Raisonnement

Nous chargerons gpt-oss-20b en utilisant la version linéarisée (car aucune autre version ne fonctionnera pour l'affinage QLoRA). Configurez les paramètres suivants :

• max_seq_length = 2048

  • Recommandé pour des tests rapides et des expériences initiales.

• load_in_4bit = True

  • Utilisez False pour l'entraînement LoRA (remarque : définir ceci sur False nécessitera au moins 43 Go de VRAM). Vous DEVEZ également définir model_name = "unsloth/gpt-oss-20b-BF16"

from unsloth import FastLanguageModel
import torch
max_seq_length = 1024
dtype = None

# Modèles pré-quantifiés 4 bits que nous prenons en charge pour un téléchargement 4× plus rapide + pas d'OOM.
fourbit_models = [
    "unsloth/gpt-oss-20b-unsloth-bnb-4bit", # modèle 20B utilisant la quantification bitsandbytes 4bit
    "unsloth/gpt-oss-120b-unsloth-bnb-4bit",
    "unsloth/gpt-oss-20b", # modèle 20B utilisant le format MXFP4
    "unsloth/gpt-oss-120b",
] # Plus de modèles sur https://huggingface.co/unsloth

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/gpt-oss-20b",
    dtype = dtype, # None pour détection automatique
    max_seq_length = max_seq_length, # Choisissez n'importe quelle valeur pour un contexte long !
    load_in_4bit = True,  # quantification 4 bits pour réduire la mémoire
    full_finetuning = False, # [NOUVEAU!] Nous avons maintenant le fine-tuning complet !
    # token = "hf_...", # utilisez-en un si vous utilisez des modèles à accès restreint
)

Vous devriez voir une sortie similaire à l'exemple ci-dessous. Remarque : nous changeons explicitement le dtype en float32 pour garantir un comportement d'entraînement correct.

Hyperparamètres d'affinage (LoRA)

Il est maintenant temps d'ajuster vos hyperparamètres d'entraînement. Pour un examen approfondi de comment, quand et quoi ajuster, consultez notre guide détaillé des hyperparamètres.

Cette étape ajoute des adapteurs LoRA pour un affinage efficace en paramètres. Environ 1% seulement des paramètres du modèle sont entraînés, ce qui rend le processus nettement plus efficace.

model = FastLanguageModel.get_peft_model(
    model,
    r = 8, # Choisissez n'importe quel nombre > 0 ! Suggestion : 8, 16, 32, 64, 128
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0, # Prend en charge n'importe quelle valeur, mais = 0 est optimisé
    bias = "none",    # Prend en charge n'importe quelle valeur, mais = "none" est optimisé
    # [NOUVEAU] "unsloth" utilise 30% de VRAM en moins, permet des tailles de batch 2× supérieures !
    use_gradient_checkpointing = "unsloth", # True or "unsloth" pour des contextes très longs
    random_state = 3407,
    use_rslora = False,  # Nous prenons en charge le LoRA à rang stabilisé
    loftq_config = None, # Et LoftQ
)

Préparation des données

Pour cet exemple, nous utiliserons le HuggingFaceH4/Multilingual-Thinking. Cet ensemble de données contient des exemples de raisonnement en chaîne (chain-of-thought) dérivés de questions d'utilisateurs traduites de l'anglais vers quatre langues supplémentaires.

C'est le même ensemble de données référencé dans le guide d'affinage d'OpenAI. L'objectif d'utiliser un ensemble de données multilingue est d'aider le modèle à apprendre et à généraliser des schémas de raisonnement à travers plusieurs langues.

def formatting_prompts_func(examples):
    convos = examples["messages"]
    texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
    return { "text" : texts, }
pass

#token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf

dataset = load_dataset("HuggingFaceH4/Multilingual-Thinking", split="train")
Elise

gpt-oss introduit un système d'effort de raisonnement qui contrôle la quantité de raisonnement effectuée par le modèle. Par défaut, l'effort de raisonnement est réglé sur faible, mais vous pouvez le modifier en définissant le reasoning_effort paramètre sur faible, moyen ou élevé.

Exemple :

tokenizer.apply_chat_template(
    text, 
    tokenize = False, 
    add_generation_prompt = False,
    reasoning_effort = "medium",
)

Pour formater l'ensemble de données, nous appliquons une version personnalisée du prompt gpt-oss :

from unsloth.chat_templates import standardize_sharegpt
dataset = standardize_sharegpt(dataset)
dataset = dataset.map(formatting_prompts_func, batched = True,)

Inspectons l'ensemble de données en affichant le premier exemple :

print(dataset[0]['text'])

Une caractéristique unique de gpt-oss est son utilisation du format OpenAI Harmony, qui prend en charge des conversations structurées, la sortie de raisonnement et l'appel d'outils. Ce format inclut des balises telles que <|start|> , <|message|> , et <|return|> .

N'hésitez pas à adapter le prompt et la structure à votre propre ensemble de données ou cas d'utilisation. Pour plus d'orientation, référez-vous à notre guide d'ensemble de données.

Entraîner le modèle

Nous avons présélectionné des hyperparamètres d'entraînement pour des résultats optimaux. Cependant, vous pouvez les modifier en fonction de votre cas d'utilisation spécifique. Consultez notre guide des hyperparamètres.

Dans cet exemple, nous entraînons pendant 60 étapes pour accélérer le processus. Pour un entraînement complet, définissez num_train_epochs=1 et désactivez la limitation d'étapes en définissant max_steps=None.

from trl import SFTConfig, SFTTrainer
trainer = SFTTrainer(
    trainer = Trainer(
    tokenizer = tokenizer,
    model = model,
    args = SFTConfig(
        args = TrainingArguments(
        gradient_accumulation_steps = 4,
        per_device_train_batch_size = 1,
        warmup_steps = 5,
        max_steps = 30,
        max_steps = 60,
        bf16 = is_bfloat16_supported(),
        optim = "adamw_8bit",
        logging_steps = 1,
        weight_decay = 0.01,','t201':'lr_scheduler_type = "linear",']
        seed = 3407,
        output_dir = "outputs",
        report_to = "none", # Utilisez ceci pour WandB, etc.
    ),
)

Pendant l'entraînement, surveillez la perte pour vous assurer qu'elle diminue au fil du temps. Cela confirme que le processus d'entraînement fonctionne correctement.

Inférence : Exécutez votre modèle entraîné

Il est maintenant temps d'exécuter l'inférence avec votre modèle affiné. Vous pouvez modifier l'instruction et l'entrée, mais laissez la sortie vide.

Dans cet exemple, nous testons la capacité du modèle à raisonner en français en ajoutant une instruction spécifique au prompt système, suivant la même structure utilisée dans notre ensemble de données.

messages = [
    {"role": "system", "content": "langue de raisonnement : Français\n\nVous êtes un assistant utile qui peut résoudre des problèmes mathématiques."},
    {"role": "user", "content": "Résoudre x^5 + 3x^4 - 10 = 3."},
]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt = True,
    return_tensors = "pt",
    return_dict = True,
    reasoning_effort = "medium",
).to(model.device)
from transformers import TextStreamer
_ = model.generate(**inputs, max_new_tokens = 2048, streamer = TextStreamer(tokenizer))

Cela devrait produire une sortie similaire à :

Enregistrez et exportez votre modèle

Pour enregistrer votre modèle affiné, il peut être exporté au format Safetensors avec notre nouveau déquantification à la demande de MXFP4 modèles de base (comme gpt-oss) lors du processus de fusion LoRA. Cela rend possible de exporter votre modèle affiné au format bf16.

Après avoir affiné votre modèle gpt-oss, vous pouvez le fusionner en format 16 bits avec :

model.save_pretrained_merged(save_directory, tokenizer)

Si vous préférez fusionner le modèle et pousser directement vers le hub hugging-face :

model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token= hf_token)

✨ Enregistrement vers Llama.cpp

1. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

   Copier

   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.cp

2. Convertir et quantifier le modèle fusionné :

   Copier

   python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned.gguf
   llama.cpp/llama-quantize gpt-oss-finetuned.gguf  gpt-oss-finetuned-Q8_0.gguf Q8_0

3. Exécuter l'inférence sur le modèle quantifié :

   Copier

   llama.cpp/llama-cli --model gpt-oss-finetuned-Q8_0.gguf \
       --jinja -ngl 99 --threads -1 --ctx-size 16384 \
       --temp 1.0 --top-p 1.0 --top-k 0 \
        -p "Le sens de la vie et de l'univers est"