For the complete documentation index, see llms.txt. This page is also available as Markdown.

Tutorial: Wie man gpt-oss feinabstimmt

Erfahre Schritt für Schritt, wie du OpenAI gpt-oss lokal mit Unsloth trainierst.

In diesem Leitfaden mit Screenshots lernst du, dein eigenes benutzerdefiniertes gpt-oss-Modell feinabzustimmen, entweder lokal auf deinem Rechner mit Unsloth oder kostenlos mit Google Colab. Wir führen dich durch den gesamten Prozess, vom Einrichten bis zum Ausführen und Speichern deines trainierten Modells.

Schnellstart: Feinabstimmung von gpt-oss-20b kostenlos mit unserem: Colab-Notebook

Die gpt-oss-Feinabstimmung mit Unsloth erreicht im Vergleich zu allen anderen FA2-Implementierungen 1,5× schnelleres Training, 70 % weniger VRAM-Verbrauch und 10x längere Kontextlängen – ohne Genauigkeitsverlust.

  • QLoRA-Anforderungen: gpt-oss-20b = 14 GB VRAM • gpt-oss-120b = 65 GB VRAM.

  • BF16-LoRA-Anforderungen: gpt-oss-20b = 44 GB VRAM • gpt-oss-120b = 210 GB VRAM.

Lokaler LeitfadenColab-Leitfaden

🌐 Colab gpt-oss-Fine-Tuning

Dieser Abschnitt behandelt das Feinabstimmen von gpt-oss mithilfe unserer Google-Colab Notebooks. Du kannst das gpt-oss-Notebook auch speichern und in deinem bevorzugten Code-Editor verwenden und unserem lokalen gpt-oss-Leitfaden.

1

Unsloth in Colab installieren

Führe in Colab Zellen aus von oben nach unten. Verwenden Sie Alle ausführen für den ersten Durchlauf. Die erste Zelle installiert Unsloth (und zugehörige Abhängigkeiten) und gibt GPU-/Speicherinformationen aus. Falls eine Zelle einen Fehler auslöst, führe sie einfach erneut aus.

2

gpt-oss und Reasoning Effort konfigurieren

Wir laden gpt-oss-20b mithilfe von Unsloths linearisiertem Version (da keine andere Version funktioniert).

Konfiguriere die folgenden Parameter:

  • max_seq_length = 1024

    • Empfohlen für schnelle Tests und erste Experimente.

  • load_in_4bit = True

    • Verwende False für LoRA-Training (Hinweis: wenn du dies auf False setzt, werden mindestens 43 GB VRAM benötigt). Du MUSS außerdem setzen model_name = "unsloth/gpt-oss-20b-BF16"

Du solltest eine ähnliche Ausgabe wie im folgenden Beispiel sehen. Hinweis: Wir ändern den dtype zu explizit auf float32 um ein korrektes Trainingsverhalten sicherzustellen.

3

Feinabstimmungs-Hyperparameter (LoRA)

Jetzt ist es an der Zeit, deine Trainings-Hyperparameter anzupassen. Für einen tieferen Einblick darin, wie, wann und was angepasst werden sollte, sieh dir unseren detaillierten Leitfaden zu Hyperparametern.

an, um Überanpassungzu vermeiden, beobachte deinen Trainingsverlust und vermeide, diese Werte zu hoch einzustellen.

Dieser Schritt fügt LoRA-Adapter für eine parameter-effiziente Feinabstimmung hinzu. Es werden nur etwa 1 % der Modellparameter trainiert, was den Prozess deutlich effizienter macht.

4

Inference ausprobieren

Im Notebook gibt es einen Abschnitt namens "Reasoning Effort" der zeigt, wie gpt-oss-Inferenz in Colab ausgeführt wird. Du kannst diesen Schritt überspringen, musst das Modell aber später trotzdem ausführen, sobald du mit der Feinabstimmung fertig bist.

5

Datenvorbereitung

