gpt-oss: Anleitung zum Ausführen

Führe OpenAIs neue Open-Source-Modelle aus & feinabstimme sie!

OpenAI veröffentlicht 'gpt-oss-120b' und 'gpt-oss-20b', zwei SOTA offene Sprachmodelle unter der Apache-2.0-Lizenz. Beide 128k-Kontextmodelle übertreffen ähnlich große offene Modelle in Schlussfolgerung, Werkzeugnutzung und agentischen Aufgaben. Du kannst sie jetzt lokal mit Unsloth ausführen und feinjustieren!

gpt-oss-20b ausführengpt-oss-120b ausführengpt-oss feinjustieren

Feinabstimmen gpt-oss-20b kostenlos mit unserem Colab-Notebook

Trainiert mit RL, gpt-oss-120b konkurriert mit o4-mini und gpt-oss-20b konkurriert mit o3-mini. Beide zeichnen sich bei Funktionsaufrufen und CoT-Schlussfolgerungen aus und übertreffen o1 und GPT-4o.

Für beste Leistung stelle sicher, dass dein gesamter verfügbarer Speicher (unifizierter Speicher + VRAM + Systemspeicher) die Größe der quantisierten Modell-Datei, die du herunterlädst, übersteigt. Falls nicht, kann llama.cpp immer noch über SSD/HDD-Auslagerung laufen, aber die Inferenz wird langsamer sein.

gpt-oss - Unsloth GGUFs:

Enthält Unsloths Chat-Vorlagen-Fixes. Für beste Ergebnisse nutze unsere Uploads und trainiere mit Unsloth!

• 20B: gpt-oss-20B

• 120B: gpt-oss-120B

📜Unsloth-Fixes für gpt-oss

Einige unserer Fixes wurden upstream in OpenAIs offizielles Modell auf Hugging Face übernommen. Tool Calling mit GLM 4.7

OpenAI veröffentlichte eine eigenständige Parsing- und Tokenisierungsbibliothek namens Harmony die es ermöglicht, Konversationen in OpenAIs bevorzugtes Format für gpt-oss zu tokenisieren.

Inference-Engines verwenden im Allgemeinen stattdessen die jinja-Chatvorlage und nicht das Harmony-Paket, und wir fanden einige Probleme mit ihnen, nachdem wir sie direkt mit Harmony verglichen haben. Wenn du unten siehst, ist oben die korrekte gerenderte Form wie von Harmony. Unten ist die von der aktuellen jinja-Chatvorlage gerenderte Version. Es gibt ziemlich viele Unterschiede!

Wir haben auch einige Funktionen erstellt, die es dir direkt ermöglichen, OpenAIs Harmony-Bibliothek ohne eine jinja-Chatvorlage zu verwenden, falls du das möchtest - du kannst einfach normale Konversationen wie unten parsen:

messages = [
    {"role" : "user", "content" : "What is 1+1?"},
    {"role" : "assistant", "content" : "2"},
    {"role": "user",  "content": "Wie ist die Temperatur in San Francisco jetzt? Wie sieht es morgen aus? Heutiges Datum ist 2024-09-30."},
    {"role": "assistant",  "content": "Der Benutzer fragt: 'Wie ist das Wetter in San Francisco?' Wir müssen das Tool get_current_temperature verwenden.", "thinking" : ""},
    {"role": "assistant", "content": "", "tool_calls": [{"name": "get_current_temperature", "arguments": '{"location": "San Francisco, California, United States", "unit": "celsius"}'}]},
    {"role": "tool", "name": "get_current_temperature", "content": '{"temperature": 19.9, "location": "San Francisco, California, United States", "unit": "celsius"}'},
]

Verwende dann die encode_conversations_with_harmony Funktion von Unsloth:

from unsloth_zoo import encode_conversations_with_harmony

