> 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/tutorial-how-to-fine-tune-gpt-oss.md). # Tutorial: Wie man gpt-oss feinabstimmt Lerne Schritt für Schritt, wie du OpenAI gpt-oss lokal mit Unsloth trainierst. In diesem Leitfaden mit Screenshots lernst du, dein eigenes benutzerdefiniertes gpt-oss-Modell feinabzustimmen, entweder [lokal](#local-gpt-oss-fine-tuning) auf deinem Rechner mit [Unsloth](https://github.com/unslothai/unsloth) oder kostenlos mit [Google Colab](#colab-gpt-oss-fine-tuning). Wir führen dich durch den gesamten Prozess, vom Einrichten bis zum Ausführen und Speichern deines trainierten Modells. {% hint style="success" %} [**Update vom 28. Aug.**](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/long-context-gpt-oss-training.md#introducing-unsloth-flex-attention-support)**:** Du kannst dein mit QLoRA feinabgestimmtes gpt-oss-Modell jetzt nach llama.cpp, vLLM, HF usw. exportieren/speichern. Außerdem haben wir [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, was **>8× längere Kontextlängen**, **>50 % weniger VRAM-Nutzung** und **>1,5× schnelleres Training** gegenüber allen Implementierungen ermöglicht. [Lesen Sie hier mehr](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/long-context-gpt-oss-training.md#introducing-unsloth-flex-attention-support) {% endhint %} > **Schnellstart:** Feinabstimmung von 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) Unsloth gpt-oss-Fine-Tuning erreicht im Vergleich zu allen anderen FA2-Implementierungen 1,5× schnelleres Training, 70 % weniger VRAM-Verbrauch und 10× längere Kontextlängen – ohne Genauigkeitsverlust. * **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. Lokaler Leitfaden Colab-Leitfaden ## 🌐 Colab gpt-oss-Feinabstimmung Dieser Abschnitt behandelt die Feinabstimmung von gpt-oss mit unseren Google-Colab [Notebooks](/docs/de/loslegen/unsloth-notebooks.md). Du kannst das gpt-oss-Notebook auch speichern und in deinem bevorzugten Code-Editor verwenden und unserem [lokalen gpt-oss-Leitfaden](#local-gpt-oss-fine-tuning). {% stepper %} {% step %} #### Unsloth installieren (in Colab) In Colab, führe Zellen aus **von oben nach unten**. Verwenden Sie **Alle ausführen** für den ersten Durchlauf. Die erste Zelle installiert Unsloth (und zugehörige Abhängigkeiten) und gibt GPU-/Speicherinformationen aus. Wenn eine Zelle einen Fehler wirft, führe sie einfach erneut aus.

{% endstep %} {% step %} #### gpt-oss und Reasoning Effort konfigurieren Wir laden **`gpt-oss-20b`** mithilfe von Unsloths [linearisierten Version](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md#making-efficient-gpt-oss-fine-tuning-work) (da keine andere Version funktionieren wird). Konfiguriere die folgenden Parameter: * `max_seq_length = 1024` * Empfohlen für schnelle Tests und erste Experimente. * `load_in_4bit = True` * Verwenden Sie `Falsch` für LoRA-Training (Hinweis: Wenn du dies auf `Falsch` setzt, benötigst du mindestens 43 GB VRAM). Du ***MUSS*** auch **`model_name = "unsloth/gpt-oss-20b-BF16"`**

Du solltest eine Ausgabe sehen, die dem folgenden Beispiel ähnelt. Hinweis: Wir ändern den `dtype` zu `float32` explizit, um das korrekte Trainingsverhalten sicherzustellen.

