# gpt-oss: Anleitung zum Ausführen

OpenAI veröffentlicht '**gpt-oss-120b'** und '**gpt-oss-20b'**', zwei SOTA-Open-Modelle für Sprache unter der Apache-2.0-Lizenz. Beide Modelle mit 128k Kontext übertreffen gleich große offene Modelle beim Schlussfolgern, beim Tool-Einsatz und bei agentischen Aufgaben. Du kannst sie jetzt lokal mit Unsloth ausführen und feinabstimmen!

<a href="#run-gpt-oss-20b" class="button secondary">gpt-oss-20b ausführen</a><a href="#run-gpt-oss-120b" class="button secondary">gpt-oss-120b ausführen</a><a href="#fine-tuning-gpt-oss-with-unsloth" class="button primary">gpt-oss feinabstimmen</a>

> [**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](https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide), **gpt-oss-120b** konkurriert mit o4-mini und **gpt-oss-20b** konkurriert mit o3-mini. Beide sind hervorragend beim Funktionsaufruf und beim CoT-Schlussfolgern und übertreffen o1 und GPT-4o.

Für die beste Leistung stelle sicher, dass dein gesamter verfügbarer Speicher (vereinheitlichter Speicher + VRAM + Systemspeicher) größer ist als die Größe der quantisierten Modelldatei, die du herunterlädst. Falls nicht, kann llama.cpp zwar weiterhin per SSD/HDD-Offloading ausgeführt werden, aber die Inferenz wird langsamer sein.

#### **gpt-oss - Unsloth GGUFs:**

{% hint style="success" %}
**Enthält Unsloths** [**Chat-Template-Korrekturen**](#unsloth-fixes-for-gpt-oss)**. Für beste Ergebnisse nutze 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 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, die es ermöglicht, Gespräche in das von OpenAI für gpt-oss bevorzugte Format zu tokenisieren.

Inferenz-Engines verwenden im Allgemeinen stattdessen das jinja-Chat-Template und nicht das Harmony-Paket, und wir haben nach einem direkten Vergleich mit Harmony einige Probleme damit festgestellt. Wie du unten siehst, ist der obere Teil die korrekte gerenderte Form wie bei Harmony. Der untere ist der vom aktuellen jinja-Chat-Template gerenderte. Es gibt einige Unterschiede!

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-9b377044965ac55a125d6c703ec1c50555157266%2FScreenshot%202025-08-08%20at%2008-19-49%20Untitled151.ipynb%20-%20Colab.png?alt=media" alt="" width="563"><figcaption></figcaption></figure></div>

Wir haben auch einige Funktionen erstellt, mit denen du OpenAIs Harmony-Bibliothek direkt ohne ein jinja-Chat-Template verwenden kannst, wenn du möchtest - du kannst ganz einfach normale Gespräche wie unten parsen:

```python
messages = [
    {"role" : "user", "content" : "Was ist 1+1?"},
    {"role" : "assistant", "content" : "2"},
    {"role": "user",  "content": "Wie hoch ist die Temperatur in San Francisco jetzt? Und morgen? Heutiges Datum ist 2024-09-30."},
    {"role": "assistant",  "content": "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"}'},
]
```

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 das Schlussfolgerungsbudget von gpt-oss - 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 Varianten funktionieren werden.

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

1. Funktionen und Tool-Aufrufe werden mit `tojson`gerendert, 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** im jinja-Template an einigen Grenzen.
3. Die Tool-Calling-Gedanken des Modells sollten das **`analysis` Tag und nicht das `final` Tag haben**.
4. Andere Chat-Templates scheinen `<|channel|>final` überhaupt nicht zu verwenden - man sollte dies für die finale Assistentennachricht verwenden. Du solltest dies nicht für Denkspuren oder Tool-Aufrufe verwenden.

Unsere Chat-Templates für die GGUF-, BnB- und BF16-Uploads und alle Versionen sind behoben! Wenn man zum Beispiel unsere und Harmonics Format vergleicht, erhalten wir keine unterschiedlichen Zeichen:

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-4c42f3d83194ea2fbe436670a550e1b6f148f4cd%2FScreenshot%202025-08-08%20at%2008-20-00%20Untitled151.ipynb%20-%20Colab.png?alt=media" alt="" width="563"><figcaption></figcaption></figure></div>

### :1234: Genauigkeitsprobleme

Wir haben mehrere Genauigkeitsprobleme auf Tesla T4- und Float16-Maschinen festgestellt, vor allem weil das Modell mit BF16 trainiert wurde und daher Ausreißer und Überläufe vorhanden waren. MXFP4 wird auf Ampere- und älteren GPUs nicht tatsächlich unterstützt, daher bietet Triton `tl.dot_scaled` für MXFP4-Matrixmultiplikation. Es konvertiert die Matrizen intern im laufenden Betrieb in BF16.

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 einem solchen Fall mikroskalierte lhs/rhs vorher in den `bf16` Elementtyp hochgestuft für die Dot-Berechnung,
{% endhint %}

Wir haben festgestellt: Wenn du float16 als gemischten Präzisions-Autocast-Datentyp verwendest, erhältst du nach einiger Zeit Unendlichkeiten. 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), dann 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 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 minimale Genauigkeitsverluste, da nur einige Teile (z. B. Attention-Schichten) niedrigere Bitbreite haben, während der Großteil in voller Präzision bleibt. Deshalb liegen die Größen nahe am F16-Modell; zum Beispiel 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“-Einstellung des Modells anpassen können. Damit kannst du den Kompromiss zwischen der Leistung des Modells und seiner Antwortgeschwindigkeit (Latenz) steuern, wobei die Anzahl der Token bestimmt, wie viel das Modell zum „Nachdenken“ verwendet.