def encode_conversations_with_harmony(
    def unsloth_inference(
    reasoning_effort = "medium",
    add_generation_prompt = True,
    tool_calls = None,
    developer_instructions = None,
    model_identity = "You are ChatGPT, a large language model trained by OpenAI.",
)

Das Harmony-Format enthält mehrere interessante Dinge:

1. reasoning_effort = "medium" Du kannst low, medium oder high auswählen, und das ändert gpt-oss' Reasoning-Budget – im Allgemeinen gilt: je höher, desto besser die Genauigkeit des Modells.

2. developer_instructions ist wie ein System-Prompt, den du hinzufügen kannst.

3. model_identity lässt man am besten unverändert – du kannst es bearbeiten, aber wir sind uns nicht sicher, ob benutzerdefinierte Identitäten funktionieren werden.

Wir finden mehrere Probleme mit aktuellen jinja-Chatvorlagen (es existieren mehrere Implementierungen im Ökosystem):

1. Funktions- und Toolaufrufe werden mit tojsongerendert, was in Ordnung ist, wenn es ein Dict ist, aber wenn es ein String ist, werden Anführungszeichen und andere Symbole werden mit Backslashes versehen.

2. Es gibt einige zusätzliche neue Zeilen in der jinja-Vorlage an einigen Grenzen.

3. Tool-Calling-Gedanken des Modells sollten das analysis Tag und nicht das final Tag haben.

4. Andere Chatvorlagen scheinen <|channel|>final überhaupt nicht zu nutzen – dieses sollte für die finale Assistenten-Nachricht verwendet werden. Du solltest es nicht für Denkspuren oder Toolaufrufe verwenden.

Unsere Chatvorlagen für das GGUF, unsere BnB- und BF16-Uploads und alle Versionen sind behoben! Zum Beispiel erhalten wir beim Vergleich unserer und Harmonys Format keine unterschiedlichen Zeichen:

🔢 Präzisionsprobleme

Wir fanden mehrere Präzisionsprobleme auf Tesla T4- und float16-Maschinen, hauptsächlich da das Modell mit BF16 trainiert wurde, und daher Ausreißer und Überläufe auftraten. MXFP4 wird auf Ampere- und älteren GPUs nicht wirklich unterstützt, daher bietet Triton tl.dot_scaled für MXFP4-Matrixmultiplikation. Es hebt die Matrizen intern on-the-fly auf BF16 hoch.

Wir haben ein MXFP4-Inferenz-Notebook auch im Tesla T4 Colab erstellt!

Software-Emulation ermöglicht das Anvisieren von Hardwarearchitekturen ohne native Unterstützung für Mikroskalierungsoperationen. Momentan wird in solchen Fällen die mikroskalierte lhs/rhs zuvor auf bf16 Elementtyp für die Dot-Berechnung hochgestuft,

Wir haben festgestellt, dass bei Verwendung von float16 als Mixed-Precision-Autocast-Datentyp nach einiger Zeit Infinities auftreten. Um dem entgegenzuwirken, haben wir festgestellt, dass man das MoE in bfloat16 ausführt und es dann entweder in bfloat16 oder float32 belässt. Wenn ältere GPUs nicht einmal bfloat16-Unterstützung haben (wie T4), wird float32 verwendet.

Wir ändern außerdem alle Präzisionen von Operationen (wie den Router) zu float32 für float16-Maschinen.

🖥️ gpt-oss ausführen

Unten stehen Anleitungen für die 20B und 120B Varianten des Modells.

Jede Quantisierung kleiner als F16, einschließlich 2-Bit, hat einen minimalen Genauigkeitsverlust, da nur einige Teile (z. B. Attention-Layer) niedrigere Bitzahlen verwenden, während die meisten Teile in voller Präzision verbleiben. Deshalb sind die Größen nahe dem F16-Modell; zum Beispiel performt die 2-Bit-Version (11,5 GB) nahezu gleich wie die volle 16-Bit-Version (14 GB). Sobald llama.cpp bessere Quantisierung für diese Modelle unterstützt, werden wir sie so schnell wie möglich hochladen.

Die gpt-oss Modelle von OpenAI enthalten eine Funktion, die Nutzern erlaubt, den "Reasoning Effort" des Modells anzupassen. Das gibt dir Kontrolle über den Kompromiss zwischen Modellleistung und Antwortgeschwindigkeit (Latenz), bestimmt durch die Anzahl der Tokens, die das Modell zum Nachdenken verwendet.

Die gpt-oss Modelle bieten drei unterschiedliche Stufen des Reasoning Effort, die du wählen kannst:

• Niedrig: Optimiert für Aufgaben, die sehr schnelle Antworten benötigen und keine komplexe, mehrstufige Schlussfolgerung erfordern.

• Mittel: Ein Balanceakt zwischen Leistung und Geschwindigkeit.

• Hoch: Bietet die stärkste Schlussfolgerungsleistung für Aufgaben, die dies erfordern, führt jedoch zu höherer Latenz.

⚙️ Empfohlene Einstellungen

OpenAI empfiehlt diese Inferenz-Einstellungen für beide Modelle:

temperature=1.0, top_p=1.0, top_k=0

• Temperatur von 1.0

• Top_K = 0 (oder experimentiere mit 100 für möglicherweise bessere Ergebnisse)

• Top_P = 1,0

• Empfohlener Mindestkontext: 16.384

• Maximale Kontextlänge: 131.072

Chat-Vorlage:

<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.\nKnowledge cutoff: 2024-06\nCurrent date: 2025-08-05\n\nReasoning: medium\n\n# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>user<|message|>Hello<|end|><|start|assistant<|channel|>final<|message|>Hi there!<|end|><|start|>user<|message|>What is 1+1?<|end|><|start|>assistant

Das End-of-Sentence/Generierungs-Token: EOS ist <|return|>

gpt-oss-20B ausführen

Um Inferenzgeschwindigkeiten von 6+ Tokens pro Sekunde für unsere Dynamic 4-bit-Quantisierung zu erreichen, habe mindestens 14 GB unifizierten Speicher (kombiniertes VRAM und RAM) oder 14 GB Systemspeicher allein. Als Faustregel sollte dein verfügbarer Speicher der Größe des verwendeten Modells entsprechen oder diese übersteigen. GGUF-Link: unsloth/gpt-oss-20b-GGUF

HINWEIS: Das Modell kann mit weniger Speicher als seiner Gesamtkapazität laufen, aber das verlangsamt die Inferenz. Maximale Speicherausstattung wird nur für die schnellsten Geschwindigkeiten benötigt.

Folge den oben genannten Best Practices. Sie sind dieselben wie beim 120B-Modell.

Du kannst das Modell vorerst in Google Colab, Docker, LM Studio oder llama.cpp ausführen. Siehe unten:

Du kannst gpt-oss-20b kostenlos mit unserem Google Colab-Notebook

🐋 Docker: gpt-oss-20b ausführen Tutorial

Wenn du bereits Docker Desktop hast, musst du nur den folgenden Befehl ausführen und bist fertig:

docker model run hf.co/unsloth/gpt-oss-20b-GGUF:F16

✨ Llama.cpp: gpt-oss-20b ausführen Tutorial

1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anweisungen unten folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest. Für Apple Mac / Metal-Geräte, setze -DGGML_CUDA=OFF dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert.

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

1. Sie können direkt von Hugging Face ziehen via:

   ./llama.cpp/llama-cli \
       -hf unsloth/gpt-oss-20b-GGUF:F16 \
       --jinja -ngl 99 --ctx-size 16384 \
       --temp 1.0 --top-p 1.0 --top-k 0

2. Laden Sie das Modell herunter (nach der Installation pip install huggingface_hub hf_transfer ). Falls Downloads hängenbleiben, siehe Hugging Face Hub, XET-Debugging

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/gpt-oss-20b-GGUF",
    local_dir = "unsloth/gpt-oss-20b-GGUF",
    allow_patterns = ["*F16*"],
)