{% endstep %} {% step %} #### Feinabstimmungs-Hyperparameter (LoRA) Jetzt ist es an der Zeit, deine Trainings-Hyperparameter anzupassen. Für einen tieferen Einblick, wie, wann und was angepasst werden sollte, schau dir unseren [detaillierten Hyperparameter-Leitfaden](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md). {% hint style="info" %} Um [Überanpassung](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md#avoiding-overfitting-and-underfitting), behalte deinen Trainingsverlust im Auge und vermeide, diese Werte zu hoch einzustellen. {% endhint %} Dieser Schritt fügt LoRA-Adapter für eine parameter-effiziente Feinabstimmung hinzu. Nur etwa 1 % der Modellparameter werden trainiert, was den Prozess deutlich effizienter macht.

{% endstep %} {% step %} #### Inference ausprobieren Im Notebook gibt es einen Abschnitt namens *"Reasoning Effort"* der die gpt-oss-Inferenz in Colab demonstriert. Du kannst diesen Schritt überspringen, musst das Modell jedoch später trotzdem ausführen, sobald du mit der Feinabstimmung fertig bist.

{% endstep %} {% step %} #### Datenvorbereitung Für dieses Beispiel verwenden wir den [`HuggingFaceH4/Multilingual-Thinking`](https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking). Dieses Datenset enthält Chain-of-Thought-Reasoning-Beispiele, die aus Benutzerfragen abgeleitet und aus dem Englischen in vier weitere Sprachen übersetzt wurden. Dies ist dasselbe Datenset, das auch im Fine-Tuning-Cookbook von OpenAI erwähnt wird. Das Ziel der Verwendung eines mehrsprachigen Datensatzes ist es, dem Modell zu helfen, Schlussfolgerungsmuster über mehrere Sprachen hinweg zu lernen und zu verallgemeinern.

gpt-oss führt ein System für Reasoning Effort ein, das steuert, wie viel Schlussfolgerung das Modell durchführt. Standardmäßig ist der Reasoning Effort auf `niedrig`, gesetzt, aber du kannst ihn ändern, indem du den `reasoning_effort` Parameter auf `niedrig`, `mittel` oder `hoch`. Beispiel: ```python tokenizer.apply_chat_template( text, tokenize = False, add_generation_prompt = False, reasoning_effort = "medium", ) ``` Um den Datensatz zu formatieren, wenden wir eine angepasste Version des gpt-oss-Prompts an: ```python from unsloth.chat_templates import standardize_sharegpt dataset = standardize_sharegpt(dataset) dataset = dataset.map(formatting_prompts_func, batched = True,) ``` Schauen wir uns den Datensatz an, indem wir das erste Beispiel ausgeben: ```notebook-python print(dataset[0]['text']) ```

Während des Trainings beobachte den Verlust, um sicherzustellen, dass er im Laufe der Zeit sinkt. Dies bestätigt, dass der Trainingsprozess korrekt funktioniert.

Dies sollte eine Ausgabe erzeugen, die ähnlich aussieht wie:

{% endstep %} {% step %} #### Speichere/exportiere dein Modell Um dein feinabgestimmtes Modell zu speichern, kannst du dein feinabgestimmtes Modell sowohl im **bf16-Format ,** mit unserem **On-Demand-Dekwantisierung von MXFP4** Basismodellen mithilfe von `save_method="merged_16bit"`oder im nativen **MXFP4** Safetensors-Format mit `save_method="mxfp4"` . Der **MXFP4** Das native Merge-Format bietet erhebliche Leistungsverbesserungen im Vergleich zum **bf16-Format**: Es benötigt bis zu 75 % weniger Speicherplatz, reduziert den VRAM-Verbrauch um 50 %, beschleunigt das Zusammenführen um das 5- bis 10-Fache und ermöglicht eine deutlich schnellere Konvertierung in **GGUF** Format. {% hint style="success" %} Neu: Das Speichern oder Zusammenführen von mit QLoRA feinabgestimmten Modellen nach GGUF wird jetzt für die Verwendung in anderen Frameworks unterstützt (z. B. Hugging Face, llama.cpp mit GGUF). {% endhint %} Nachdem du dein gpt-oss-Modell feinabgestimmt hast, kannst du es zusammenführen zu **MXFP4** Format mit: ```python model.save_pretrained_merged(save_directory, tokenizer, save_method="mxfp4) ``` Wenn du das Modell lieber zusammenführen und direkt auf den Hugging-Face-Hub pushen möchtest: ```python model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token= hf_token, save_method="mxfp4") ``` #### :sparkles: Speichern für Llama.cpp 1. Holen Sie sich die neueste `llama.cpp` auf [hier auf GitHub](https://github.com/ggml-org/llama.cpp). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. ```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. Konvertiere das **MXFP4** zusammengeführte Modell: ```bash python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned-mxfp4.gguf ``` 3. Führe Inferenz auf dem quantisierten Modell aus: ```bash llama.cpp/llama-cli --model gpt-oss-finetuned-mxfp4.gguf \\ --jinja -ngl 99 --threads -1 --ctx-size 16384 \\ --temp 1.0 --top-p 1.0 --top-k 0 \\ -p "The meaning to life and the universe is" ```

