# gpt-oss: Leitfaden zum Ausführen OpenAI veröffentlicht '**gpt-oss-120b'** und '**gpt-oss-20b'**, zwei SOTA-Open-Source-Sprachmodelle unter der Apache-2.0-Lizenz. Beide 128k-Kontextmodelle übertreffen ähnlich große offene Modelle bei Schlussfolgerungen, Tool-Nutzung 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**](#fine-tuning-gpt-oss-with-unsloth) **gpt-oss-20b kostenlos mit unserem** [**Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-Fine-tuning.ipynb) Trainiert mit [RL](/docs/de/loslegen/reinforcement-learning-rl-guide.md), **gpt-oss-120b** konkurriert mit o4-mini und **gpt-oss-20b** konkurriert mit o3-mini. Beide glänzen beim Funktionsaufruf und bei CoT-Reasoning und übertreffen o1 und GPT-4o. Für beste Leistung stelle sicher, dass dein insgesamt verfügbarer Speicher (Unified Memory + VRAM + Systemspeicher) die Größe der quantisierten Modelldatei übersteigt, die du herunterlädst. Wenn nicht, kann llama.cpp trotzdem per SSD-/HDD-Auslagerung ausgeführt werden, aber die Inferenz wird langsamer sein. #### **gpt-oss - Unsloth GGUFs:** {% hint style="success" %} **Enthält Unsloths** [**Korrekturen am Chat-Template**](#unsloth-fixes-for-gpt-oss)**. Für beste Ergebnisse verwende unsere Uploads und trainiere mit Unsloth!** {% endhint %} * 20B: [gpt-oss-**20B**](https://huggingface.co/unsloth/gpt-oss-20b-GGUF) * 120B: [gpt-oss-**120B**](https://huggingface.co/unsloth/gpt-oss-120b-GGUF) ## :scroll:Unsloth-Korrekturen für gpt-oss {% hint style="info" %} Einige unserer Korrekturen wurden in OpenAIs offizielles Modell auf Hugging Face upstream übernommen. [Siehe](https://huggingface.co/openai/gpt-oss-20b/discussions/94/files) {% endhint %} OpenAI veröffentlichte eine eigenständige Parsing- und Tokenisierungsbibliothek namens [Harmony](https://github.com/openai/harmony) die es ermöglicht, Konversationen in OpenAIs bevorzugtes Format für gpt-oss zu tokenisieren. Inferenz-Engines verwenden stattdessen im Allgemeinen die jinja-Chatvorlage und nicht das Harmony-Paket, und wir haben nach dem direkten Vergleich mit Harmony einige Probleme damit gefunden. Wie du unten siehst, ist der obere Teil die korrekte gerenderte Form wie bei Harmony. Der untere ist der aktuell von der jinja-Chatvorlage gerenderte. Es gibt einige Unterschiede!
Wir haben außerdem einige Funktionen erstellt, mit denen du OpenAIs Harmony-Bibliothek direkt verwenden kannst, ohne wenn gewünscht eine jinja-Chatvorlage zu benutzen - du kannst einfach normale Konversationen wie unten parsen: ```python messages = [ {"role" : "user", "content" : "Was ist 1+1?"}, {"role" : "assistant", "content" : "2"}, {"role": "user", "content": "Wie ist die Temperatur in San Francisco jetzt? Und morgen? Das heutige Datum ist der 30.09.2024."}, {"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, Kalifornien, Vereinigte Staaten", "unit": "celsius"}'}]}, {"role": "tool", "name": "get_current_temperature", "content": '{"temperature": 19.9, "location": "San Francisco, Kalifornien, Vereinigte Staaten", "unit": "celsius"}'}, ] ``` Dann verwende die `encode_conversations_with_harmony` Funktion von Unsloth: ```python 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 = "Du bist ChatGPT, ein großes Sprachmodell, das von OpenAI trainiert wurde.", ) ``` Das Harmony-Format umfasst mehrere interessante Dinge: 1. `reasoning_effort = "medium"` Du kannst low, medium oder high wählen, und das verä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 funktionieren werden. Wir finden mehrere Probleme mit den aktuellen jinja-Chatvorlagen (es gibt mehrere Implementierungen im gesamten Ökosystem): 1. Funktionen und Tool-Aufrufe werden mit `tojson`gerendert, was okay ist, wenn es ein Dict ist, aber wenn es ein String ist, werden Anführungszeichen und andere **Symbole mit Backslashes versehen**. 2. Es gibt einige **zusätzliche Zeilenumbrüche** in der jinja-Vorlage an einigen Grenzen. 3. Die Gedanken des Modells beim Tool-Calling sollten das **`analysis` -Tag und nicht `final` -Tag**. 4. Andere Chatvorlagen scheinen `<|channel|>final` gar nicht zu verwenden - man sollte dies für die finale Assistenten-Nachricht verwenden. Du solltest dies nicht für Gedankengänge oder Tool-Aufrufe verwenden. Unsere Chatvorlagen für die GGUF-, BnB- und BF16-Uploads sowie alle Versionen sind korrigiert! Wenn wir zum Beispiel unsere und H armonys Form vergleichen, erhalten wir keine unterschiedlichen Zeichen:
### :1234: Präzisionsprobleme Wir haben mehrere Präzisionsprobleme auf Tesla-T4- und Float16-Maschinen gefunden, hauptsächlich weil das Modell mit BF16 trainiert wurde und daher Ausreißer und Überläufe vorhanden waren. MXFP4 wird auf Ampere- und älteren GPUs tatsächlich nicht unterstützt, daher stellt Triton `tl.dot_scaled` für die MXFP4-Matrixmultiplikation bereit. Dabei werden die Matrizen intern im laufenden Betrieb auf BF16 hochgestuft. Wir haben ein [MXFP4-Inferenz-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/GPT_OSS_MXFP4_\(20B\)-Inference.ipynb) auch in Tesla-T4-Colab erstellt! {% hint style="info" %} [Software-Emulation](https://triton-lang.org/main/python-api/generated/triton.language.dot_scaled.html) ermöglicht das Anvisieren von Hardwarearchitekturen ohne native Unterstützung für Mikroskalierungsoperationen. Derzeit werden in so einem Fall mikroskalierte lhs/rhs zuvor auf den `bf16` Elementtyp hochgestuft, um die Dot-Berechnung durchzuführen, {% endhint %} Wir haben festgestellt, dass du bei Verwendung von float16 als Datentyp für Mixed-Precision-Autocast nach einiger Zeit Unendlichkeiten erhältst. Um dem entgegenzuwirken, haben wir festgestellt, dass es hilft, das MoE in bfloat16 auszuführen und es dann entweder in bfloat16- oder float32-Präzision zu belassen. Wenn ältere GPUs nicht einmal bfloat16-Unterstützung haben (wie T4), wird float32 verwendet. Wir ändern auch alle Präzisionen von Operationen (wie dem Router) für float16-Maschinen auf float32. ## 🖥️ **gpt-oss ausführen** Unten sind Anleitungen für die [20B](#run-gpt-oss-20b) und [120B](#run-gpt-oss-120b) Varianten des Modells. {% hint style="info" %} Jede Quantisierung kleiner als F16, einschließlich 2-Bit, hat nur einen minimalen Genauigkeitsverlust, da nur einige Teile (z. B. die Attention-Layers) mit niedrigerer Bitbreite vorliegen, während der Großteil vollpräzise bleibt. Deshalb liegen die Größen nahe am F16-Modell; beispielsweise verhält sich die 2-Bit-Version (11,5 GB) nahezu genauso wie die vollständige 16-Bit-Version (14 GB). Sobald llama.cpp eine bessere Quantisierung für diese Modelle unterstützt, laden wir sie so schnell wie möglich hoch. {% endhint %} Die `gpt-oss` Modelle von OpenAI enthalten eine Funktion, mit der Benutzer die „Reasoning Effort“ des Modells anpassen können. Damit kannst du den Kompromiss zwischen der Leistung des Modells und seiner Antwortgeschwindigkeit (Latenz) steuern, der davon abhängt, wie viele Token das Modell zum Nachdenken verwendet. Die `gpt-oss` Modelle bieten drei unterschiedliche Stufen des Reasoning Efforts, aus denen du wählen kannst: * **Niedrig**: Optimiert für Aufgaben, die sehr schnelle Antworten erfordern und kein komplexes, mehrstufiges Denken benötigen. * **Mittel**: Ein Gleichgewicht zwischen Leistung und Geschwindigkeit. * **Hoch**: Bietet die stärkste Reasoning-Leistung für Aufgaben, die sie benötigen, allerdings mit höherer Latenz. ### :gear: 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|>Du bist ChatGPT, ein großes Sprachmodell, das von OpenAI trainiert wurde.\nKnowledge cutoff: 2024-06\nCurrent date: 2025-08-05\n\nReasoning: medium\n\n# Gültige Kanäle: analysis, commentary, final. Der Kanal muss für jede Nachricht enthalten sein.<|end|><|start|>user<|message|>Hallo<|end|><|start|>assistant<|channel|>final<|message|>Hallo!<|end|><|start|>user<|message|>Was ist 1+1?<|end|><|start|>assistant ``` Das End-of-Sentence-/Generierungstoken: EOS ist `<|return|>` ### gpt-oss-20B ausführen
Um Inferenzgeschwindigkeiten von 6+ Tokens pro Sekunde für unsere dynamische 4-Bit-Quantisierung zu erreichen, solltest du mindestens haben **14 GB Unified Memory** (kombinierter VRAM und RAM) oder **14 GB Systemspeicher** allein. Als Faustregel sollte dein verfügbarer Speicher der Größe des von dir verwendeten Modells entsprechen oder diese übersteigen. GGUF-Link: [unsloth/gpt-oss-20b-GGUF](https://huggingface.co/unsloth/gpt-oss-20b-GGUF) **HINWEIS:** Das Modell kann mit weniger Speicher als seiner Gesamtgröße ausgeführt werden, aber das verlangsamt die Inferenz. Der maximale Speicher wird nur für die schnellsten Geschwindigkeiten benötigt. {% hint style="info" %} Befolge die [**bewährten Vorgehensweisen oben**](#recommended-settings). Sie sind dieselben wie beim 120B-Modell. {% endhint %} Du kannst das Modell vorerst auf Google Colab, Docker, LM Studio oder llama.cpp ausführen. Siehe unten: > **Du kannst gpt-oss-20b kostenlos mit unserem ausführen** [**Google-Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/GPT_OSS_MXFP4_\(20B\)-Inference.ipynb) #### 🦥 Unsloth Studio-Anleitung Für dieses Tutorial verwenden wir [Unsloth Studio](/docs/de/neu/studio.md), unsere neue Web-UI zum Ausführen und Trainieren von LLMs. Mit Unsloth Studio können Sie Modelle lokal ausführen auf **Mac, Windows**und Linux eingeben und: {% columns %} {% column %} * Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle * **Modelle** vergleichen **nebeneinander** * [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche** * [**Code-Ausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash) * [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameter-Tuning (Temp, Top-p usw.) * [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70% weniger VRAM {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Unsloth installieren Führen Sie es in Ihrem Terminal aus: **MacOS, Linux, WSL:** ```bash curl -fsSL https://unsloth.ai/install.sh | sh ``` **Windows PowerShell:** ```bash irm https://unsloth.ai/install.ps1 | iex ``` {% endstep %} {% step %} #### Unsloth starten **MacOS, Linux, WSL, Windows:** ```bash unsloth studio -H 0.0.0.0 -p 8888 ```
**Dann öffnen Sie `http://localhost:8888` in Ihrem Browser.** {% endstep %} {% step %} #### gpt-oss-20b suchen und herunterladen Beim ersten Start müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern, und sich später erneut anmelden. Anschließend sehen Sie einen kurzen Einrichtungsassistenten, in dem Sie ein Modell, einen Datensatz und grundlegende Einstellungen auswählen. Sie können ihn jederzeit überspringen. Gehen Sie dann zur [Studio Chat](/docs/de/neu/studio/chat.md) Tab und suche in der Suchleiste nach gpt-oss und lade das gewünschte Modell und die gewünschte Quantisierung herunter.
{% endstep %} {% step %} #### gpt-oss-20b ausführen Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden; Sie können sie jedoch weiterhin manuell ändern. Sie können auch die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten. Weitere Informationen finden Sie in unserer [Unsloth Studio-Inferenzanleitung](/docs/de/neu/studio/chat.md).
{% endstep %} {% endstepper %} #### 🐋 Docker: Tutorial zum Ausführen von gpt-oss-20b Wenn du bereits Docker Desktop hast, musst du nur den folgenden Befehl ausführen, und fertig: ```bash docker model run hf.co/unsloth/gpt-oss-20b-GGUF:F16 ``` #### :sparkles: Llama.cpp: Tutorial zum Ausführen von gpt-oss-20b 1. Hole dir die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). 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. **Für Apple Mac / Metal-Geräte**, setze `-DGGML_CUDA=OFF` und fahre dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert. ```bash 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. Sie können direkt von Hugging Face ziehen über: ```bash ./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 ``` 3. Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Wenn Downloads hängen bleiben, siehe [Hugging Face Hub, XET-Debugging](/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md) ```python # !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 Unified Memory** (kombinierter VRAM und RAM) oder **66 GB Systemspeicher** allein. Als Faustregel sollte dein verfügbarer Speicher der Größe des von dir verwendeten Modells entsprechen oder diese übersteigen. GGUF-Link: [unsloth/gpt-oss-120b-GGUF](https://huggingface.co/unsloth/gpt-oss-120b-GGUF) **HINWEIS:** Das Modell kann mit weniger Speicher als seiner Gesamtgröße ausgeführt werden, aber das verlangsamt die Inferenz. Der maximale Speicher wird nur für die schnellsten Geschwindigkeiten benötigt. {% hint style="info" %} Befolge die [**bewährten Vorgehensweisen oben**](#recommended-settings). Sie sind dieselben wie beim 20B-Modell. {% endhint %} #### 🦥 Unsloth Studio-Anleitung Für dieses Tutorial verwenden wir [Unsloth Studio](/docs/de/neu/studio.md), unsere neue Web-UI zum Ausführen und Trainieren von LLMs. Mit Unsloth Studio können Sie Modelle lokal ausführen auf **Mac, Windows**und Linux eingeben und: {% columns %} {% column %} * Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle * **Modelle** vergleichen **nebeneinander** * [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche** * [**Code-Ausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash) * [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameter-Tuning (Temp, Top-p usw.) * [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70% weniger VRAM {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Unsloth installieren **MacOS, Linux, WSL:** ```bash curl -fsSL https://unsloth.ai/install.sh | sh ``` **Windows PowerShell:** ```bash irm https://unsloth.ai/install.ps1 | iex ``` {% endstep %} {% step %} #### Unsloth Studio einrichten (einmalig) Die Einrichtung installiert automatisch Node.js (über nvm), baut das Frontend, installiert alle Python-Abhängigkeiten und baut llama.cpp mit CUDA-Unterstützung. {% hint style="info" %} **WSL-Benutzer:** Sie werden aufgefordert, Ihr `sudo` Passwort einzugeben, um Build-Abhängigkeiten zu installieren (`cmake`, `git`, `libcurl4-openssl-dev`). {% endhint %} {% endstep %} {% step %} #### Unsloth starten **MacOS, Linux, WSL:** ```bash source unsloth_studio/bin/activate unsloth studio -H 0.0.0.0 -p 8888 ``` **Windows PowerShell:** ```bash & .\unsloth_studio\Scripts\unsloth.exe studio -H 0.0.0.0 -p 8888 ```
**Dann öffnen Sie `http://localhost:8888` in Ihrem Browser.** {% endstep %} {% step %} #### gpt-oss-120b suchen und herunterladen Beim ersten Start müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern, und sich später erneut anmelden. Anschließend sehen Sie einen kurzen Einrichtungsassistenten, in dem Sie ein Modell, einen Datensatz und grundlegende Einstellungen auswählen. Sie können ihn jederzeit überspringen. Gehen Sie dann zur [Studio Chat](/docs/de/neu/studio/chat.md) Tab und suche in der Suchleiste nach gpt-oss und lade das gewünschte Modell und die gewünschte Quantisierung herunter.
{% endstep %} {% step %} #### gpt-oss-120b ausführen Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden; Sie können sie jedoch weiterhin manuell ändern. Sie können auch die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten. Weitere Informationen finden Sie in unserer [Unsloth Studio-Inferenzanleitung](/docs/de/neu/studio/chat.md).
{% endstep %} {% endstepper %} #### 📖 Llama.cpp: Tutorial zum Ausführen von gpt-oss-120b Für gpt-oss-120b werden wir speziell Llama.cpp für optimierte Inferenz verwenden. {% hint style="success" %} Wenn du eine **vollpräzise, unquantisierte Version**möchtest, verwende unsere `F16` Versionen! {% endhint %} 1. Hole dir die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). 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. ```bash 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 Verwendung von `huggingface_hub` Um llama.cpp direkt zu verwenden, gehe wie folgt vor: ```bash ./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 \ ``` 3. Oder lade das Modell über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst UD-Q2\_K\_XL oder andere quantisierte Versionen wählen.. ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal eine Ratenbegrenzung auslösen, daher 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 einen beliebigen Prompt aus. 5. Bearbeiten `--threads -1` für die Anzahl der CPU-Threads bearbeiten, `--ctx-size` 262114 für die Kontextlänge, `--n-gpu-layers 99` für GPU-Offloading, also für wie viele Layer. Versuchen Sie, dies anzupassen, wenn Ihrem GPU-Speicher der Platz ausgeht. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben. {% hint style="success" %} Verwende `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Layers auf die CPU auszulagern! Dadurch kannst du effektiv alle Nicht-MoE-Layers auf 1 GPU unterbringen und die Generierungsgeschwindigkeiten verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Layers unterzubringen, wenn du mehr GPU-Kapazität hast. Weitere Optionen werden besprochen [hier](#improving-generation-speed). {% endhint %} {% code overflow="wrap" %} ```bash ./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 \ ``` {% endcode %} ### :tools: Die Generierungsgeschwindigkeit verbessern Wenn Sie mehr VRAM haben, können Sie versuchen, mehr MoE-Layer oder ganze Layer auszulagern. Normalerweise `-ot ".ffn_.*_exps.=CPU"` lagert alle MoE-Layer auf die CPU aus! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer 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 die MoE-Layer für Up- und Down-Projektionen aus. Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus. Sie können 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-Layer auszulagern, aber nur ab der 6. Schicht. Die [neueste llama.cpp-Version](https://github.com/ggml-org/llama.cpp/pull/14363) führt außerdem einen High-Throughput-Modus ein. Verwenden Sie `llama-parallel`. Lesen Sie mehr darüber [hier](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Sie können auch **den KV-Cache auf 4 Bit quantisieren** zum Beispiel um den VRAM-/RAM-Datenverkehr zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann. ## 🦥 Feinabstimmung von gpt-oss mit Unsloth {% hint style="success" %} [**Update vom 28. Aug.**](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/long-context-gpt-oss-training.md#new-saving-to-gguf-vllm-after-gpt-oss-training)**:** Du kannst dein mit QLoRA feinabgestimmtes gpt-oss-Modell jetzt nach llama.cpp, vLLM, HF usw. exportieren/speichern. Wir haben außerdem [Unsloth Flex Attention](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/long-context-gpt-oss-training.md#introducing-unsloth-flex-attention-support) eingeführt, wodurch **>8× längere Kontextlängen**, **>50 % weniger VRAM-Nutzung** und **>1,5× schnelleres Training** gegenüber allen Implementierungen möglich sind. [Hier mehr lesen](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/long-context-gpt-oss-training.md#introducing-unsloth-flex-attention-support) {% endhint %} Das Feinabstimmen von gpt-oss mit Unsloth ist 1,5x schneller, benötigt 70 % weniger VRAM und unterstützt 10x längere Kontextlängen. Das gpt-oss-20b-QLoRA-Training passt auf 14 GB VRAM, und gpt-oss-120b funktioniert mit 65 GB VRAM. * **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. Lies unser Schritt-für-Schritt-Tutorial zur Feinabstimmung von gpt-oss: {% content-ref url="/pages/795c60e5aacc9878814ca680a7342a1f57e65aad" %} [Tutorial: Wie man gpt-oss feinabstimmt](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/tutorial-how-to-fine-tune-gpt-oss.md) {% endcontent-ref %} {% hint style="success" %} Du kannst dein mit QLoRA feinabgestimmtes gpt-oss-Modell jetzt nach llama.cpp, vLLM, HF usw. exportieren/speichern. {% endhint %} Kostenlose Unsloth-Notebooks zum Feinabstimmen von gpt-oss: * gpt-oss-20b [Notebook für Reasoning + Konversation](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-Fine-tuning.ipynb) ### Reinforcement Learning (GRPO) Unsloth unterstützt jetzt RL für gpt-oss! Wir haben zwei Notebooks erstellt; für weitere Details lies unseren speziellen Blog zu gpt-oss-RL: [gpt-oss RL](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/gpt-oss-reinforcement-learning.md) | [2048-Notebook](https://colab.research.google.com/github/openai/gpt-oss/blob/main/examples/reinforcement-fine-tuning.ipynb) (Offizielles OpenAI-Beispiel) | [Notebook zur Kernel-Generierung](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-GRPO.ipynb) | | --------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ### 💾**NEU: Speichern in GGUF, vLLM nach dem gpt-oss-Training** Du kannst gpt-oss jetzt 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. Bisher war jedes mit QLoRA feinabgestimmte gpt-oss-Modell auf die Ausführung in Unsloth beschränkt. Wir haben diese Einschränkung entfernt, indem wir **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 jetzt in ein 16-Bit-Format zusammenführen mit einem **einzelnen Befehl**: ```python model.save_pretrained_merged(save_directory, tokenizer) ``` Wenn du das Modell lieber zusammenführen und stattdessen direkt auf den Hugging-Face-Hub pushen möchtest, kannst du das folgendermaßen tun: ```python model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token=hf_token) ``` ### 💡Effizientes gpt-oss-Feinabstimmen zum Laufen bringen Wir haben festgestellt, dass MXFP4 zwar sehr effizient ist, aber das Training mit gpt-oss nicht nativ unterstützt. Um diese Einschränkung zu umgehen, haben wir benutzerdefinierte Trainingsfunktionen speziell für MXFP4-Layers implementiert, indem wir es durch Folgendes nachbilden: `Bitsandbytes` NF4-Quantisierung. Wir haben OpenAIs Triton-Kernels-Bibliothek direkt verwendet, um MXFP4-Inferenz zu ermöglichen. Für das Finetuning/Training unterstützen die MXFP4-Kernels das Training jedoch noch nicht, 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](https://github.com/triton-lang/triton/blob/main/python/triton_kernels/triton_kernels/matmul_ogs_details/_matmul_ogs.py#L39), das implementiert werden sollte. Die Ableitung kann durch die Transponierung der Gewichtsmatrizen berechnet werden, daher müssen wir die Transponierungsoperation implementieren. Wenn du gpt-oss mit einer anderen Bibliothek als Unsloth trainieren möchtest, musst du die Gewichte vor dem Training auf bf16 hochstufen. Dieser Ansatz **erhöht signifikant** sowohl die VRAM-Nutzung als auch die Trainingszeit um bis zu **300 % mehr Speicherverbrauch**! **ALLE anderen Trainingsmethoden erfordern mindestens 65 GB VRAM, um das 20B-Modell zu trainieren, während Unsloth nur 14 GB VRAM benötigt (-80 %).** Da beide Modelle die MoE-Architektur verwenden, wählt das 20B-Modell 4 Experten aus 32 aus, während das 120B-Modell pro Token 4 aus 128 auswählt. Während Training und Release werden die Gewichte im MXFP4-Format als `nn.Parameter` Objekte gespeichert, nicht als `nn.Linear` -Layers, was die Quantisierung erschwert, insbesondere da MoE-/MLP-Experten etwa 19B der 20B-Parameter ausmachen. Um `BitsandBytes` Quantisierung und speichereffizientes Feinabstimmen zu ermöglichen, haben wir diese Parameter in `nn.Linear` -Layers umgewandelt. Obwohl dies Operationen leicht verlangsamt, ermöglicht es das Feinabstimmen 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 [dataset](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md)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. Verwende mindestens 75 % Reasoning und 25 % nicht-Reasoning in Ihrem Datensatz, damit das Modell seine Reasoning-Fähigkeiten beibehält. Unser gpt-oss-20b-Kursiv-Notebook verwendet OpenAIs Beispiel, nämlich den Multilingual-Thinking-Datensatz von Hugging Face. Der Zweck der Verwendung dieses Datensatzes besteht darin, dem Modell zu ermöglichen, in diesen vier verschiedenen Sprachen Reasoning-Fähigkeiten zu erlernen und zu entwickeln.
--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.