> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md). # gpt-oss: Anleitung zum Ausführen OpenAI veröffentlicht '**gpt-oss-120b'** und '**gpt-oss-20b'**, zwei SOTA offene Sprachmodelle unter der Apache-2.0-Lizenz. Beide Modelle mit 128k Kontext übertreffen gleich große offene Modelle beim Schlussfolgern, bei der Werkzeugnutzung und bei 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/los-gehts/reinforcement-learning-rl-guide.md), **gpt-oss-120b** ist auf Augenhöhe mit o4-mini und **gpt-oss-20b** ist auf Augenhöhe mit o3-mini. Beide glänzen bei Funktionsaufrufen und CoT-Reasoning und übertreffen o1 und GPT-4o. Für die beste Leistung stelle sicher, dass dein gesamter verfügbarer Speicher (vereinheitlichter Speicher + VRAM + Systemspeicher) die Größe der quantisierten Modelldatei übersteigt, die du herunterlädst. Wenn nicht, kann llama.cpp zwar weiterhin per Auslagerung auf SSD/HDD ausgeführt werden, aber die Inferenz wird langsamer sein. #### **gpt-oss - Unsloth-GGUFs:** {% hint style="success" %} **Enthält Unsloths** [**Korrekturen an der Chat-Vorlage**](#unsloth-fixes-for-gpt-oss)**. Für beste Ergebnisse verwende unsere Uploads & 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 upstream in OpenAIs offizielles Modell auf Hugging Face übernommen. [Siehe](https://huggingface.co/openai/gpt-oss-20b/discussions/94/files) {% endhint %} OpenAI hat eine eigenständige Parsing- und Tokenisierungsbibliothek namens [Harmony](https://github.com/openai/harmony) veröffentlicht, mit der man Unterhaltungen in OpenAIs bevorzugtes Format für gpt-oss tokenisieren kann. Inferenz-Engines verwenden im Allgemeinen stattdessen die Jinja-Chatvorlage und nicht das Harmony-Paket, und wir haben nach einem direkten Vergleich mit Harmony einige Probleme damit gefunden. Wie du unten sehen kannst, ist der obere Teil die korrekte gerenderte Form aus Harmony. Der untere ist der, der von der aktuellen Jinja-Chatvorlage gerendert wird. Es gibt einige Unterschiede!
Wir haben außerdem einige Funktionen erstellt, die es dir direkt ermöglichen, OpenAIs Harmony-Bibliothek ohne eine Jinja-Chatvorlage zu verwenden, falls du möchtest - du kannst einfach normale Unterhaltungen 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? Wie sieht es morgen aus? Das heutige Datum ist 2024-09-30."}, {"role": "assistant", "content": "Der Nutzer 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"}'}, ] ``` 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, trainiert von OpenAI.", ) ``` Das Harmony-Format enthält mehrere interessante Dinge: 1. `reasoning_effort = "medium"` Du kannst niedrig, mittel oder hoch wählen, und das verändert gpt-oss' Schlussfolgerungsbudget - 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. Wir stellen mehrere Probleme mit den aktuellen Jinja-Chatvorlagen fest (es gibt mehrere Implementierungen im gesamten Ökosystem): 1. Funktions- und Tool-Aufrufe werden gerendert mit `tojson`, was in Ordnung 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. Gedanken des Modells zum Tool-Aufruf sollten das **`analysis` Tag und nicht `final` Tag**. 4. Andere Chatvorlagen scheinen `<|channel|>final` überhaupt nicht zu verwenden - man sollte dies für die endgültige Assistentennachricht verwenden. Du solltest dies nicht für Gedankenspuren oder Tool-Aufrufe verwenden. Unsere Chatvorlagen für das GGUF, unsere BnB- und BF16-Uploads und alle Versionen sind behoben! Wenn wir zum Beispiel unser Format und das von Harmony 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 nicht wirklich unterstützt, daher bietet Triton `tl.dot_scaled` für die MXFP4-Matrixmultiplikation an. Es castet die Matrizen intern on the fly auf BF16 hoch. Wir haben ein [MXFP4-Inferenz-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/GPT_OSS_MXFP4_\(20B\)-Inference.ipynb) auch im Tesla-T4-Colab erstellt! {% hint style="info" %} [Softwareemulation](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 Microscaling-Operationen. Derzeit werden in einem solchen Fall microskalierte lhs/rhs vorher auf `bf16` Elementtyp für die Dot-Berechnung hochgestuft, {% endhint %} Wir haben festgestellt, dass du nach einiger Zeit Unendlichkeiten erhältst, wenn du float16 als gemischten Präzisions-Autocast-Datentyp verwendest. 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) auf float32 für float16-Maschinen. ## 🖥️ **gpt-oss ausführen** Unten findest du 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. Attention-Layer) mit geringerer Bitbreite sind, während die meisten in voller Präzision bleiben. Deshalb liegen die Größen nahe am F16-Modell; zum Beispiel verhält sich die 2-Bit-Version (11.5 GB) fast 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 %} Der `gpt-oss` Modelle von OpenAI enthalten eine Funktion, mit der Benutzer den "reasoning effort" des Modells anpassen können. Damit kontrollierst du den Kompromiss zwischen der Leistung des Modells und seiner Antwortgeschwindigkeit (Latenz), der sich danach richtet, wie viele Tokens das Modell zum Nachdenken verwendet. Der `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 kein komplexes, mehrstufiges Schlussfolgern erfordern. * **Mittel**: Ein Gleichgewicht zwischen Leistung und Geschwindigkeit. * **Hoch**: Bietet die stärkste Schlussfolgerungsleistung für Aufgaben, die sie erfordern, allerdings mit höherer Latenz. ### :gear: Empfohlene Einstellungen OpenAI empfiehlt diese Inference-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ängen-Fenster: 131,072 **Chat-Vorlage:** ``` <|start|>system<|message|>Du bist ChatGPT, ein großes Sprachmodell, trainiert von OpenAI.\nWissensstand: 2024-06\nAktuelles Datum: 2025-08-05\n\nSchlussfolgern: mittel\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 Satz-/Generierungsende-Token: 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 **14 GB einheitlichen Speichers** (kombinierter VRAM und RAM) oder **14 GB Systemspeicher** allein haben. Als Faustregel sollte dein verfügbarer Speicher der Größe des Modells entsprechen oder sie übersteigen, das du verwendest. 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. Maximaler Speicher wird nur für die höchsten Geschwindigkeiten benötigt. {% hint style="info" %} Befolge die [**oben genannten Best Practices**](#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** [**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 verwenden und: {% columns %} {% column %} * Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle * **Vergleichen** Modelle **nebeneinander** * [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche** * [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash) * [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameterabstimmung (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ühre in deinem 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 deinem Browser.** {% endstep %} {% step %} #### gpt-oss-20b suchen und herunterladen Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern, und dich später erneut anmelden. Danach siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen. Gehen Sie dann zur [Unsloth Chat](/docs/de/neu/studio/chat.md) Tab und suche in der Suchleiste nach gpt-oss und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter.
{% endstep %} {% step %} #### gpt-oss-20b ausführen Die Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst außerdem die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten. Für weitere Informationen können Sie unsere [Inferenzanleitung für Unsloth Studio](/docs/de/neu/studio/chat.md).
{% endstep %} {% endstepper %} #### 🐋 Docker: Anleitung zum Ausführen von gpt-oss-20b Wenn du Docker Desktop bereits installiert hast, musst du nur den folgenden Befehl ausführen und bist fertig: ```bash docker model run hf.co/unsloth/gpt-oss-20b-GGUF:F16 ``` #### :sparkles: Llama.cpp: Anleitung zum Ausführen von gpt-oss-20b 1. Holen Sie sich die neueste `llama.cpp` ein [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch den untenstehenden Build-Anweisungen folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen. **Für Apple-Mac-/Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie 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. Du kannst direkt von Hugging Face herunterladen ü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. Laden Sie das Modell über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Falls 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 einheitlichen Speichers** (kombinierter VRAM und RAM) oder **66 GB Systemspeicher** allein haben. Als Faustregel sollte dein verfügbarer Speicher der Größe des Modells entsprechen oder sie übersteigen, das du verwendest. 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. Maximaler Speicher wird nur für die höchsten Geschwindigkeiten benötigt. {% hint style="info" %} Befolge die [**oben genannten Best Practices**](#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 verwenden und: {% columns %} {% column %} * Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle * **Vergleichen** Modelle **nebeneinander** * [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche** * [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash) * [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameterabstimmung (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) Das Setup installiert automatisch Node.js (über nvm), baut das Frontend, installiert alle Python-Abhängigkeiten und kompiliert llama.cpp mit CUDA-Unterstützung. {% hint style="info" %} **WSL-Benutzer:** du wirst nach deinem `sudo` Passwort gefragt, 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 deinem Browser.** {% endstep %} {% step %} #### gpt-oss-120b suchen und herunterladen Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern, und dich später erneut anmelden. Danach siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen. Gehen Sie dann zur [Unsloth Chat](/docs/de/neu/studio/chat.md) Tab und suche in der Suchleiste nach gpt-oss und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter.
{% endstep %} {% step %} #### gpt-oss-120b ausführen Die Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst außerdem die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten. Für weitere Informationen können Sie unsere [Inferenzanleitung für Unsloth Studio](/docs/de/neu/studio/chat.md).
{% endstep %} {% endstepper %} #### 📖 Llama.cpp: Anleitung 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 **Version in voller Präzision ohne Quantisierung**, verwende unsere `F16` Versionen! {% endhint %} 1. Holen Sie sich die neueste `llama.cpp` ein [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch den untenstehenden Build-Anweisungen folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen. ```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, mache Folgendes: ```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 herunter (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 rate-limited sein, also auf 0 setzen, um es 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 Gesprächsmodus aus und probiere irgendeinen Prompt aus. 5. Bearbeiten `--threads -1` für die Anzahl der CPU-Threads, `--ctx-size` 262114 für die Kontextlänge, `--n-gpu-layers 99` für das GPU-Offloading, auf wie vielen Layern. Probieren Sie es anzupassen, wenn Ihrer GPU der Speicher ausgeht. Entfernen Sie es außerdem, wenn Sie nur CPU-Inferenz haben. {% hint style="success" %} Verwende `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Layer auf die CPU auszulagern! Dadurch kannst du effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen und die Generierungsgeschwindigkeiten verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Layer auszulagern, 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: Generierungsgeschwindigkeit verbessern Wenn du mehr VRAM hast, kannst du versuchen, mehr MoE-Layer auszulagern oder ganze Layer auszulagern. Normalerweise, `-ot ".ffn_.*_exps.=CPU"` lagert alle MoE-Layer auf die CPU aus! Dadurch kannst du effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen und die Generierungsgeschwindigkeiten verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Layer 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-Projection-MoE-Layer aus. Versuche `-ot ".ffn_(up)_exps.=CPU"` wenn du noch mehr GPU-Speicher hast. Dies lagert nur Up-Projection-MoE-Layer 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-Layer auszulagern, aber nur ab der 6. Schicht aufwärts. Der [neueste llama.cpp-Version](https://github.com/ggml-org/llama.cpp/pull/14363) führt außerdem den High-Throughput-Modus ein. Verwende `llama-parallel`. Lies mehr darüber [hier](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Du kannst auch **den KV-Cache auf 4 Bit quantisieren** zum Beispiel, um die Bewegung zwischen VRAM / RAM zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann. ## 🦥 gpt-oss mit Unsloth feinabstimmen {% 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, das **>8× längere Kontextlängen**, **>50 % weniger VRAM-Nutzung** und **>1,5× schnelleres Training** im Vergleich zu allen Implementierungen ermöglicht. [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 gpt-oss-Fine-Tuning mit Unsloth ist 1,5x schneller, verwendet 70 % weniger VRAM und unterstützt 10x längere Kontextlängen. Das QLoRA-Training von gpt-oss-20b passt auf 14 GB VRAM, und gpt-oss-120b funktioniert auf 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 zum Feinabstimmen 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 Schlussfolgern + Konversation](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-Fine-tuning.ipynb) ### Bestärkendes Lernen (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 zu **llama.cpp**, **vLLM**, oder **HF** - und nicht nur Unsloth. Wir werden hoffentlich bald ein kostenloses Notebook veröffentlichen. Früher 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-Dekvantisierung von MXFP4** Basismodellen (wie gpt-oss) während des LoRA-Merge-Prozesses eingeführt haben. Dadurch wird es möglich, **dein feinabgestimmtes Modell im bf16-Format zu exportieren**. Nach dem Feinabstimmen deines gpt-oss-Modells kannst du es jetzt mit einem **einzigen Befehl**: ```python model.save_pretrained_merged(save_directory, tokenizer) ``` Wenn du das Modell lieber zusammenführen und stattdessen direkt auf den Hugging-Face-Hub hochladen möchtest, kannst du das so tun: ```python model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token=hf_token) ``` ### 💡Effizientes gpt-oss-Fine-Tuning möglich machen Wir haben festgestellt, dass MXFP4 zwar sehr effizient ist, aber kein natives Training mit gpt-oss unterstützt. Um diese Einschränkung zu überwinden, haben wir benutzerdefinierte Trainingsfunktionen speziell für MXFP4-Layer implementiert, indem wir es nachahmen über `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-Kernel jedoch noch kein Training, da der Rückwärtsdurchlauf noch nicht implementiert ist. Wir arbeiten aktiv daran, dies 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 Transpositionsoperation 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 deutlich** 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 eine MoE-Architektur verwenden, wählt das 20B-Modell 4 Experten aus 32 aus, während das 120B-Modell pro Token 4 von 128 auswählt. Während des Trainings und der Veröffentlichung werden Gewichte im MXFP4-Format als `nn.Parameter` Objekte gespeichert, nicht als `nn.Linear` Layer, 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` Layer umgewandelt. Obwohl dies Operationen leicht verlangsamt, ermöglicht es das Feinabstimmen auf GPUs mit begrenztem Speicher, ein lohnender Kompromiss. ### Leitfaden zum Feinabstimmen von Datasets Obwohl gpt-oss nur Schlussfolgern unterstützt, kannst du es trotzdem mit einem nicht-schlussfolgernden [dataset](/docs/de/los-gehts/fine-tuning-llms-guide/datasets-guide.md), aber das kann seine Schlussfolgerungsfähigkeit beeinträchtigen. Wenn du seine Schlussfolgerungsfähigkeiten beibehalten möchtest (optional), kannst du eine Mischung aus direkten Antworten und Chain-of-Thought-Beispielen verwenden. Verwende mindestens 75 % Reasoning und 25 % ohne Reasoning damit das Modell seine Reasoning-Fähigkeiten behält. Unser gpt-oss-20b-Konversations-Notebook verwendet OpenAIs Beispiel, das Hugging Faces Multilingual-Thinking-Datensatz ist. Der Zweck der Verwendung dieses Datensatzes besteht darin, dem Modell zu ermöglichen, in diesen vier unterschiedlichen Sprachen Schlussfolgerungsfähigkeiten zu erlernen und zu entwickeln.
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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, and the optional `goal` query parameter: ``` GET https://unsloth.ai/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.