Für dieses Beispiel verwenden wir das HuggingFaceH4/Multilingual-Thinking. Dieses Dataset enthält Chain-of-Thought-Reasoning-Beispiele, die aus Nutzerfragen abgeleitet wurden, die aus dem Englischen in vier weitere Sprachen übersetzt wurden.

Dies ist dasselbe Dataset, das im Fine-Tuning-Cookbook von OpenAI referenziert wird.

Das Ziel der Verwendung eines mehrsprachigen Datasets ist es, dem Modell zu helfen, Reasoning-Muster über mehrere Sprachen hinweg zu lernen und zu verallgemeinern.

gpt-oss führt ein Reasoning-Effort-System ein, das steuert, wie viel Schlussfolgern das Modell ausführt. Standardmäßig ist der Reasoning-Effort auf niedriggesetzt, aber du kannst ihn ändern, indem du den Parameter reasoning_effort auf niedrig, mittel oder hoch.

Beispiel:

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

Um das Dataset zu formatieren, wenden wir eine angepasste Version des gpt-oss-Prompts an:

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

Lass uns das Dataset prüfen, indem wir das erste Beispiel ausgeben:

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

Eine einzigartige Funktion von gpt-oss ist die Verwendung des OpenAI-Harmony-Formats, das strukturierte Gespräche, Reasoning-Ausgaben und Tool-Aufrufe unterstützt. Dieses Format enthält Tags wie <|start|> , <|message|> und <|return|> .

🦥 Unsloth korrigiert die Chat-Vorlage, um sicherzustellen, dass sie korrekt ist. Sieh dir diesen Tweet für technische Details zu unserem Vorlagen-Fix an.

Du kannst den Prompt und die Struktur gerne an dein eigenes Dataset oder deinen Anwendungsfall anpassen. Weitere Hinweise findest du in unserem Dataset-Leitfaden.

6

Das Modell trainieren

Wir haben Trainings-Hyperparameter für optimale Ergebnisse vorab ausgewählt. Du kannst sie jedoch an deinen spezifischen Anwendungsfall anpassen. Sieh dir unseren Leitfaden zu Hyperparametern.

In diesem Beispiel trainieren wir 60 Schritte, um den Prozess zu beschleunigen. Für einen vollständigen Trainingsdurchlauf setze num_train_epochs=1 und deaktiviere die Schrittbegrenzung, indem du max_steps=None.

während des Trainings den Verlust, um sicherzustellen, dass er mit der Zeit sinkt. Das bestätigt, dass der Trainingsprozess korrekt funktioniert.

7

Inference: Führe dein trainiertes Modell aus

Jetzt ist es an der Zeit, Inferenz mit deinem feinabgestimmten Modell auszuführen. Du kannst die Anweisung und die Eingabe ändern, aber lass die Ausgabe leer.

In diesem Beispiel testen wir die Fähigkeit des Modells, auf Französisch zu schlussfolgern, indem wir dem System-Prompt eine spezifische Anweisung hinzufügen, entsprechend derselben Struktur, die in unserem Dataset verwendet wird.

Dies sollte eine ähnliche Ausgabe erzeugen wie:

8

Modell speichern/exportieren

Um dein feinabgestimmtes Modell zu speichern, kannst du dein feinabgestimmtes Modell sowohl im bf16-Format, mit unserer On-Demand-Dekquantisierung von MXFP4 Basis-Modellen unter Verwendung von save_method="merged_16bit"oder im nativen MXFP4 Safetensors-Format mit save_method="mxfp4" .

speichern. MXFP4 Das native Merge-Format bietet gegenüber dembf16-Format deutliche Leistungsverbesserungen: Es benötigt bis zu 75 % weniger Speicherplatz, reduziert den VRAM-Verbrauch um 50 %, beschleunigt das Zusammenführen um das 5-10-Fache und ermöglicht eine deutlich schnellere Konvertierung in das GGUF