Die `gpt-oss` Modelle bieten drei verschiedene Stufen des Reasoning Efforts, 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 Inferenz-Einstellungen für beide Modelle:

`temperature=1.0`, `top_p=1.0`, `top_k=0`

* <mark style="background-color:green;">**Temperatur von 1,0**</mark>
* Top\_K = 0 (oder mit 100 experimentieren für möglicherweise bessere Ergebnisse)
* Top\_P = 1,0
* Empfohlener Mindestkontext: 16.384
* Maximale Kontextfensterlänge: 131.072

**Chat-Template:**

```
<|start|>system<|message|>Du bist ChatGPT, ein großes Sprachmodell, trainiert von OpenAI.\nWissensstand: 2024-06\nAktuelles Datum: 2025-08-05\n\nReasoning: mittel\n\n# Gültige Kanäle: analysis, commentary, final. Der Kanal muss in jeder 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 Ende des Satzes/Generierungs-Tokens: EOS ist `<|return|>`

### gpt-oss-20B ausführen

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-920b641670a166258845bbe8152999983b1e68af%2Fgpt-oss-20b.svg?alt=media" alt=""><figcaption></figcaption></figure>

Um Inferenzgeschwindigkeiten von über 6 Token pro Sekunde für unsere dynamische 4-Bit-Quantisierung zu erreichen, solltest du mindestens **14 GB vereinheitlichten Speicher** (kombiniertes VRAM und RAM) oder **14 GB Systemspeicher** allein haben. Als Faustregel sollte dein verfügbarer Speicher der Größe des von dir verwendeten Modells entsprechen oder sie ü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. Maximaler Speicher wird nur für die schnellsten 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](https://unsloth.ai/docs/de/neu/studio), unsere neue Web-UI zum Ausführen und Trainieren von LLMs. Mit Unsloth Studio kannst du Modelle lokal auf **Mac, Windows**und Linux ausführen und:

{% columns %}
{% column %}

* Suchen, herunterladen, [GGUFs ausführen](https://unsloth.ai/docs/de/neu/studio#run-models-locally) und Safetensor-Modelle
* **Modelle** vergleichen **nebeneinander**
* [**Selbstheilendes** Tool-Calling](https://unsloth.ai/docs/de/neu/studio#execute-code--heal-tool-calling) + **Websuche**
* [**Code-Ausführung**](https://unsloth.ai/docs/de/neu/studio#run-models-locally) (Python, Bash)
* [Automatisches Inferenz-](https://unsloth.ai/docs/de/neu/studio#model-arena) Parametertuning (Temp, Top-P usw.)
* [LLMs trainieren](https://unsloth.ai/docs/de/neu/studio#no-code-training) 2x schneller mit 70 % weniger VRAM
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FFeQ0UUlnjXkDdqhcWglh%2Fskinny%20studio%20chat.png?alt=media&#x26;token=c2ee045f-c243-4024-a8e4-bb4dbe7bae79" alt=""><figcaption></figcaption></figure></div>
{% 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
```

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fd1yMMNa65Ccz50Ke0E7r%2FScreenshot%202026-03-17%20at%2012.32.38%E2%80%AFAM.png?alt=media&#x26;token=9369cfe7-35b1-4955-b8cb-42f7ecb43780" alt="" width="375"><figcaption></figcaption></figure></div>