{% endstep %} {% endstepper %} ## 🖥️ Lokale gpt-oss-Feinabstimmung Dieses Kapitel behandelt die Feinabstimmung von gpt-oss auf deinem lokalen Gerät. Während **gpt-oss-20b** die Feinabstimmung mit nur 14 GB VRAM möglich ist, empfehlen wir, mindestens 16 GB VRAM verfügbar zu haben, um stabile und zuverlässige Trainingsläufe zu gewährleisten. {% hint style="info" %} Wir empfehlen, Elemente aus unserem Colab [Notebooks](/docs/de/loslegen/unsloth-notebooks.md) herunterzuladen oder in dein lokales Setup zu integrieren, um die Nutzung zu erleichtern. {% endhint %} {% stepper %} {% step %} #### Unsloth lokal installieren Stelle sicher, dass dein Gerät [mit Unsloth kompatibel](/docs/de/loslegen/fine-tuning-for-beginners/unsloth-requirements.md) ist, und du kannst unseren ausführlichen [Installationsleitfaden](/docs/de/loslegen/install.md). **lesen.** [**Du kannst Unsloth auch mit unserem**](https://unsloth.ai/docs/models/qwen3-coder-next)**.** Docker-Image `installieren.` Beachte, dass ```python # Wir installieren die neueste Torch-, Triton-, OpenAI-Triton-Kernels-, Transformers- und Unsloth-Version! !pip install --upgrade -qqq uv try: import numpy; install_numpy = f"numpy=={numpy.__version__}" except: install_numpy = "numpy" !uv pip install -qqq \ "torch>=2.8.0" "triton>=3.4.0" {install_numpy} \\ "unsloth_zoo[base] @ git+https://github.com/unslothai/unsloth-zoo" \ "unsloth[base] @ git+https://github.com/unslothai/unsloth" \ torchvision bitsandbytes \\ git+https://github.com/huggingface/transformers \\ git+https://github.com/triton-lang/triton.git@05b2c186c1b6c9a08375389d5efe9cb4c401c075#subdirectory=python/triton_kernels ``` {% endstep %} {% step %} #### gpt-oss und Reasoning Effort konfigurieren Wir laden **`gpt-oss-20b`** mithilfe von Unsloths [linearisierten Version](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md#making-efficient-gpt-oss-fine-tuning-work) (da keine andere Version für QLoRA-Feinabstimmung funktionieren wird). Konfiguriere die folgenden Parameter: * `max_seq_length = 2048` * Empfohlen für schnelle Tests und erste Experimente. * `load_in_4bit = True` * Verwenden Sie `Falsch` für LoRA-Training (Hinweis: Wenn du dies auf `Falsch` setzt, benötigst du mindestens 43 GB VRAM). Du ***MUSS*** auch **`model_name = "unsloth/gpt-oss-20b-BF16"`**

from unsloth import FastLanguageModel
import torch
max_seq_length = 1024
dtype = None

