gpt-oss: Anleitung zum Ausführen

Führe OpenAIs neue Open-Source-Modelle aus und feineinstelle sie!

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

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

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 brillieren bei Funktionsaufrufen und CoT-Schlussfolgerungen und übertreffen o1 und GPT-4o.

Für beste Leistung stelle sicher, dass dein insgesamt verfügbarer Speicher (vereinheitlichter Speicher + VRAM + System-RAM) größer ist als die Größe der quantisierten Modell-Datei, die du herunterlädst. Falls nicht, kann llama.cpp weiterhin über SSD/HDD-Auslagerung laufen, aber die Inferenz wird langsamer sein.

gpt-oss - Unsloth GGUFs:

Enthält Unsloths Chat-Template-Korrekturen. Für beste Ergebnisse nutze unsere Uploads & trainiere mit Unsloth!

• 20B: gpt-oss-20B

• 120B: gpt-oss-120B

📜Unsloth-Korrekturen für gpt-oss

Einige unserer Korrekturen wurden upstream in OpenAIs offizielles Modell auf Hugging Face übernommen. Siehe

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

Inference-Engines verwenden im Allgemeinen stattdessen das jinja-Chat-Template und nicht das Harmony-Paket, und wir fanden einige Probleme bei einem direkten Vergleich mit Harmony. Wenn du weiter unten schaust, ist oben die korrekte gerenderte Form wie von Harmony. Unten ist diejenige, die vom aktuellen jinja-Chat-Template gerendert wird. Es gibt ziemlich viele Unterschiede!