Neu: Das Speichern oder Zusammenführen von mit QLoRA feinabgestimmten Modellen zu GGUF wird jetzt für die Verwendung in anderen Frameworks unterstützt (z. B. Hugging Face, llama.cpp mit GGUF). MXFP4 Nachdem du dein gpt-oss-Modell feinabgestimmt hast, kannst du es mit Folgendem in das

Format zusammenführen:

Wenn du das Modell lieber zusammenführen und direkt auf den Hugging-Face-Hub hochladen möchtest:

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

Speichern für Llama.cpp

  1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den untenstehenden Build-Anweisungen folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest.

    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. Konvertiere das MXFP4 zusammengeführte Modell:

    python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned-mxfp4.gguf
  3. Führe Inferenz auf dem quantisierten Modell aus:

    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 "Der Sinn des Lebens und des Universums ist"

🖥️ Lokales gpt-oss-Fine-Tuning

Dieses Kapitel behandelt das Feinabstimmen von gpt-oss auf deinem lokalen Gerät. Während gpt-oss-20b Feinabstimmung bereits mit nur 14 GB VRAM möglich ist, empfehlen wir, mindestens 16 GB VRAM verfügbar zu haben, um stabile und zuverlässige Trainingsläufe sicherzustellen.

Wir empfehlen, Elemente aus unserem Colab herunterzuladen oder zu übernehmen Notebooks in dein lokales Setup, um die Nutzung zu erleichtern.

1

Unsloth lokal installieren

Stelle sicher, dass dein Gerät Unsloth-kompatibel ist, und lies unseren ausführlichen Installationsleitfaden.

Du kannst Unsloth auch mit unserem Docker-Image.

installieren. Beachte, dass pip install unsloth für dieses Setup nicht funktioniert, da wir die neueste PyTorch-, Triton- und zugehörige Pakete verwenden müssen. Installiere Unsloth mit diesem speziellen Befehl:

# Wir installieren die neueste Torch, Triton, OpenAIs Triton-Kernels, Transformers und 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
2

gpt-oss und Reasoning Effort konfigurieren

Wir laden gpt-oss-20b mithilfe von Unsloths linearisiertem Version (da keine andere Version für QLoRA-Feinabstimmung funktioniert). Konfiguriere die folgenden Parameter:

  • max_seq_length = 2048

    • Empfohlen für schnelle Tests und erste Experimente.

  • load_in_4bit = True

    • Verwende False für LoRA-Training (Hinweis: wenn du dies auf False setzt, werden mindestens 43 GB VRAM benötigt). Du MUSS außerdem setzen model_name = "unsloth/gpt-oss-20b-BF16"

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

# 4-Bit-vorquantisierte Modelle, die wir unterstützen, für 4x schnelleres Herunterladen + keine OOMs.
fourbit_models = [
    "unsloth/gpt-oss-20b-unsloth-bnb-4bit", # 20B-Modell mit bitsandbytes-4bit-Quantisierung
    "unsloth/gpt-oss-120b-unsloth-bnb-4bit",
    "unsloth/gpt-oss-20b", # 20B-Modell im MXFP4-Format
    "unsloth/gpt-oss-120b",
] # Weitere Modelle unter https://huggingface.co/unsloth

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/gpt-oss-20b",
    dtype = dtype, # None für automatische Erkennung
    max_seq_length = max_seq_length, # Wähle beliebig für langen Kontext!
    load_in_4bit = True,  # 4-Bit-Quantisierung zur Speicherreduzierung
    full_finetuning = False, # [NEU!] Wir haben jetzt Full-Finetuning!
    # token = "hf_...", # verwende einen, wenn du geschützte Modelle nutzt
)

Du solltest eine ähnliche Ausgabe wie im folgenden Beispiel sehen. Hinweis: Wir ändern den dtype zu explizit auf float32 um ein korrektes Trainingsverhalten sicherzustellen.

3