# Wir unterstützen vorquantisierte 4-Bit-Modelle für 4x schnelleres Herunterladen + keine OOMs.
fourbit_models = [
    "unsloth/gpt-oss-20b-unsloth-bnb-4bit", # 20B-Modell mit bitsandbytes 4-Bit-Quantisierung
    "unsloth/gpt-oss-120b-unsloth-bnb-4bit",
    "unsloth/gpt-oss-20b", # 20B-Modell mit MXFP4-Format
    "unsloth/gpt-oss-120b",
] # Weitere Modelle unter https://huggingface.co/unsloth

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/gpt-oss-20b",
    dtype = dtype, # None für automatische Erkennung
    max_seq_length = max_seq_length, # Wähle irgendetwas für langen Kontext!
    load_in_4bit = True,  # 4 bit quantization to reduce memory
    full_finetuning = False, # [NEW!] We have full finetuning now!
    # token = "hf_...", # verwende einen, wenn du gesperrte Modelle nutzt
)

Du solltest eine Ausgabe sehen, die dem folgenden Beispiel ähnelt. Hinweis: Wir ändern den `dtype` zu `float32` explizit, um das korrekte Trainingsverhalten sicherzustellen. {% endstep %} {% step %} #### Feinabstimmungs-Hyperparameter (LoRA) Jetzt ist es an der Zeit, deine Trainings-Hyperparameter anzupassen. Für einen tieferen Einblick, wie, wann und was angepasst werden sollte, schau dir unseren [detaillierten Hyperparameter-Leitfaden](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md). {% hint style="info" %} Um [Überanpassung](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md#avoiding-overfitting-and-underfitting), behalte deinen Trainingsverlust im Auge und vermeide, diese Werte zu hoch einzustellen. {% endhint %} Dieser Schritt fügt LoRA-Adapter für eine parameter-effiziente Feinabstimmung hinzu. Nur etwa 1 % der Modellparameter werden trainiert, was den Prozess deutlich effizienter macht. ```python model = FastLanguageModel.get_peft_model( model, r = 8, # Wähle jede Zahl > 0! Empfohlen: 8, 16, 32, 64, 128 target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj",], lora_alpha = 16, lora_dropout = 0, # Unterstützt alles, aber = 0 ist optimiert bias = "none", # Unterstützt alles, aber = "none" ist optimiert # [NEU] "unsloth" benötigt 30 % weniger VRAM und passt in 2x größere Batchgrößen! use_gradient_checkpointing = "unsloth", # True oder "unsloth" für sehr lange Kontexte random_state = 3407, use_rslora = False, # Wir unterstützen rank-stabilisiertes LoRA loftq_config = None, # Und LoftQ ) ``` {% endstep %} {% step %} #### Datenvorbereitung Für dieses Beispiel verwenden wir den [`HuggingFaceH4/Multilingual-Thinking`](https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking). Dieses Datenset enthält Chain-of-Thought-Reasoning-Beispiele, die aus Benutzerfragen abgeleitet und aus dem Englischen in vier weitere Sprachen übersetzt wurden. Dies ist dasselbe Datenset, das auch im Fine-Tuning-Cookbook von OpenAI erwähnt wird. Das Ziel der Verwendung eines mehrsprachigen Datensatzes ist es, dem Modell zu helfen, Schlussfolgerungsmuster über mehrere Sprachen hinweg zu lernen und zu verallgemeinern. ```python def formatting_prompts_func(examples): convos = examples["messages"] texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos] return { "text" : texts, } pass from datasets import load_dataset dataset = load_dataset("HuggingFaceH4/Multilingual-Thinking", split="train") Datensatz ``` gpt-oss führt ein System für Reasoning Effort ein, das steuert, wie viel Schlussfolgerung das Modell durchführt. Standardmäßig ist der Reasoning Effort auf `niedrig`, gesetzt, aber du kannst ihn ändern, indem du den `reasoning_effort` Parameter auf `niedrig`, `mittel` oder `hoch`. Beispiel: ```python tokenizer.apply_chat_template( text, tokenize = False, add_generation_prompt = False, reasoning_effort = "medium", ) ``` Um den Datensatz zu formatieren, wenden wir eine angepasste Version des gpt-oss-Prompts an: ```python from unsloth.chat_templates import standardize_sharegpt dataset = standardize_sharegpt(dataset) dataset = dataset.map(formatting_prompts_func, batched = True,) ``` Schauen wir uns den Datensatz an, indem wir das erste Beispiel ausgeben: ```notebook-python print(dataset[0]['text']) ```