**Dann öffne `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.

Dann gehe zum [Studio-Chat](https://unsloth.ai/docs/de/neu/studio/chat) Tab und suche in der Suchleiste nach gpt-oss und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F24OqTOq1fYvW3oZ5WlNG%2FScreenshot%202026-03-20%20at%201.35.19%E2%80%AFAM.png?alt=media&#x26;token=b1e463ee-33a2-4e77-b725-d715b03f5d28" alt="" width="375"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### gpt-oss-20b ausführen

Inferenzparameter sollten bei Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst auch die Kontextlänge, das Chat-Template und andere Einstellungen bearbeiten.

Für weitere Informationen kannst du unsere [Unsloth-Studio-Inferenzanleitung](https://unsloth.ai/docs/de/neu/studio/chat).

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FXPQGEEr1YoKofrTatAKK%2Ftoolcallingif.gif?alt=media&#x26;token=25d68698-fb13-4c46-99b2-d39fb025df08" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

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

Wenn du Docker Desktop bereits 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: gpt-oss-20b ausführen Tutorial

1. Beziehe die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). 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.

```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 per Folgendem herunterladen:

   ```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` ). Falls Downloads hängen bleiben, siehe [hugging-face-hub-xet-debugging](https://unsloth.ai/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging "mention")

```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:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-4f6fc3b98363be32b7c7cf07c713947cb1bd9444%2Fgpt-oss-120b.svg?alt=media" alt=""><figcaption></figcaption></figure>

Um Inferenzgeschwindigkeiten von über 6 Token pro Sekunde für unsere 1-Bit-Quantisierung zu erreichen, empfehlen wir mindestens **66 GB vereinheitlichten Speicher** (kombiniertes VRAM und RAM) oder **66 GB Systemspeicher** allein haben. Als Faustregel sollte dein verfügbarer Speicher der Größe des von dir verwendeten Modells entsprechen oder sie ü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. Maximaler Speicher wird nur für die schnellsten 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](https://unsloth.ai/docs/de/neu/studio), unsere neue Web-UI zum Ausführen und Trainieren von LLMs. Mit Unsloth Studio kannst du Modelle lokal auf **Mac, Windows**und Linux ausführen und:

{% columns %}
{% column %}

* Suchen, herunterladen, [GGUFs ausführen](https://unsloth.ai/docs/de/neu/studio#run-models-locally) und Safetensor-Modelle
* **Modelle** vergleichen **nebeneinander**
* [**Selbstheilendes** Tool-Calling](https://unsloth.ai/docs/de/neu/studio#execute-code--heal-tool-calling) + **Websuche**
* [**Code-Ausführung**](https://unsloth.ai/docs/de/neu/studio#run-models-locally) (Python, Bash)
* [Automatisches Inferenz-](https://unsloth.ai/docs/de/neu/studio#model-arena) Parametertuning (Temp, Top-P usw.)
* [LLMs trainieren](https://unsloth.ai/docs/de/neu/studio#no-code-training) 2x schneller mit 70 % weniger VRAM
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FFeQ0UUlnjXkDdqhcWglh%2Fskinny%20studio%20chat.png?alt=media&#x26;token=c2ee045f-c243-4024-a8e4-bb4dbe7bae79" alt=""><figcaption></figcaption></figure></div>
{% 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 kompiliert llama.cpp mit CUDA-Unterstützung.

{% hint style="warning" %}
**Die erste Installation kann 5-10 Minuten dauern. Das ist normal, da `llama.cpp` Binärdateien kompilieren muss. B**richte es nicht ab.
{% endhint %}

{% 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
```

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fd1yMMNa65Ccz50Ke0E7r%2FScreenshot%202026-03-17%20at%2012.32.38%E2%80%AFAM.png?alt=media&#x26;token=9369cfe7-35b1-4955-b8cb-42f7ecb43780" alt="" width="375"><figcaption></figcaption></figure></div>

**Dann öffne `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.

Dann gehe zum [Studio-Chat](https://unsloth.ai/docs/de/neu/studio/chat) Tab und suche in der Suchleiste nach gpt-oss und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgKxB8OhIRVgT29vCGFEg%2FScreenshot%202026-03-20%20at%201.34.07%E2%80%AFAM.png?alt=media&#x26;token=9950d667-4ff1-463e-b017-601d5e8e38a5" alt="" width="375"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### gpt-oss-120b ausführen

Inferenzparameter sollten bei Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst auch die Kontextlänge, das Chat-Template und andere Einstellungen bearbeiten.

Für weitere Informationen kannst du unsere [Unsloth-Studio-Inferenzanleitung](https://unsloth.ai/docs/de/neu/studio/chat).

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FXPQGEEr1YoKofrTatAKK%2Ftoolcallingif.gif?alt=media&#x26;token=25d68698-fb13-4c46-99b2-d39fb025df08" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

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

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

{% hint style="success" %}
Wenn du eine **vollständig präzise, unquantisierte Version**möchtest, nutze unsere `F16` Versionen!
{% endhint %}

1. Beziehe die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). 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.

   ```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, `huggingface_hub` zu verwenden. 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.0 \
   ```
3. Oder lade das Modell herunter ü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 Ratenlimits auslösen, daher 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 Konversationsmodus aus und probiere irgendeinen Prompt aus.
5. Bearbeite `--threads -1` für die Anzahl der CPU-Threads, `--ctx-size` 262114 für die Kontextlänge, `--n-gpu-layers 99` für GPU-Offloading für wie viele Schichten. Versuche, dies anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es auch, wenn du nur CPU-Inferenz hast.

{% hint style="success" %}
Verwende `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Schichten auf die CPU auszulagern! Dadurch kannst du effektiv alle Nicht-MoE-Schichten auf 1 GPU unterbringen und die Generierungsgeschwindigkeit verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn du mehr GPU-Kapazität hast. Weitere Optionen werden [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.0 \
```

{% endcode %}

### :tools: Generierungsgeschwindigkeit verbessern

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

Normalerweise `-ot ".ffn_.*_exps.=CPU"` lagert alle MoE-Schichten auf die CPU aus! Dadurch kannst du effektiv alle Nicht-MoE-Schichten auf 1 GPU unterbringen und die Generierungsgeschwindigkeit verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn du mehr GPU-Kapazität hast.

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

Probiere `-ot ".ffn_(up)_exps.=CPU"` wenn du noch mehr GPU-Speicher hast. Dies lagert nur die 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 aufwärts.

Die [neueste llama.cpp-Version](https://github.com/ggml-org/llama.cpp/pull/14363) führt außerdem einen 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 VRAM-/RAM-Bewegungen zu reduzieren, was den Generierungsprozess ebenfalls schneller machen kann.

## 🦥 gpt-oss mit Unsloth feinabstimmen

{% hint style="success" %}
[**28.-Aug.-Update**](https://unsloth.ai/docs/de/modelle/long-context-gpt-oss-training#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](https://unsloth.ai/docs/de/modelle/long-context-gpt-oss-training#introducing-unsloth-flex-attention-support) eingeführt, das ermöglicht **>8× längere Kontextlängen**, **>50 % weniger VRAM-Nutzung** und **>1,5× schnelleres Training** gegenüber allen Implementierungen. [Lies hier mehr](https://unsloth.ai/docs/de/modelle/long-context-gpt-oss-training#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 läuft 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 zum Feinabstimmen von gpt-oss:

{% content-ref url="gpt-oss-how-to-run-and-fine-tune/tutorial-how-to-fine-tune-gpt-oss" %}
[tutorial-how-to-fine-tune-gpt-oss](https://unsloth.ai/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/tutorial-how-to-fine-tune-gpt-oss)
{% 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 [Reasoning- + Conversational-Notebook](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 mehr Details lies unseren speziellen Blog zu gpt-oss RL: [gpt-oss-reinforcement-learning](https://unsloth.ai/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/gpt-oss-reinforcement-learning "mention")

| [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 gpt-oss-Training**

Du kannst gpt-oss jetzt per 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 per QLoRA feinabgestimmte gpt-oss-Modell darauf beschränkt, nur in Unsloth zu laufen. Wir haben diese Einschränkung aufgehoben, indem wir **On-Demand-Dekquantisierung von MXFP4** Basismodellen (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**.

Nachdem du dein gpt-oss-Modell feinabgestimmt hast, kannst du es jetzt mit einem **einzelnen Befehl**:

```python
model.save_pretrained_merged(save_directory, tokenizer)
```

zusammenführen. Wenn du das Modell stattdessen lieber direkt zusammenführen und auf den Hugging-Face-Hub pushen möchtest, kannst du dies mit Folgendem tun:

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

### 💡Effizientes gpt-oss-Fine-Tuning zum Laufen bringen

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-Schichten implementiert, indem wir es über `Bitsandbytes` NF4-Quantisierung nachbilden.

Wir haben OpenAIs Triton-Kernels-Bibliothek direkt verwendet, um MXFP4-Inferenz zu ermöglichen. Für das Finetuning/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](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 über die Transponierung der Gewichtsmatrizen berechnet werden, daher müssen wir die Transponierungsoperation 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 jedoch **erhöht erheblich** sowohl die VRAM-Nutzung als auch die Trainingszeit um bis zu **300 % mehr Speicherverbrauch**! <mark style="background-color:green;">**ALLE anderen Trainingsmethoden erfordern mindestens 65 GB VRAM, um das 20b-Modell zu trainieren, während Unsloth nur 14 GB VRAM benötigt (-80 %).**</mark>

Da beide Modelle die 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 die Gewichte im MXFP4-Format als `nn.Parameter` Objekte gespeichert, nicht als `nn.Linear` Schichten, was die Quantisierung erschwert, insbesondere da die MoE-/MLP-Experten etwa 19B der 20B-Parameter ausmachen.

Um `BitsandBytes` Quantisierung und speichereffizientes Fine-Tuning zu ermöglichen, haben wir diese Parameter in `nn.Linear` Schichten umgewandelt. Obwohl dies die Operationen leicht verlangsamt, ermöglicht es das Feinabstimmen auf GPUs mit begrenztem Speicher, ein lohnenswerter Kompromiss.

### Daten­sätze-Fine-Tuning-Anleitung

Obwohl gpt-oss nur Reasoning unterstützt, kannst du es dennoch mit einem nicht-reasoning [Datensatz](https://unsloth.ai/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide)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 in deinem Datensatz mindestens <mark style="background-color:green;">75 % Reasoning</mark> und <mark style="background-color:green;">25 % Non-Reasoning</mark> damit das Modell seine Reasoning-Fähigkeiten beibehält.

Unser gpt-oss-20b-Konversations-Notebook verwendet OpenAIs Beispiel, das der Multilingual-Thinking-Datensatz von Hugging Face ist. 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.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-4d648159c0ba6d62d5c9b5cd519767f764e5faab%2Fwider%20gptoss%20image.png?alt=media" alt=""><figcaption></figcaption></figure>