Feinabstimmungs-Hyperparameter (LoRA)

Jetzt ist es an der Zeit, deine Trainings-Hyperparameter anzupassen. Für einen tieferen Einblick darin, wie, wann und was angepasst werden sollte, sieh dir unseren detaillierten Leitfaden zu Hyperparametern.

an, um Überanpassungzu vermeiden, beobachte deinen Trainingsverlust und vermeide, diese Werte zu hoch einzustellen.

Dieser Schritt fügt LoRA-Adapter für eine parameter-effiziente Feinabstimmung hinzu. Es werden nur etwa 1 % der Modellparameter trainiert, was den Prozess deutlich effizienter macht.

model = FastLanguageModel.get_peft_model(
    model,
    r = 8, # Wähle eine beliebige Zahl > 0 ! Empfohlen: 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, # Unterstützt jeden Wert, aber = 0 ist optimiert
    bias = "none",    # Unterstützt jeden Wert, aber = "none" ist optimiert
    # [NEU] "unsloth" verwendet 30 % weniger VRAM und passt in 2x größere Batch-Größen!
    use_gradient_checkpointing = "unsloth", # True oder "unsloth" für sehr langen Kontext
    random_state = 3407,
    use_rslora = False,  # Wir unterstützen rank-stabilisiertes LoRA
    loftq_config = None, # Und LoftQ
)
4

Datenvorbereitung

Für dieses Beispiel verwenden wir das HuggingFaceH4/Multilingual-Thinking. Dieses Dataset enthält Chain-of-Thought-Reasoning-Beispiele, die aus Nutzerfragen abgeleitet wurden, die aus dem Englischen in vier weitere Sprachen übersetzt wurden.

Dies ist dasselbe Dataset, das im Fine-Tuning-Cookbook von OpenAI referenziert wird. Das Ziel der Verwendung eines mehrsprachigen Datasets ist es, dem Modell zu helfen, Reasoning-Muster über mehrere Sprachen hinweg zu lernen und zu verallgemeinern.

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

from datasets import load_dataset

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

gpt-oss führt ein Reasoning-Effort-System ein, das steuert, wie viel Schlussfolgern das Modell ausführt. Standardmäßig ist der Reasoning-Effort auf niedriggesetzt, aber du kannst ihn ändern, indem du den Parameter reasoning_effort auf niedrig, mittel oder hoch.

Beispiel:

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

Um das Dataset zu formatieren, wenden wir eine angepasste Version des gpt-oss-Prompts an:

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

Lass uns das Dataset prüfen, indem wir das erste Beispiel ausgeben:

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

Eine einzigartige Funktion von gpt-oss ist die Verwendung des OpenAI-Harmony-Formats, das strukturierte Gespräche, Reasoning-Ausgaben und Tool-Aufrufe unterstützt. Dieses Format enthält Tags wie <|start|> , <|message|> und <|return|> .

🦥 Unsloth korrigiert die Chat-Vorlage, um sicherzustellen, dass sie korrekt ist. Sieh dir diesen Tweet für technische Details zu unserem Vorlagen-Fix an.

Du kannst den Prompt und die Struktur gerne an dein eigenes Dataset oder deinen Anwendungsfall anpassen. Weitere Hinweise findest du in unserem Dataset-Leitfaden.

5

Das Modell trainieren

Wir haben Trainings-Hyperparameter für optimale Ergebnisse vorab ausgewählt. Du kannst sie jedoch an deinen spezifischen Anwendungsfall anpassen. Sieh dir unseren Leitfaden zu Hyperparametern.

In diesem Beispiel trainieren wir 60 Schritte, um den Prozess zu beschleunigen. Für einen vollständigen Trainingsdurchlauf setze num_train_epochs=1 und deaktiviere die Schrittbegrenzung, indem du max_steps=None.