gpt-oss-120b ausführen:

Um Inferenzgeschwindigkeiten von 6+ Tokens pro Sekunde für unsere 1-Bit-Quantisierung zu erreichen, empfehlen wir mindestens 66 GB unifizierten Speicher (kombiniertes VRAM und RAM) oder 66 GB Systemspeicher allein. Als Faustregel sollte dein verfügbarer Speicher der Größe des verwendeten Modells entsprechen oder diese übersteigen. GGUF-Link: unsloth/gpt-oss-120b-GGUF

HINWEIS: Das Modell kann mit weniger Speicher als seiner Gesamtkapazität laufen, aber das verlangsamt die Inferenz. Maximale Speicherausstattung wird nur für die schnellsten Geschwindigkeiten benötigt.

Folge den oben genannten Best Practices. Sie sind dieselben wie beim 20B-Modell.

📖 Llama.cpp: gpt-oss-120b ausführen Tutorial

Für gpt-oss-120b werden wir speziell Llama.cpp für optimierte Inferenz verwenden.

Wenn du eine vollpräzise unquantisierte Versionmöchtest, verwende unsere F16 Versionen!

1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anweisungen unten 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. Du kannst llama.cpp direkt verwenden, um das Modell herunterzuladen, aber ich empfehle normalerweise die Nutzung von huggingface_hub Um llama.cpp direkt zu verwenden, mache:

   ./llama.cpp/llama-cli \
       -hf unsloth/gpt-oss-120b-GGUF:F16 \
       --ctx-size 16384 \
       --n-gpu-layers 99 \
       -ot ".ffn_.*_exps.=CPU" \
       --temp 1.0 \
       --min-p 0.0 \
       --top-p 1.0 \
       --top-k 0.0 \