Wir haben auch einige Funktionen erstellt, die es dir ermöglichen, OpenAIs Harmony-Bibliothek direkt ohne ein jinja-Chat-Template zu verwenden, wenn du 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": "What's the temperature in San Francisco now? How about tomorrow? Today's date is 2024-09-30."},
    {"role": "assistant",  "content": "User asks: 'What is the weather in San Francisco?' We need to use get_current_temperature tool.", "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(
    messages,
    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 verändert gpt-oss' Reasoning-Budget – generell 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 sollte am besten unverändert bleiben – du kannst sie bearbeiten, aber wir sind uns nicht sicher, ob benutzerdefinierte funktionieren werden.

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

1. Funktions- und Werkzeugaufrufe werden mit tojson, gerendert, was in Ordnung ist, da 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 Zeilenumbrüche im jinja-Template an einigen Grenzen.

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

4. Andere Chat-Templates scheinen <|channel|>final überhaupt nicht zu verwenden – dies sollte für die finale Assistenten-Nachricht genutzt werden. Du solltest es nicht für Denkspuren oder Werkzeugaufrufe verwenden.

Unsere Chat-Templates für das GGUF, unsere BnB- und BF16-Uploads und alle Versionen sind korrigiert! Zum Beispiel ergeben beim Vergleich unseres Formats und des Harmony-Formats keine unterschiedlichen Zeichen:

🔢 Genauigkeitsprobleme

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

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

Software-Emulation ermöglicht das Anvisieren von Hardware-Architekturen ohne native Unterstützung für Microscaling-Operationen. Im Moment werden in solchen Fällen die microskalierten lhs/rhs vorher auf bf16 Elementtyp hochkonvertiert für die Dot-Berechnung,

Wir fanden heraus, dass wenn du float16 als Mixed-Precision-Autocast-Datentyp verwendest, du nach einiger Zeit Infinities bekommst. Um dem entgegenzuwirken, haben wir festgestellt, dass das MoE in bfloat16 durchgeführt wird und danach entweder in bfloat16 oder float32 verbleibt. Wenn ältere GPUs nicht einmal bfloat16-Unterstützung haben (wie T4), wird float32 verwendet.

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

🖥️ gpt-oss ausführen

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

Jede Quantisierung, die kleiner als F16 ist, einschließlich 2-Bit, hat einen minimalen Genauigkeitsverlust, da nur einige Teile (z. B. Attention-Schichten) niedrigere Bits nutzen, während die meisten Schichten in voller Präzision verbleiben. Deshalb sind die Größen nahe am F16-Modell; zum Beispiel ist die 2-Bit-Version (11,5 GB) nahezu so leistungsfähig 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.

Das gpt-oss Modell von OpenAI enthält eine Funktion, mit der Nutzer den "Reasoning Effort" des Modells anpassen können. Das gibt dir Kontrolle über den Kompromiss zwischen Modellleistung und Antwortgeschwindigkeit (Latenz), bestimmt durch die Anzahl der Token, die das Modell zum Nachdenken verwendet.

Das gpt-oss Modelle bieten drei verschiedene Stufen des Reasoning Effort, aus denen du wählen kannst:

• Niedrig: Optimiert für Aufgaben, die sehr schnelle Antworten benötigen und keine komplexen, mehrstufigen Schlussfolgerungen erfordern.

• Mittel: Ein Gleichgewicht zwischen Leistung und Geschwindigkeit.

• Hoch: Bietet die stärkste Reasoning-Leistung 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

• Temperature von 1.0

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

• Top_P = 1.0

• Empfohlener minimaler Kontext: 16.384

• Maximale Kontextlänge: 131.072

Chat-Template:

<|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-Token für Satz/Generierung: EOS ist <|return|>

gpt-oss-20B ausführen

Um Inferenzgeschwindigkeiten von 6+ Token pro Sekunde für unsere Dynamic-4-Bit-Quantisierung zu erreichen, solltest du mindestens haben 14 GB vereinheitlichten Speicher (kombinierter VRAM und RAM) oder 14 GB System-RAM allein. Als Faustregel sollte dein verfügbarer Speicher der Größe des verwendeten Modells entsprechen oder diese übertreffen. GGUF-Link: unsloth/gpt-oss-20b-GGUF

HINWEIS: Das Modell kann mit weniger Speicher als seiner Gesamtgröße laufen, aber das verlangsamt die Inferenz. Maximales Gedächtnis ist nur für die schnellsten Geschwindigkeiten nötig.

Befolge die oben genannten Best Practices. Sie sind dieselben wie beim 120B-Modell.

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

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

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

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 Tutorial ausführen

1. Hole dir das neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anleitungen 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

1. Du kannst 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. Lade das Modell herunter via (nach Installation von pip install huggingface_hub hf_transfer ). Wenn Downloads hängen bleiben, 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+ Token pro Sekunde für unsere 1-Bit-Quantisierung zu erreichen, empfehlen wir mindestens 66 GB vereinheitlichten Speicher (kombinierter VRAM und RAM) oder 66 GB System-RAM allein. Als Faustregel sollte dein verfügbarer Speicher der Größe des verwendeten Modells entsprechen oder diese übertreffen. GGUF-Link: unsloth/gpt-oss-120b-GGUF

HINWEIS: Das Modell kann mit weniger Speicher als seiner Gesamtgröße laufen, aber das verlangsamt die Inferenz. Maximales Gedächtnis ist nur für die schnellsten Geschwindigkeiten nötig.

Befolge die oben genannten Best Practices. Sie sind dieselben wie beim 20B-Modell.

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

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

Wenn du eine vollpräzise unquantisierte Version, nutze unsere F16 Versionen!

1. Hole dir das neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anleitungen 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 zum Herunterladen des Modells verwenden, aber ich empfehle normalerweise die Nutzung von huggingface_hub Um llama.cpp direkt zu verwenden, mache:

   {% code overflow="wrap" %}

   ./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 \

   {% endcode %}

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 auslösen, 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. Bearbeite --threads -1 für die Anzahl der CPU-Threads, --ctx-size 262114 für Kontextlänge, --n-gpu-layers 99 für GPU-Offloading, also wie viele Layer. Versuche, es anzupassen, wenn deine GPU in den OOM geht. Entferne es auch, wenn du nur CPU-Inferenz hast.

Verwende -ot ".ffn_.*_exps.=CPU" um alle MoE-Schichten auf die CPU auszulagern! Das ermöglicht es effektiv, alle Nicht-MoE-Schichten auf einer GPU unterzubringen und verbessert die Generierungsgeschwindigkeit. Du kannst den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn du mehr GPU-Kapazität hast. Mehr Optionen werden 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 \

🛠️ Verbesserung der Generierungsgeschwindigkeit

Wenn du mehr VRAM hast, kannst du versuchen, mehr MoE-Schichten auszulagern oder ganze Schichten selbst auszulagern.

Normalerweise, -ot ".ffn_.*_exps.=CPU" lagert alle MoE-Schichten auf die CPU aus! Das ermöglicht es effektiv, alle Nicht-MoE-Schichten auf einer GPU unterzubringen und verbessert die Generierungsgeschwindigkeit. Du kannst den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn du mehr GPU-Kapazität hast.

Wenn du etwas mehr GPU-Speicher hast, versuche -ot ".ffn_(up|down)_exps.=CPU" Dies lagert up- und down-Projektions-MoE-Schichten aus.

Versuche -ot ".ffn_(up)_exps.=CPU" wenn du noch mehr GPU-Speicher hast. Dies lagert nur up-Projektions-MoE-Schichten aus.

Du kannst den Regex auch 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.

Das neueste llama.cpp-Version führt außerdem einen Hochdurchsatzmodus ein. Verwende llama-parallel. Lies mehr darüber hier. Du kannst außerdem den KV-Cache auf 4-Bit quantisieren zum Beispiel, um VRAM-/RAM-Bewegungen zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann.

🦥 Feinabstimmung von gpt-oss mit Unsloth

Update vom 28. Aug: Du kannst jetzt dein QLoRA-feinabgestimmtes gpt-oss-Modell exportieren/speichern für llama.cpp, vLLM, HF usw.

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

Unsloth gpt-oss Feinabstimmung ist 1,5× schneller, nutzt 70% weniger VRAM und unterstützt 10× 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-feinabgestimmtes gpt-oss-Modell exportieren/speichern für llama.cpp, vLLM, HF usw.

Kostenlose Unsloth-Notebooks zum Feinabstimmen von gpt-oss:

• gpt-oss-20b Reasoning + Konversationelles Notebook

Reinforcement Learning (GRPO)

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

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

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

Du kannst jetzt gpt-oss mit QLoRA feinabstimmen und das Modell 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-feinabgestimmte gpt-oss-Modell darauf beschränkt, in Unsloth zu laufen. Wir haben diese Einschränkung aufgehoben, indem wir On-Demand-Dequantisierung von MXFP4 Basis-Modellen (wie gpt-oss) während des LoRA-Merge-Prozesses eingeführt haben. Dadurch ist es möglich, dein feinabgestimmtes Modell im bf16-Format zu exportieren.

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

model.save_pretrained_merged(save_directory, tokenizer)

Wenn du es bevorzugst, das Modell zusammenzuführen und direkt zum Hugging Face Hub zu pushen, kannst du das stattdessen mit folgendem tun:

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

💡Effizientes Feinabstimmen von gpt-oss ermöglichen

Wir stellten fest, dass obwohl MXFP4 sehr effizient ist, es nicht nativ das Training mit gpt-oss unterstützt. Um diese Einschränkung zu überwinden, haben wir benutzerdefinierte Trainingsfunktionen speziell für MXFP4-Schichten implementiert, indem wir sie durch Bitsandbytes NF4-Quantisierung

nachahmten. Wir nutzten OpenAIs Triton-Kernels-Bibliothek direkt, um MXFP4-Inferenz zu ermöglichen. Für Feinabstimmung/Training allerdings unterstützen die MXFP4-Kernels 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 hierwie erwähnt

, 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 möchtest, musst du die Gewichte vor dem Training auf bf16 hochkonvertieren. Dieser Ansatz erhöht jedoch signifikant sowohl VRAM-Nutzung als auch Trainingszeit um bis zu! 300% mehr Speicherverbrauch

ALLE anderen Trainingsmethoden werden mindestens 65GB VRAM benötigen, um das 20b-Modell zu trainieren, während Unsloth nur 14GB VRAM benötigt (-80%). Da beide Modelle MoE-Architektur verwenden, wählt das 20B-Modell 4 Experten aus 32, während das 120B-Modell pro Token 4 aus 128 auswählt. Während Training und Veröffentlichung werden Gewichte im MXFP4-Format als nn.Parameter Objekte gespeichert, nicht als nn.Linear

Schichten, was die Quantisierung verkompliziert, insbesondere da MoE/MLP-Experten etwa 19B der 20B-Parameter ausmachen. Um BitsandBytes Objekte gespeichert, nicht als Quantisierung und speichereffiziente Feinabstimmung zu ermöglichen, konvertierten wir diese Parameter in

Schichten. Obwohl dies die Operationen leicht verlangsamt, ermöglicht es die Feinabstimmung auf GPUs mit begrenztem Speicher – ein lohnenswerter Kompromiss.

Anleitung zur Feinabstimmung von Datensätzen Obwohl gpt-oss nur Reasoning unterstützt, kannst du es trotzdem mit einem nicht-Reasoning-Datensatz feinabstimmen, 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 und 75% Reasoning 25% Nicht-Reasoning

in deinem Datensatz, damit das Modell seine Reasoning-Fähigkeiten behält.","t306":"Unser gpt-oss-20b Konversations-Notebook verwendet OpenAIs Beispiel, das Hugging Faces Multilingual-Thinking-Datensatz ist. Der Zweck der Verwendung dieses Datensatzes ist es, dem Modell zu ermöglichen, Reasoning-Fähigkeiten in diesen vier verschiedenen Sprachen zu erlernen und zu entwickeln."}