> 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/grundlagen/trainiere-dein-eigenes-entscheidungsmodell-mit-unsloth.md).
# Trainiere dein eigenes Entscheidungsmodell mit Unsloth
Feinabstimme LLMs wie Qwen und Gemma, um Entscheidungen mit kalibrierten Wahrscheinlichkeiten zu treffen.
Du kannst jetzt dein eigenes Entscheidungsmodell trainieren wie **Jev**, **Laya** und **Clef** mit Unsloth. Erfahre, wie man feinabstimmt [Qwen3.8](/docs/de/modelle/qwen3.8.md) und [Gemma 4](/docs/de/modelle/gemma-4.md) LLMs, effektive Datensatzformate entwirft und sie umwandelt in [Entscheidungsfindung](/docs/de/modelle/decision-laya.md) Modelle, die **Entscheidungen treffen** statt Text zu generieren. Das feinabgestimmte Modell liest deine Eingabe, bewertet die von dir bereitgestellten Optionen und gibt eine Wahl mit einer Wahrscheinlichkeit zurück.
TrainingsleitfadenDatensatzleitfadenDecision API + Bereitstellungsleitfaden
Siehe Tabelle für Benchmarks nach dem Training:
| Modell | typed-decisions | BANKING77 | CLINC150 | Holdout-Genauigkeit |
| ------------ | --------------- | ------------- | -------------- | ------------------- |
| Qwen3.5-0.8B | 36% -> **73%** | 7% -> **74%** | 19% -> **76%** | 78% |
| Qwen3.5-2B | 33% -> **78%** | 1% -> 58% | 1% -> 62% | 81% |
{% columns %}
{% column %}
Wir haben LLMs mit einem Clef-Head mittels LoRA (r=64) nur für eine Epoche feinabgestimmt und dabei die Genauigkeit auf nachgelagerten Aufgaben von 30–37 % (also ungefähr Zufallsniveau) auf **bis zu 78 % gesteigert**.
Das Training verwendet dasselbe Datensatzformat wie Laya und Clef. Testmengen wurden **entkontaminiert** gegenüber den Trainingsdaten.
{% endcolumn %}
{% column %}
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
**Alle Modelle** funktionieren ebenso gut – und du kannst auch **zusätzlich** Entscheidungsmodelle wie Laya / Clef feinabstimmen.
| Modell | Testgenauigkeit | VRAM | Trainingszeit |
| --------------------- | --------------- | ------- | ------------- |
| Qwen3.5-0.8B | 78% | 4 GB | 42 Min. |
| Qwen3.5-2B | 81% | 8 GB | 40 Min. |
| Llama 3.2 3B | 79% | 4,1 GB | 30 Min. |
| Gemma 4 E4B | 77% | 14,4 GB | 49 Min. |
| Laya (feinabgestimmt) | 77% | 2,5 GB | 10 Min. |
Wir haben eine Mischung aus **12 Quellen**, plus `typed-decisions`: `ag_news`, `arc`, `banking77`, `boolq`, `clinc150`, `commonsense_qa`, `mmlu`, `mnli`, `prompt_injections`, `snli`, `sst5` und `wanli`. Die **Testmenge umfasste 3.000 Zeilen**: 2.000 aus typed-decisions, 500 aus BANKING77 und 500 aus CLINC150.
### 🦥 In Unsloth trainieren
{% stepper %}
{% step %}
#### **Unsloth einrichten**
Der einfachste Weg zum Einstieg ist das Herunterladen der [Unsloth-Desktop-App](/docs/de/desktop.md). Funktioniert auf [macOS](/docs/de/loslegen/install/mac.md), [Windows](/docs/de/loslegen/install/windows-installation.md), und [Linux](/docs/de/loslegen/install/linux.md).
Unsloth herunterladen
Oder, wenn du es lieber manuell installieren möchtest:
MacOS, Linux, WSL:
```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```
Windows PowerShell:
```bash
irm https://unsloth.ai/install.ps1 | iex
```
{% endstep %}
{% step %}
#### **Wähle dein Modell und deinen Datensatz aus**
Öffne den Tab Train und wähle ein LLM wie `unsloth/Qwen3.5-4B`. Dann setze **Trainiere als** auf **Entscheidungsmodell**. Unsloth füllt Einstellungen aus, die gut funktionieren. Um unsere Ergebnisse zu erreichen, setze die Epochen auf 2, die LoRA-Rangzahl auf 16 und die Lernrate auf 2e-4.
Lade eine Datei hoch oder wähle einen Datensatz von Hugging Face im Datensatzformat aus. Für typed-decisions setze **Subset** auf `all`.
{% endstep %}
{% step %}
#### **Training starten**
Klicke auf **Training starten**. Unsloth meldet die Genauigkeit auf zurückgehaltenen Entscheidungen vor und nach dem Training und kalibriert die Zuversicht des Modells.
{% endstep %}
{% step %}
#### **Führe es in der Decision API aus**
Klicke auf **In der Decision API verwenden**. Anfragen, die `laya`, `default` oder `jev-latest` gehen jetzt an dein Modell.
Dein Modell erscheint in den Einstellungen → API außerdem unter seinem Run-Namen, unter Decision API → Model.
{% endstep %}
{% step %}
Du kannst das trainierte Entscheidungsmodell auch über die Option „Try It“ in der Decision API ausprobieren:
{% endstep %}
{% endstepper %}
### 📒 Verwende unsere kostenlosen Notebooks
Du kannst dein eigenes Entscheidungsmodell komplett kostenlos mit unseren Google-Colab- oder Kaggle-Notebooks trainieren. Sowohl Colab als auch Kaggle bieten großzügige kostenlose GPU-Rechenleistung, solange du ein Google-Konto hast. In diesen Notebooks gibt es einen Schritt-für-Schritt-Workflow, den du durchlaufen kannst, und wir zeigen dir, wie du die Daten vorbereitest, das eigentliche Modell trainierst (in diesem Fall Qwen3.5-4B) und es exportierst.
* Fine-tune Qwen3.5-4B zu einem Entscheidungsmodell mit unseren kostenlosen Notebooks:
| [**Google Colab** Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)-Decision.ipynb) | [**Kaggle** Notebook](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Qwen3_5_\(4B\)-Decision.ipynb\&accelerator=nvidiaTeslaT4) |
| ------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
Du kannst auch unser kostenloses Unsloth-Studio-Notebook verwenden, um ein Entscheidungsmodell mit einer UI-Oberfläche zu trainieren:
{% embed url="" %}
### 📈 Datensatzleitfaden
Datensätze für Entscheidungsmodelle enthalten eine Eingabe, Fragen zu dieser Eingabe und die korrekten Antworten. Jede Zeile verwendet drei Felder:
| Feld | Was es enthält |
| ----------------- | -------------------------------------------------------------------------- |
| `Zustand` | Die Eingabe, zum Beispiel eine Kundennachricht. |
| `Fragen` | Was das Modell entscheiden soll, mit Anweisungen und verfügbaren Optionen. |
| `Referenzantwort` | Die richtige Antwort auf jede Frage. |
Jede Zeile kann mehrere Fragen enthalten. `Fragen` und `Referenzantwort` können Python-Dictionaries oder JSON-kodierte Strings sein.
**Fragetypen**
| Typ | Was es bewirkt | Referenzantwort |
| ----------- | -------------------------------------------------------- | ----------------------------------------------------------- |
| `Auswahl` | Wählt eine Option aus `Kriterien`. | Der Optionsschlüssel, z. B. `"billing"`. |
| `noul` | Antwortet mit Ja oder Nein. | `True` oder `False` in Python; `true` oder `false` in JSON. |
| `Bewertung` | Wählt eine Stufe aus einer geordneten `Kriterien` Liste. | Der Index der Stufe, beginnend bei `0`. |
**Beispiel: Support-Tickets**
Dieses Beispiel verwendet die Support-Ticket-Fragen aus unserem [Notebook für Entscheidungsmodelle](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_%284B%29-Decision.ipynb), mit Trainingslabels und zwei zusätzlichen Beispiel-Tickets.
{% code expandable="true" %}
```python
questions = {
"team": {
"type": "choice",
"instructions": "Welches Team sollte das bearbeiten?",
"criteria": {
"billing": "invoices, payments, refunds",
"technical": "bugs, outages, errors",
"sales": "pricing, new plans",
},
},
"refund": {
"type": "noul",
"instructions": "Bittet der Kunde um eine Rückerstattung?",
},
"urgency": {
"type": "score",
"instructions": "Wie dringend ist das?",
"criteria": ["not urgent", "soon", "today"],
},
}
rows = [
{
"state": "Hi, I was charged twice for invoice #4411. Please refund the duplicate today.",
"questions": questions,
"gold": {"team": "billing", "refund": True, "urgency": 2},
},
{
"state": "The dashboard shows an error when I export a report. Please help in the next few days.",
"questions": questions,
"gold": {"team": "technical", "refund": False, "urgency": 1},
},
{
"state": "Could you send pricing for your business plan? We are researching for next year; no rush.",
"questions": questions,
"gold": {"team": "sales", "refund": False, "urgency": 0},
},
]
```
{% endcode %}
Jede Frage braucht eine passende Antwort in `Referenzantwort`. Auswahlantworten müssen mit einem Schlüssel in übereinstimmen `Kriterien`. Die Beschriftungen für Bewertungen beginnen bei `0`, also `"urgency": 2` bedeutet `"today"`.
Halte Eingaben in `Zustand` und Antworten in `Referenzantwort`. Diese Zeilen veranschaulichen das Format; füge vor dem Training weitere Beispiele hinzu, die deinen Anwendungsfall abdecken.
### 🎯 Entscheidungen treffen
Gib `predict` eine Eingabe und die zu entscheidenden Fragen im selben Format wie dein Datensatz:
{% code expandable="true" %}
```python
FastDecisionModel.for_inference(model)
answers = FastDecisionModel.predict(
model,
tokenizer,
"Hi, I was charged twice for invoice #4411. Please refund the duplicate today.",
{
"team": {
"type": "choice",
"instructions": "Welches Team sollte das bearbeiten?",
"criteria": {
"billing": "invoices, payments, refunds",
"technical": "bugs, outages, errors",
"sales": "pricing, new plans",
},
},
"refund": {"type": "noul", "instructions": "Does the customer ask for a refund?"},
"urgency": {
"type": "score",
"instructions": "Wie dringend ist das?",
"criteria": ["not urgent", "soon", "today"],
},
},
)
for name, result in answers.items():
print(name, result["answer"], {k: round(v, 3) for k, v in result["probabilities"].items()})
```
{% endcode %}
`Antwort` ist der Optionsschlüssel für choice, `True` oder `False` für noul und die Stufennummer für score. Jede Antwort hat außerdem dieselben Felder wie eine Antwort der Decision API.
Um die Genauigkeit auf einer beschrifteten Testmenge zu prüfen, verwende `evaluate`:
```python
test = load_dataset("LocalLLaMA/typed-decisions", "all", split = "test")
test_items, _ = FastDecisionModel.build_dataset(test, tokenizer, model)
print(FastDecisionModel.evaluate(model, tokenizer, test_items))
```
### Verwende es in der Decision API
Du kannst [unseren ausführlichen Leitfaden lesen](/docs/de/modelle/decision-laya.md) für das Bereitstellen/Ausführen von Entscheidungsmodellen; lies andernfalls unten die Kurzfassung. Modelle, die du in Unsloth trainierst, erscheinen in Einstellungen → API. Für ein Modell, das du mit Code trainiert hast, starte Unsloth mit dem gespeicherten zusammengeführten Ordner:
```bash
UNSLOTH_SYSTEMONE_MODEL=/path/to/qwen-decisions-merged unsloth studio -H 0.0.0.0 -p 8888
```
Schalte die Decision API in Einstellungen → API ein. Anfragen, die `laya`, `default` oder `jev-latest` gehen jetzt an dein Modell, und die Antworten haben dasselbe Format wie bei Laya. Das Modell benötigt eine GPU und wird bei der ersten Anfrage geladen, was ein paar Minuten dauern kann. Während ein Trainingslauf die GPU verwendet, wartet die Decision API und beginnt wieder mit dem Antworten, wenn der Lauf endet.
#### So funktioniert es
Unsloth packt deine Eingabe in einen einzigen Prompt, gefolgt von jeder Frage und ihren Optionen. Das LLM liest ihn einmal. Ein kleiner Head, mit demselben Design wie Cloudflares Clef, betrachtet die Ausgabe des LLM für jede Frage und Option und bewertet jede Option, sodass alle Fragen zusammen entschieden werden. Er schreibt nie Text, also verbraucht er keinen Speicher für die Wortvorhersagen des LLM.
### 🐍 Mit Code trainieren
Installiere oder aktualisiere Unsloth mit `pip install --upgrade unsloth`, und verwende den folgenden Code, um dein eigenes Entscheidungsmodell zu trainieren.
{% code expandable="true" %}
```python
from unsloth import FastDecisionModel, DecisionTrainer, is_bfloat16_supported
from datasets import load_dataset
from transformers import TrainingArguments
model, tokenizer = FastDecisionModel.from_pretrained(
model_name = "unsloth/Qwen3.5-4B",
max_seq_length = 2048,
load_in_4bit = True,
)
model = FastDecisionModel.get_peft_model(
model,
r = 16,
lora_alpha = 16,
lora_dropout = 0,
use_gradient_checkpointing = "unsloth",
random_state = 3407,
)
dataset = load_dataset("LocalLLaMA/typed-decisions", "all", split = "train")
items, report = FastDecisionModel.build_dataset(dataset, tokenizer, model)
print(f"Skipped {report['skipped']} of {report['total']} decisions")
train_items, eval_items = FastDecisionModel.split_holdout(items, seed = 3407)
print(f"{len(train_items)} training rows, {len(eval_items)} held out")
from transformers import TrainingArguments
trainer = DecisionTrainer(
model = model,
processing_class = tokenizer,
train_dataset = train_items,
eval_dataset = eval_items,
args = TrainingArguments(
per_device_train_batch_size = 2,
gradient_accumulation_steps = 4, # Use GA to mimic batch size!
warmup_steps = 10,
# num_train_epochs = 2, # Set this for 1 full training run.
max_steps = 240,
learning_rate = 2e-5,
lr_scheduler_type = "cosine",
weight_decay = 0.01,
bf16 = is_bfloat16_supported(),
fp16 = not is_bfloat16_supported(),
eval_strategy = "epoch",
logging_steps = 1,
output_dir = "outputs",
report_to = "none", # Use TrackIO/WandB etc
seed = 3407,
),
)
trainer_stats = trainer.train()
```
{% endcode %}
Um Llama oder Gemma 4 zu verwenden, ändere `model_name` auf `unsloth/Llama-3.2-3B-Instruct` oder `unsloth/gemma-4-E4B-it`. Andere LLMs, die Unsloth feinabstimmen kann, sollten auf die gleiche Weise funktionieren.
Für deine eigenen Daten siehe das Datensatzformat. Jede Zeile hat einen Zustand, die zu entscheidenden Fragen und die Goldantworten.
#### Kalibrieren und speichern
Kalibriere auf den Zeilen `split_holdout` zurückgehalten, damit die Wahrscheinlichkeiten des Modells dazu passen, wie oft es richtig liegt:
```python
metrics = FastDecisionModel.calibrate(model, tokenizer, eval_items)
print(metrics) # Genauigkeit auf zurückgehaltenen Daten, Kalibrierungsfehler (ece) und Verlust
```
Dann speichern. `save_pretrained` speichert die LoRA-Adapter und den Head. `save_pretrained_merged` speichert ein vollständiges 16-Bit-Modell:
```python
model.save_pretrained("qwen-decisions")
model.save_pretrained_merged("qwen-decisions-merged")
# model.push_to_hub("hf_username/qwen-decisions", token = "hf_...")
```
Lade es erneut auf dieselbe Weise, wie du das Basismodell geladen hast:
```python
model, tokenizer = FastDecisionModel.from_pretrained("qwen-decisions", load_in_4bit = True)
```
### ⚙️ Empfohlene Einstellungen
* Beginne mit 4-Bit-LoRA bei Rang 16 und einer Lernrate von 2e-4. Der neue Head trainiert standardmäßig mit 1e-4. Du kannst das mit `head_learning_rate` in `DecisionTrainer`.
* Wir haben auf typed-decisions 2 Epochen verwendet. Bei weniger Daten versuche 3 oder 4.
* Für einen schnellen Test setze `max_steps = 60`. Qwen3.5-4B erreichte auf einer L4 in 10 Minuten 76 %.
* Wenn dir der Speicher ausgeht, halbiere die Batchgröße und verdopple die Gradient Accumulation.
* `max_seq_length` legt die längste Eingabe während des Trainings fest. Lange Eingaben behalten die Fragen und Optionen und schneiden das Ende der Eingabe ab, damit es passt. Vorhersagen lesen bis zu 16.384 Tokens.
---
# 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/grundlagen/trainiere-dein-eigenes-entscheidungsmodell-mit-unsloth.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.