3. Oder lade das Modell herunter via (nach Installation von pip install huggingface_hub hf_transfer ). Du kannst UD-Q2_K_XL oder andere quantisierte Versionen wählen..

   # !pip install huggingface_hub hf_transfer
   import os
   os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal Ratenbegrenzung verursachen, also auf 0 setzen, um zu deaktivieren
   from huggingface_hub import snapshot_download
   snapshot_download(
       repo_id = "unsloth/gpt-oss-120b-GGUF",
       local_dir = "unsloth/gpt-oss-120b-GGUF",
       allow_patterns = ["*F16*"],
   )

4. Führe das Modell im Konversationsmodus aus und probiere beliebige Prompts.

5. Bearbeiten --threads -1 --threads 32 --ctx-size 262114 für Kontextlänge, --n-gpu-layers 99 --n-gpu-layers 2

Verwende -ot ".ffn_.*_exps.=CPU" um alle MoE-Layer auf die CPU auszulagern! Dies ermöglicht effektiv, alle nicht-MoE-Layer auf einer GPU unterzubringen und verbessert die Generierungs-Geschwindigkeiten. Du kannst den Regex-Ausdruck anpassen, um mehr Layer zu platzieren, wenn du mehr GPU-Kapazität hast. Mehr Optionen werden besprochen hier.

./llama.cpp/llama-cli \
    --model unsloth/gpt-oss-120b-GGUF/gpt-oss-120b-F16.gguf \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    -ot ".ffn_.*_exps.=CPU" \
    --temp 1.0 \
    --min-p 0.0 \
    --top-p 1.0 \
    --top-k 0.0 \

🛠️ "content": [{"type": "text", "text": "Erstelle eine Fibonacci-Funktion in Python und finde fib(20)."}],

Wenn Sie mehr VRAM haben, können Sie versuchen, mehr MoE-Schichten auszulagern oder ganze Schichten selbst auszulagern.

Normalerweise, -ot ".ffn_.*_exps.=CPU" lagert alle MoE-Schichten auf die CPU aus! Dies ermöglicht effektiv, alle Nicht-MoE-Schichten auf 1 GPU unterzubringen und verbessert die Generationsgeschwindigkeit. Sie können den Regex-Ausdruck anpassen, um mehr Schichten unterzubringen, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert Up- und Down-Projektions-MoE-Schichten aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur Up-Projektions-MoE-Schichten aus.

Sie können auch den Regex anpassen, zum Beispiel -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" bedeutet, Gate-, Up- und Down-MoE-Schichten auszulagern, aber nur ab der 6. Schicht.

Die neueste llama.cpp-Version führt außerdem einen Hochdurchsatzmodus ein. Verwenden Sie llama-parallel. Lesen Sie mehr darüber hier. Sie können auch den KV-Cache z. B. auf 4 Bit quantisieren, den KV-Cache auf 4 Bit quantisieren

🦥 gpt-oss mit Unsloth feinjustieren

Update vom 28. Aug.: Du kannst jetzt dein QLoRA-feinjustiertes gpt-oss-Modell nach llama.cpp, vLLM, HF etc. exportieren/speichern.

Wir haben außerdem eingeführt Unsloth Flex Attention welches ermöglicht >8× längere Kontextlängen, >50% weniger VRAM-Nutzung und >1.5× schnelleres Training gegenüber allen Implementierungen. Mehr dazu hier lesen

Unsloth gpt-oss Feinabstimmung ist 1.5x schneller, verwendet 70% weniger VRAM und unterstützt 10x längere Kontextlängen. gpt-oss-20b QLoRA-Training passt auf 14GB VRAM, und gpt-oss-120b funktioniert auf 65GB VRAM.

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

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

Lies unser Schritt-für-Schritt-Tutorial zur Feinabstimmung von gpt-oss:

Tutorial: Wie man gpt-oss feinabstimmt

Du kannst jetzt dein QLoRA-feinjustiertes gpt-oss-Modell nach llama.cpp, vLLM, HF etc. exportieren/speichern.

Kostenlose Unsloth-Notebooks zum Feinabstimmen von gpt-oss:

• gpt-oss-20b Reasoning- + Konversations-Notebook

Verstärkendes Lernen (GRPO)

Unsloth unterstützt jetzt RL für gpt-oss! Wir haben zwei Notebooks erstellt, für mehr Details lies unseren spezifischen Blog zu gpt-oss RL: gpt-oss RL