Ein einzigartiges Merkmal von gpt-oss ist die Verwendung des [**OpenAI-Harmony-Formats**](https://github.com/openai/harmony)**,** das strukturierte Unterhaltungen, Reasoning-Ausgaben und Tool-Aufrufe unterstützt. Dieses Format enthält Tags wie `<|start|>` , `<|message|>` , und `<|return|>` . {% hint style="info" %} 🦥 Unsloth korrigiert die Chatvorlage, um sicherzustellen, dass sie korrekt ist. Sieh dir diesen [Tweet](https://x.com/danielhanchen/status/1953901104150065544) für technische Details zu unserer Vorlagenkorrektur an. {% endhint %} Passe den Prompt und die Struktur gerne an deinen eigenen Datensatz oder Anwendungsfall an. Für weitere Hinweise siehe unseren [Datensatzleitfaden](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md). {% endstep %} {% step %} #### Das Modell trainieren Wir haben die Trainings-Hyperparameter für optimale Ergebnisse vorab ausgewählt. Du kannst sie jedoch an deinen spezifischen Anwendungsfall anpassen. Sieh dir unseren [Hyperparameter-Leitfaden](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md). In diesem Beispiel trainieren wir 60 Schritte lang, um den Prozess zu beschleunigen. Für einen vollständigen Trainingslauf setze `num_train_epochs=1` und deaktiviere die Schrittbegrenzung, indem du `max_steps=None`. ```python from trl import SFTConfig, SFTTrainer trainer = SFTTrainer( model = model, tokenizer = tokenizer, train_dataset = dataset, args = SFTConfig( per_device_train_batch_size = 1, gradient_accumulation_steps = 4, warmup_steps = 5, # num_train_epochs = 1, # Dies für einen vollständigen Trainingslauf setzen. max_steps = 30, learning_rate = 2e-4, logging_steps = 1, optim = "adamw_8bit", weight_decay = 0.01, lr_scheduler_type = "linear", seed = 3407, output_dir = "outputs", report_to = "none", # Verwenden Sie dies für WandB usw. ), ) ``` Während des Trainings beobachte den Verlust, um sicherzustellen, dass er im Laufe der Zeit sinkt. Dies bestätigt, dass der Trainingsprozess korrekt funktioniert.

{% endstep %} {% step %} #### Inference: Dein trainiertes Modell ausführen Jetzt ist es an der Zeit, Inferenz mit deinem feinabgestimmten Modell auszuführen. Du kannst die Anweisung und die Eingabe ändern, aber die Ausgabe leer lassen. In diesem Beispiel testen wir die Fähigkeit des Modells, auf Französisch zu schlussfolgern, indem wir dem System-Prompt eine spezifische Anweisung hinzufügen, nach derselben Struktur, die in unserem Datensatz verwendet wird. ```python messages = [ {"role": "system", "content": "Reasoning-Sprache: Französisch\n\nDu bist ein hilfreicher Assistent, der mathematische Probleme lösen kann."}, {"role": "user", "content": "Löse x^5 + 3x^4 - 10 = 3."}, ] inputs = tokenizer.apply_chat_template( messages, add_generation_prompt = True, return_tensors = "pt", return_dict = True, reasoning_effort = "medium", ).to(model.device) from transformers import TextStreamer _ = model.generate(**inputs, max_new_tokens = 2048, streamer = TextStreamer(tokenizer)) ``` Dies sollte eine Ausgabe erzeugen, die ähnlich aussieht wie:

{% endstep %} {% step %} #### Speichere und exportiere dein Modell Um dein feinabgestimmtes Modell zu speichern, kann es mit unserem neuen im Safetensors-Format exportiert werden **On-Demand-Dekwantisierung von MXFP4** Basismodelle (wie gpt-oss) während des LoRA-Zusammenführungsprozesses. Dadurch ist es möglich, **dein feinabgestimmtes Modell im bf16-Format zu exportieren**. {% hint style="success" %} Neu: Das Speichern oder Zusammenführen von mit QLoRA feinabgestimmten Modellen nach GGUF wird jetzt für die Verwendung in anderen Frameworks unterstützt (z. B. Hugging Face, llama.cpp mit GGUF). {% endhint %} Nachdem du dein gpt-oss-Modell feinabgestimmt hast, kannst du es mit folgendem Befehl in das 16-Bit-Format zusammenführen: ```python model.save_pretrained_merged(save_directory, tokenizer) ``` Wenn du das Modell lieber zusammenführen und direkt auf den Hugging-Face-Hub pushen möchtest: ```python model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token= hf_token) ``` #### :sparkles: Speichern für Llama.cpp 1. Holen Sie sich die neueste `llama.cpp` auf [hier auf GitHub](https://github.com/ggml-org/llama.cpp). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. ```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.cp ``` 2. Das zusammengeführte Modell konvertieren und quantisieren: ```bash python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned.gguf llama.cpp/llama-quantize gpt-oss-finetuned.gguf gpt-oss-finetuned-Q8_0.gguf Q8_0 ``` 3. Führe Inferenz auf dem quantisierten Modell aus: ```bash llama.cpp/llama-cli --model gpt-oss-finetuned-Q8_0.gguf \\ --jinja -ngl 99 --threads -1 --ctx-size 16384 \\ --temp 1.0 --top-p 1.0 --top-k 0 \\ -p "The meaning to life and the universe is" ``` {% endstep %} {% endstepper %} ### 🏁 Und das war's! Du hast gpt-oss mit Unsloth feinabgestimmt. Wir arbeiten derzeit an RL- und GRPO-Implementierungen sowie an verbessertem Speichern und Ausführen von Modellen, also bleib dran. Wie immer kannst du dich gerne an unseren [Discord](https://discord.com/invite/unsloth) oder [Reddit](https://www.reddit.com/r/unsloth/) wenden, wenn du Hilfe brauchst. ## ❓FAQ (Häufig gestellte Fragen) #### 1. Kann ich mein Modell exportieren, um es später in Hugging Face, llama.cpp GGUF oder vLLM zu verwenden? Ja, du kannst jetzt [dein feinabgestimmtes gpt-oss speichern/exportieren](/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) mit Unsloths neuem Update! #### 2. Kann ich mit gpt-oss ein fp4- oder MXFP4-Training durchführen? Nein, derzeit unterstützt kein Framework fp4- oder MXFP4-Training. Unsloth ist jedoch das einzige Framework, das QLoRA-4-Bit-Feinabstimmung für das Modell unterstützt und damit mehr als 4x weniger VRAM-Verbrauch ermöglicht. #### 3. Kann ich mein Modell nach dem Training in das MXFP4-Format exportieren? Nein, derzeit unterstützt keine Bibliothek oder kein Framework dies. #### 4. Kann ich mit gpt-oss Reinforcement Learning (RL) oder GRPO durchführen? Ja! Unsloth unterstützt jetzt RL für gpt-oss mit GRPO/GSPO. Wir haben es in einem kostenlosen Kaggle-Notebook zum Laufen gebracht und die schnellste Inferenz für RL erreicht. [Lesen Sie hier mehr](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/gpt-oss-reinforcement-learning.md) *** ***Danksagungen:** Ein riesiges Dankeschön an* [*Eyera*](https://huggingface.co/Orenguteng) *für den Beitrag zu diesem Leitfaden!* --- # 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 by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://unsloth.ai/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune/tutorial-how-to-fine-tune-gpt-oss.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. 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.