from trl import SFTConfig, SFTTrainer
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    args = SFTConfig(
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        # num_train_epochs = 1, # Setze dies für einen vollständigen Trainingsdurchlauf.
        max_steps = 30,
        learning_rate = 2e-4,
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
        report_to = "none", # Verwende dies für WandB usw.
    ),
)

während des Trainings den Verlust, um sicherzustellen, dass er mit der Zeit sinkt. Das bestätigt, dass der Trainingsprozess korrekt funktioniert.

6

Inference: Führe dein trainiertes Modell aus

Jetzt ist es an der Zeit, Inferenz mit deinem feinabgestimmten Modell auszuführen. Du kannst die Anweisung und die Eingabe ändern, aber lass die Ausgabe leer.

In diesem Beispiel testen wir die Fähigkeit des Modells, auf Französisch zu schlussfolgern, indem wir dem System-Prompt eine spezifische Anweisung hinzufügen, entsprechend derselben Struktur, die in unserem Dataset verwendet wird.

messages = [
    {"role": "system", "content": "reasoning language: French\n\nYou are a helpful assistant that can solve mathematical problems."},
    {"role": "user", "content": "Solve 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))

Dies sollte eine ähnliche Ausgabe erzeugen wie:

7

Modell speichern und exportieren

Um dein feinabgestimmtes Modell zu speichern, kann es im Safetensors-Format mit unserem neuen On-Demand-Dekquantisierung von MXFP4 Basis-Modelle (wie gpt-oss) während des LoRA-Merge-Prozesses. Dies macht es möglich, dein feinabgestimmtes Modell im bf16-Format zu exportieren.

Nachdem du dein gpt-oss-Modell feinabgestimmt hast, kannst du es mit Folgendem in das 16-Bit-Format zusammenführen:

model.save_pretrained_merged(save_directory, tokenizer)

Wenn du das Modell lieber zusammenführen und direkt auf den Hugging-Face-Hub hochladen möchtest:

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

Speichern für Llama.cpp

  1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den untenstehenden Build-Anweisungen folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest.

    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. Das zusammengeführte Modell konvertieren und quantisieren:

    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. Führe Inferenz auf dem quantisierten Modell aus:

    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 "Der Sinn des Lebens und des Universums ist"

🏁 Und das war's!

Du hast gpt-oss mit Unsloth feinabgestimmt. Wir arbeiten derzeit an RL- und GRPO-Implementierungen sowie an verbessertem Speichern und Ausführen von Modellen, also bleib dran.

Wie immer kannst du gerne in unserem Discord oder Reddit vorbeischauen, wenn du Hilfe brauchst.

❓FAQ (Häufig gestellte Fragen)

1. Kann ich mein Modell später exportieren, um es in Hugging Face, llama.cpp GGUF oder vLLM zu verwenden?

Ja, das kannst du jetzt dein gpt-oss-feinabgestimmtes Modell mit dem neuen Update von Unsloth speichern/exportieren!

2. Kann ich fp4- oder MXFP4-Training mit gpt-oss durchführen?

Nein, derzeit unterstützt kein Framework fp4- oder MXFP4-Training. Unsloth ist jedoch das einzige Framework, das QLoRA-4-Bit-Feinabstimmung für das Modell unterstützt und damit mehr als 4x weniger VRAM-Nutzung ermöglicht.

3. Kann ich mein Modell nach dem Training in das MXFP4-Format exportieren?

Nein, derzeit unterstützt keine Bibliothek oder kein Framework dies.

4. Kann ich Reinforcement Learning (RL) oder GRPO mit gpt-oss durchführen?

Ja! Unsloth unterstützt jetzt RL für gpt-oss mit GRPO/GSPO. Wir haben es in einem kostenlosen Kaggle-Notebook zum Laufen gebracht und die schnellste Inferenz für RL erreicht. Hier mehr lesen


Danksagungen: Ein riesiges Dankeschön an Eyera für den Beitrag zu diesem Leitfaden!

Zuletzt aktualisiert

War das hilfreich?