2048-Notebook (Offizielles OpenAI-Beispiel)	Kernel-Generations-Notebook

💾NEU: Speichern in GGUF, vLLM nach gpt-oss-Training

Du kannst jetzt QLoRA-feinjustiertes gpt-oss direkt speichern, exportieren oder zusammenführen zu llama.cpp, vLLM, oder HF - nicht nur Unsloth. Wir werden hoffentlich bald ein kostenloses Notebook veröffentlichen.

Früher war jedes QLoRA-feinjustierte gpt-oss-Modell darauf beschränkt, in Unsloth zu laufen. Wir haben diese Einschränkung durch die Einführung von on-demand Dequantisierung von MXFP4 Basismodellen (wie gpt-oss) während des LoRA-Merge-Prozesses entfernt. Dadurch ist es möglich, dein feinjustiertes Modell im bf16-Format zu exportieren.

Nach der Feinabstimmung deines gpt-oss-Modells kannst du es jetzt mit einem einzigen Befehl:

model.save_pretrained_merged(save_directory, tokenizer)

Wenn du es vorziehst, das Modell zu mergen und stattdessen direkt zum Hugging Face Hub zu pushen, kannst du das tun mit:

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

💡Effiziente gpt-oss-Feinabstimmung ermöglichen

Wir haben festgestellt, dass MXFP4 zwar sehr effizient ist, aber nicht nativ Training mit gpt-oss unterstützt. Um diese Einschränkung zu überwinden, implementierten wir benutzerdefinierte Trainingsfunktionen speziell für MXFP4-Layer, indem wir sie über Bitsandbytes NF4-Quantisierung

nachahmten. Wir nutzten OpenAIs Triton-Kernels-Bibliothek direkt, um MXFP4-Inferenz zu ermöglichen. Für Feinabstimmung/Training unterstützen die MXFP4-Kernels jedoch noch kein Training, da der Backward-Pass noch nicht implementiert ist. Wir arbeiten aktiv daran, ihn in Triton zu implementieren! Es gibt ein Flag namens W_TRANSPOSE wie erwähnt hier, das implementiert werden sollte. Die Ableitung kann durch die Transponierte der Gewichtsmatrizen berechnet werden, daher müssen wir die Transponier-Operation implementieren.

Wenn du gpt-oss mit einer anderen Bibliothek als Unsloth trainieren willst, musst du die Gewichte vor dem Training auf bf16 hochstufen. Dieser Ansatz erhöht erheblich sowohl VRAM-Nutzung als auch Trainingszeit um bis zu 300% mehr Speicherbedarf! ALLE anderen Trainingsmethoden benötigen mindestens 65GB VRAM, um das 20B-Modell zu trainieren, während Unsloth nur 14GB VRAM (-80%) verlangt.

Da beide Modelle MoE-Architektur verwenden, wählt das 20B-Modell 4 Experten von 32 aus, während das 120B-Modell pro Token 4 von 128 auswählt. Während Training und Veröffentlichung werden Gewichte im MXFP4-Format als nn.Parameter Objekte gespeichert, nicht als nn.Linear Layer, was die Quantisierung verkompliziert, insbesondere da MoE/MLP-Experten etwa 19B der 20B-Parameter ausmachen.

Um BitsandBytes Quantisierung und speichereffizientes Fine-Tuning zu ermöglichen, konvertierten wir diese Parameter in nn.Linear Layer. Obwohl dies Operationen etwas verlangsamt, erlaubt es Fine-Tuning auf GPUs mit begrenztem Speicher, ein lohnender Kompromiss.

Leitfaden zum Feinabstimmen von Datensätzen

Obwohl gpt-oss nur Reasoning unterstützt, kannst du es trotzdem mit einem nicht-reasoning Datensatzfeinjustieren, aber das kann seine Reasoning-Fähigkeit beeinträchtigen. Wenn du seine Reasoning-Fähigkeiten beibehalten möchtest (optional), kannst du eine Mischung aus direkten Antworten und Chain-of-Thought-Beispielen verwenden. Nutze mindestens 75% Reasoning und 25% Nicht-Reasoning in deinem Datensatz, damit das Modell seine Reasoning-Fähigkeiten behält.

Unser gpt-oss-20b Konversations-Notebook verwendet OpenAIs Beispiel, welches Hugging Faces Multilingual-Thinking-Datensatz ist. Der Zweck der Verwendung dieses Datensatzes ist es, dem Modell das Erlernen und Entwickeln von Reasoning-Fähigkeiten in diesen vier unterschiedlichen Sprachen zu ermöglichen.