> 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/neu/studio/start.md).

# Erste Schritte mit Unsloth Studio

Ein Leitfaden für den Einstieg in das Fine-Tuning-Studio, Datenrezepte, das Exportieren von Modellen und den Chat.

Unsloth Studio ist eine lokale, browserbasierte GUI zum Finetuning von LLMs, ohne Code zu schreiben. Es verpackt die Trainingspipeline in eine übersichtliche Oberfläche, die das Laden von Modellen, das Formatieren von Datensätzen, die Konfiguration von Hyperparametern und die Live-Überwachung des Trainings übernimmt.

<a href="https://unsloth.ai/docs/new/studio/start#unsloth-quickstart" class="button secondary" data-icon="bolt">Unsloth</a><a href="/docs/de/neu/studio/start.md#data-recipes-quickstart" class="button secondary" data-icon="hat-chef">Datenrezept</a><a href="/docs/de/neu/studio/start.md#export-quickstart" class="button secondary" data-icon="box-isometric">Exportiere</a><a href="/docs/de/neu/studio/start.md#chat-quickstart" class="button secondary" data-icon="comment-dots">Chat</a>

#### Unsloth Studio einrichten

**Mit Unsloth Desktop installieren.** Der einfachste Weg, Unsloth Studio zu installieren, ist mit der nativen Desktop-App. Lade sie für dein Betriebssystem herunter:

* <i class="fa-apple">:apple:</i> [Download für macOS](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Download für Windows](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Download für Linux](https://unsloth.ai/download/linux)

Für eine manuelle Installation von Unsloth Studio verwende die folgenden Befehle:

{% tabs %}
{% tab title="MacOS, Linux, WSL" %}
**Unsloth installieren:**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

Verwenden Sie denselben Befehl zum Aktualisieren.
{% endtab %}

{% tab title="Windows" %}
**Unsloth installieren:**

```powershell
irm https://unsloth.ai/install.ps1 | iex
```

Verwenden Sie denselben Befehl zum Aktualisieren.
{% endtab %}

{% tab title="Docker" %}
Das [Unsloth-Docker-Image](https://hub.docker.com/r/unsloth/unsloth) `unsloth/unsloth` ist auf Docker verfügbar. [Anleitung lesen.](https://unsloth.ai/docs/get-started/install/docker)
{% endtab %}

{% tab title="Homebrew" %}
Unsloth Desktop installieren:

{% code collapsedlinecount="10" %}

```bash
brew install --cask unsloth
```

{% endcode %}

Unsloth Desktop aktualisieren:

```bash
brew upgrade --cask unsloth
```

{% endtab %}

{% tab title="WinGet" %}
Unsloth Desktop installieren:

```powershell
winget install --id UnslothAI.Unsloth -e
```

Unsloth Desktop aktualisieren:

```powershell
winget upgrade --id UnslothAI.Unsloth -e
```

{% endtab %}
{% endtabs %}

Starten Sie Unsloth Studio zunächst entweder über eine lokale Installation oder eine Cloud-Option. Folgen Sie der [Installationsanleitung](/docs/de/neu/studio/install.md) für Ihr Setup, oder nutzen Sie unser [kostenloses Colab](/docs/de/neu/studio.md#google-colab-notebook) Notebook. Für ein lokales Setup führen Sie Folgendes aus:

```bash
unsloth studio
```

{% columns %}
{% column width="50%" %}
Öffnen Sie den Browser Ihrer Wahl und gehen Sie zu `http://127.0.0.1:8888`. Sie müssen ein neues Passwort erstellen.

**Unsloth sicher mit HTTPS und Cloudflare starten.** Unsloth bietet jetzt eine sichere Möglichkeit, Unsloth über HTTPS durch einen kostenlosen Cloudflare-Tunnel zu starten. Verwenden Sie das Folgende (funktioniert unter Windows, Mac und Linux):

```bash
unsloth studio --secure
```

{% endcolumn %}

{% column width="50%" %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FZPtRrwafzmVX54HhyyBD%2FScreenshot%202026-03-16%20at%2011.25.22%E2%80%AFPM.png?alt=media&amp;token=9153c153-ec61-4fff-b1b9-db7f70ac2936" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

## <i class="fa-comment-dots">:comment-dots:</i> Chat - Schnellstart

[Unsloth Studio Chat](/docs/de/neu/studio/chat.md) ermöglicht es Ihnen, Modelle 100 % offline auf Ihrem Computer auszuführen. Führen Sie Modellformate wie GGUF und safetensors von Hugging Face oder aus Ihren lokalen Dateien aus.

* **Herunterladen + Ausführen** jedes Modell wie GGUFs, feinabgestimmte Adapter, safetensors usw.
* [**Vergleichen** verschiedene Modelle](#model-arena) Ausgaben nebeneinander
* **Hochladen** Dokumente, Bilder und Audio in Ihren Prompts
* [**Anpassen** Inferenz](#generation-settings) Einstellungen wie: Temperatur, Top-p, Top-k und Systemprompt

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FRCnTAZ6Uh88DIlU3g0Ij%2Fmainpage%20unsloth.png?alt=media&amp;token=837c96b6-bd09-4e81-bc76-fa50421e9bfb" alt="" width="563"><figcaption></figcaption></figure>

Sie können unser detailliertes Tutorial / unseren Leitfaden zum Ausführen von Modellen mit Unsloth Studio hier lesen:

{% content-ref url="/pages/73168493b14a89fa27e95b776ade6bd93679a3e5" %}
[Chat with models](/docs/de/neu/studio/chat.md)
{% endcontent-ref %}

### Modell-Ladeleitfaden

Bevor Sie die API verwenden, müssen Sie das **Modell laden** das Sie verwenden möchten in **Unsloth.** Öffnen Sie das **Modell auswählen** Dropdown-Menü in der oberen linken Ecke der Chat-Seite.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FuZqd6tcZ5LgMSh4ZND5x%2Fexport-1778505117710-24fps.gif?alt=media&amp;token=9defec95-5404-4654-9c33-67be967c9820" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Auf einer anderen Seite? Verwenden Sie die linke Seitenleiste und klicken Sie auf `Neuer Chat` um zur Chat-Seite zurückzukehren.
{% endhint %}

{% columns %}
{% column width="50%" %}

#### Modell auswählen

Verwenden Sie die Suchleiste, um das Modell zu finden, das Sie in Unsloth laden möchten.

Durchsuchen Sie empfohlene Modelle, suchen Sie direkt nach Hugging-Face-Modellen oder legen Sie ein benutzerdefiniertes Modellverzeichnis fest.

Lokal trainierte und exportierte Modelle können aus dem Tab \`Feinabgestimmt\` geladen werden.
{% endcolumn %}

{% column width="50%" %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FxZs1wCOyXbAeKVCjSMff%2Fimage.png?alt=media&amp;token=49812361-d723-4286-93c6-7df6989c33c5" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

{% columns %}
{% column %}

#### GGUF-Auswahl

Model-Repositories enthalten mehrere Quantisierungen. Wählen Sie die Quantisierung aus, die für Ihren verfügbaren RAM / VRAM am besten geeignet ist.\
\
In diesem Leitfaden verwenden wir `unsloth/gemma-4-26B-A4B-it-GGUF` und wählen die empfohlene `UD-Q4_K_XL` Variante aus
{% endcolumn %}

{% column %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FlNXz1I4EhHUFB5zihpSk%2Fimage.png?alt=media&amp;token=44733b70-9c03-4371-a836-9401b2748a0d" alt="" width="375"><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

#### Das Modell wird heruntergeladen

{% columns %}
{% column %}
Suchen Sie nach dem Modell, das Sie verwenden möchten, und dann **klicken Sie darauf** um mit dem Herunterladen und Laden zu beginnen.

Nach der Auswahl einer Modellvariante beginnt Unsloth, das Modell herunterzuladen und in den Speicher zu laden.

Sobald das Laden abgeschlossen ist, sehen Sie die folgende Bestätigung:
{% endcolumn %}

{% column %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FzodWb7AaZH6HtE4lXopz%2Fimage.png?alt=media&amp;token=6f3ba3c1-54e2-4077-a1e7-11a9bebd820c" alt=""><figcaption></figcaption></figure>

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FsF5iWCQrYTBi6xcHxoUM%2Fimage.png?alt=media&amp;token=ed16b837-497a-48b5-9019-724f317f71dd" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Das Modell ist geladen und bereit zur Verwendung. Sie können jetzt direkt in Unsloth mit dem Modell chatten oder es mit Tools verbinden wie [Claude Code](/docs/de/grundlagen/claude-code.md) und [Codex](/docs/de/grundlagen/codex.md).

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FKoonE97b0H3RioMwVohd%2Fstudio%20new%20ui.gif?alt=media&amp;token=e37f2839-914e-48b8-8c81-2dac3ade9408" alt=""><figcaption></figcaption></figure>

## <i class="fa-bolt">:bolt:</i> Unsloth - Schnellstart

Die Unsloth Studio-Startseite hat 4 Hauptbereiche: [Modell](#id-1.-select-model-and-method), [Datensatz](#id-2.-dataset), [Parameter](#id-3.-hyperparameters), und [Training/Konfiguration](#id-4.-training-and-config)

* **Einfache Einrichtung für Modelle und Daten** von Hugging Face oder lokalen Dateien
* **Flexible Trainingsoptionen** wie QLoRA, LoRA oder Full Finetuning, mit ausgefüllten Standardwerten
* **Hilfreiche Konfigurationstools** für Splits, Spaltenzuordnung, Hyperparameter und YAML-Konfigurationen
* **Große Trainingsübersicht** mit Live-Fortschritt, GPU-Statistiken, Diagrammen und Startstatus

<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%2FxV1PO5DbF3ksB51nE2Tw%2Fmore%20cropped%20ui%20for%20homepage.png?alt=media&amp;token=f75942c9-3d8d-4b59-8ba2-1a4a38de1b86" alt="" width="563"><figcaption></figcaption></figure></div>

### 1. Modell und Methode auswählen

#### **Modelltyp**

Wählen Sie die Modalität, die zu Ihrem Anwendungsfall passt:

| Typ            | Anwendungsfall                               |
| -------------- | -------------------------------------------- |
| **Text**       | Chat, Anweisungsbefolgung, Vervollständigung |
| **Vision**     | Bild + Text (VLMs)                           |
| **Audio**      | Sprach- / Audioverständnis                   |
| **Embeddings** | Satz-Embeddings, Suche                       |

#### **Trainingsmethode**

Es stehen drei Methoden zur Verfügung, umgeschaltet mit einem Pillen-Selektor:

| Methode                      | Beschreibung                                   | VRAM           |
| ---------------------------- | ---------------------------------------------- | -------------- |
| **QLoRA**                    | 4-Bit quantisiertes Basismodell + LoRA-Adapter | Am niedrigsten |
| **LoRA**                     | Basismodell in voller Präzision + LoRA-Adapter | Mittel         |
| **Vollständiges Finetuning** | Alle Gewichte werden trainiert                 | Am höchsten    |

Geben Sie einen beliebigen Hugging-Face-Modellnamen ein oder suchen Sie direkt über das Kombinationsfeld im Hub. Lokale Modelle, die in `~/.unsloth/studio/models` gespeichert sind, und Ihr Hugging-Face-Cache erscheinen ebenfalls in der Liste.

{% hint style="warning" %}
Modelle im GGUF-Format sind vom Training ausgeschlossen - sie sind nur für die Inferenz.
{% endhint %}

Wenn Sie ein Modell auswählen, ruft Unsloth automatisch seine Konfiguration vom Backend ab und füllt sinnvolle Standardwerte für alle Hyperparameter vor.

**HuggingFace-Token**

Fügen Sie hier Ihr Hugging-Face-Zugriffstoken ein, wenn das Modell gesperrt ist (z. B. Llama, Gemma). Das Token wird in Echtzeit validiert und bei Ungültigkeit wird ein Fehler direkt angezeigt.

### 2. Datensatz

{% columns %}
{% column %}
Wechseln Sie zwischen zwei Tabs, um auszuwählen, woher Ihre Daten stammen:

* **HuggingFace Hub** - Live-Suche im Hub. Das Datum der letzten Aktualisierung wird für jedes Ergebnis angezeigt.
* **Lokal** - per Drag-and-Drop oder Klick eine Datei hochladen, unstrukturierte oder strukturierte Dateien wie: `PDF`, `DOCX`, `JSONL`, `JSON`, `CSV`, oder `Parquet` Format. Zuvor hochgeladene Datensätze erscheinen in einer Liste, die sich automatisch aktualisiert.

Sie können unseren detaillierten [Datensatz-Leitfaden hier ansehen](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md).

Weisen Sie Unsloth an, wie Ihre Daten interpretiert und formatiert werden sollen:
{% 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%2FCtWUm7GdHnKbe14fUQyT%2Fupdated_dataset.webp?alt=media&amp;token=3fcefe8d-b6a4-44c2-be9b-6dc282166095" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

| Format     | Wann zu verwenden                              |
| ---------- | ---------------------------------------------- |
| `auto`     | Unsloth das Format automatisch erkennen lassen |
| `alpaca`   | `instruction` / `input` / `output` Spalten     |
| `chatml`   | OpenAI-Stil `messages` Array                   |
| `sharegpt` | ShareGPT-Stil-Unterhaltungen                   |

**Splits und Slicing**

* **Teilmenge** - wird automatisch aus der Dataset-Karte übernommen.
* **Train-Split / Eval-Split** - wählen Sie aus, welche Splits verwendet werden sollen. Das Festlegen eines Eval-Splits aktiviert den **Eval-Verlust** Diagramm während des Trainings.
* **Datensatz-Ausschnitt** - optional das Training auf einen Zeilenbereich einschränken (Startindex / Endindex) für schnelle Experimente.

**Spaltenzuordnung**

Wenn Unsloth Ihre Datensatzspalten nicht automatisch den richtigen Rollen zuordnen kann, öffnet sich ein **Dialog zur Datensatzvorschau** Er zeigt Beispielzeilen und ermöglicht es Ihnen, jede Spalte zuzuordnen zu `instruction`, `input`, `output`, `Bild-`, usw. Vorgeschlagene Zuordnungen werden, wo möglich, vorab ausgefüllt.

### 3. Hyperparameter

Parameter sind in einklappbare Abschnitte gruppiert. Sie können unseren detaillierten [Leitfaden zu LoRA-Hyperparametern](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md) hier ansehen:

{% content-ref url="/pages/ce825bbf83c91ef73a7fc71d696bd3d1ecc78590" %}
[Hyperparameters Guide](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md)
{% endcontent-ref %}

| Parameter             | Standard | Hinweise                                   |
| --------------------- | -------- | ------------------------------------------ |
| **Maximale Schritte** | `0`      | `0` bedeutet stattdessen Epochen verwenden |
| **Kontextlänge**      | `2048`   | Optionen: 512 → 32768                      |
| **Lernrate**          | `2e-4`   |                                            |

**LoRA-Einstellungen**

*(Ausgeblendet, wenn Full Finetuning ausgewählt ist)*

| Parameter         | Standard | Hinweise                                                                    |
| ----------------- | -------- | --------------------------------------------------------------------------- |
| **Rank**          | `16`     | Schieberegler 4–128                                                         |
| **Alpha**         | `32`     | Schieberegler 4–256                                                         |
| **Dropout**       | `0.05`   |                                                                             |
| **LoRA-Variante** | `LoRA`   | `LoRA` / `RS-LoRA` / `LoftQ`                                                |
| **Zielmodule**    | Alle an  | `q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj` |

Für **Vision** bei Modellen mit einem Bilddatensatz erscheinen vier zusätzliche Kontrollkästchen. Finetuning von:

| Vision-Layer | Sprach-Layer | Attention-Module | MLP-Module |
| ------------ | ------------ | ---------------- | ---------- |

**Trainings-Hyperparameter**

In drei Tabs organisiert:

{% tabs %}
{% tab title="Optimierung" %}

| Parameter              | Standard    |
| ---------------------- | ----------- |
| Epochen                | 3           |
| Batch-Größe            | 4           |
| Gradientenakkumulation | 8           |
| Gewichtsabfall         | 0.01        |
| Optimierer             | AdamW 8-Bit |

{% endtab %}

{% tab title="Plan" %}

| Parameter                       | Standard |
| ------------------------------- | -------- |
| LR-Scheduler                    | linear   |
| Warmup-Schritte                 | 5        |
| Gradienten-Checkpointing        | unsloth  |
| Zufalls-Seed                    | 3407     |
| Speicherschritte                | 0        |
| Eval-Schritte                   | 0        |
| Packing                         | false    |
| Auf Komplettierungen trainieren | false    |
| {% endtab %}                    |          |

{% tab title="Protokollierung" %}

| Parameter               | Standard       |
| ----------------------- | -------------- |
| W\&B aktivieren         | false          |
| W\&B-Projekt            | llm-finetuning |
| TensorBoard aktivieren  | false          |
| TensorBoard-Verzeichnis | runs           |
| Protokollfrequenz       | 10             |
| {% endtab %}            |                |
| {% endtabs %}           |                |

{% hint style="info" %}
[**Unsloth-Gradienten-Checkpointing**](/docs/de/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)**: `unsloth`** verwendet Unsloths eigene speichereffiziente Implementierung, die den VRAM-Verbrauch im Vergleich zur standardmäßigen PyTorch-Option erheblich reduzieren kann. Es ist der empfohlene Standard.
{% endhint %}

### 4. Training und Konfiguration

Die Karte unten rechts hat drei Schaltflächen zur Konfigurationsverwaltung und die **Training starten** Schaltfläche.

| Schaltfläche     | Aktion                                                        |
| ---------------- | ------------------------------------------------------------- |
| **Hochladen**    | Eine zuvor gespeicherte `.yaml` Konfigurationsdatei laden     |
| **Speichern**    | Die aktuelle Konfiguration als YAML exportieren               |
| **Zurücksetzen** | Alle Parameter auf die Standardwerte des Modells zurücksetzen |

Die Schaltfläche Training starten bleibt deaktiviert, bis sowohl ein Modell als auch ein Datensatz konfiguriert sind. Validierungsfehler werden direkt angezeigt - zum Beispiel, wenn Eval-Schritte festgelegt werden, ohne einen Eval-Split auszuwählen, oder wenn ein reines Textmodell mit einem Vision-Datensatz kombiniert wird.

#### Ladebildschirm

{% columns %}
{% column %}
Nachdem Sie auf **Training starten**klicken, erscheint ein Overlay über die gesamte Seite, während das Backend alles vorbereitet.

<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%2FYtsUxHI0szGw8ZPxCHep%2Fimage.png?alt=media&amp;token=1701f4af-ef35-48da-80e7-4aba4e80f4d4" alt="" width="375"><figcaption></figcaption></figure></div>
{% endcolumn %}

{% column %}
Das Overlay zeigt ein animiertes Terminal mit Live-Phasenaktualisierungen:

* Blau: Modell / Datensatz wird heruntergeladen
* Bernstein: Modell / Datensatz wird geladen
* Blau: Konfigurieren
* Grün: Training

Sie können jederzeit abbrechen mit der **×** Schaltfläche in der Ecke. Bevor etwas gestoppt wird, erscheint ein Bestätigungsdialog.
{% endcolumn %}
{% endcolumns %}

### Trainingsfortschritt und Beobachtbarkeit

Sobald der erste Trainingsschritt erreicht ist, wird das Overlay ausgeblendet und die Live-Trainingsansicht wird angezeigt. Der Finetuning-Prozess ist abgeschlossen, wenn die Schritte in der Fortschrittsanzeige 100 % erreichen. Sie können die verstrichene Zeit und die Tokens sehen.&#x20;

<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%2Fah3G1rYgRaDNY8Ay6Uw7%2Fimage.png?alt=media&amp;token=0528c15e-7a4b-4028-8070-95dc0871da5d" alt="" width="563"><figcaption></figcaption></figure></div>

{% columns %}
{% column %}

#### Statusbereich

Die linke Spalte zeigt:

* **Epoche** - aktuelle Bruchzahl-Epoche (z. B. `Epoche 1,23`)
* **Fortschrittsanzeige** - schrittbasiert, mit Prozentangabe
* **Wichtige Kennzahlen**:
  * **Verlust** - Trainingsverlust auf 4 Dezimalstellen
  * **LR** - aktuelle Lernrate in wissenschaftlicher Schreibweise
  * **Grad-Norm** - Gradienten-Norm
  * **Modell** - das trainierte Modell
  * **Methode** - `QLoRA` / `LoRA` / `Vollständig`
* **Zeitzeile** - verstrichene Zeit, ETA, Schritte pro Sekunde und insgesamt verarbeitete Tokens
  {% endcolumn %}

{% column %}

#### GPU-Monitor

Die rechte Spalte zeigt Live-GPU-Statistiken, die alle paar Sekunden abgefragt werden:

* **Auslastung** - Prozentbalken
* **Temperatur** - °C-Balken
* **VRAM** - verwendet / insgesamt GB
* **Leistung** - Verbrauch / Limit in Watt

#### Training stoppen

Verwenden Sie die **Training stoppen** Schaltfläche oben rechts auf der Fortschrittskarte. Ein Dialog bietet Ihnen zwei Optionen:

* **Stoppen & Speichern** - speichert einen Checkpoint vor dem Stoppen
* **Abbrechen** - stoppt sofort ohne Checkpoint
  {% endcolumn %}
  {% endcolumns %}

{% columns %}
{% column %}

#### Diagramme

Vier Live-Diagramme werden aktualisiert, während das Training voranschreitet:

1. **Trainingsverlust** - Rohwerte plus eine EMA-geglättete Linie und eine Referenzlinie des laufenden Durchschnitts
2. **Lernrate** - die LR-Plan-Kurve
3. **Gradienten-Norm** - Gradienten-Norm über die Schritte hinweg
4. **Eval-Verlust** - wird nur angezeigt, wenn Sie einen Eval-Split konfiguriert haben
   {% 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%2FRgXfe3sobdQWxha8yslr%2Fimage.png?alt=media&amp;token=b3aa9004-778b-4e3d-85b1-40a205ad0602" alt="" width="278"><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% columns %}
{% column %}
Jedes Diagramm hat Einstellungen (Zahnradsymbol) mit:

| Option                      | Standard                                 |
| --------------------------- | ---------------------------------------- |
| Ansichtsfenster             | Schieberegler für die letzten N Schritte |
| EMA-Glättung                | `0.6`                                    |
| Roh anzeigen                | An                                       |
| Geglättet anzeigen          | An                                       |
| Durchschnittslinie anzeigen | An                                       |
| Skalierung (pro Reihe)      | Linear / Log                             |
| Ausreißerbegrenzung         | Keine Begrenzung / p99 / p95             |
| {% 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%2FFJtjQpAgOFaieyQCYhkq%2Fimage.png?alt=media&amp;token=4da9cdc2-c088-4ab8-8d0d-40d8d392ee03" alt="" width="276"><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

#### Konfigurationsdateien

{% columns %}
{% column %}
Alle Trainingskonfigurationen können als YAML-Dateien gespeichert und neu geladen werden. Dateien werden automatisch benannt als:

```
{model}_{method}_{dataset}_{timestamp}.yaml
```

{% 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%2FuGAKdGkANbh2wIENA9X7%2Fimage.png?alt=media&amp;token=9553db5b-5c88-4556-be49-fe61035edf11" alt="" width="178"><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

Das YAML ist in drei Abschnitte unterteilt:

{% code expandable="true" %}

```yaml
training:
  max_steps: 0
  num_train_epochs: 3
  per_device_train_batch_size: 4
  ...

lora:
  r: 16
  lora_alpha: 32
  ...

logging:
  report_to: none
  ...
```

{% endcode %}

Dadurch ist es einfach, Läufe zu reproduzieren, Konfigurationen zu teilen oder Ihre Experimente zu versionieren.

## <i class="fa-hat-chef">:hat-chef:</i> Data Recipes - Schnellstart

[Unsloth Data Recipes](/docs/de/neu/studio/data-recipe.md) ermöglicht Ihnen, Dokumente wie PDFs oder CSV-Dateien hochzuladen und sie in nutzbare Datensätze umzuwandeln. Erstellen und bearbeiten Sie Datensätze visuell über einen Workflow mit Graph-Knoten.

Die Rezepteseite ist der zentrale Einstiegspunkt. Rezepte werden lokal im Browser gespeichert, sodass Sie später zu Ihrer gespeicherten Arbeit zurückkehren können. Von hier aus können Sie ein leeres Rezept erstellen oder ein geführtes Lernrezept öffnen.

<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%2FQ6e19jESrJg0VjHnX58c%2Fdata%20recipes%20final.png?alt=media&amp;token=8d74e453-815d-4790-83d1-76d0bc80a3ce" alt="" width="563"><figcaption></figcaption></figure></div>

Data Recipes folgt demselben grundlegenden Ablauf. Sie öffnen die Rezepteseite, erstellen oder wählen ein Rezept, bauen den Workflow im Editor auf, validieren ihn, führen eine Vorschau aus und verarbeiten dann den vollständigen Datensatz, sobald die Ausgabe korrekt aussieht. Fügen Sie Seed-Daten und Generierungsblöcke hinzu, validieren Sie den Workflow, sehen Sie sich Beispielausgaben in der Vorschau an und starten Sie dann einen vollständigen Datensatzlauf. Unsloth Data Recipes wird von NVIDIA unterstützt [DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner).

Ein typischer Workflow sollte auf einen Blick so aussehen:

1. Öffnen Sie die Rezepteseite.
2. Erstellen Sie ein neues Rezept oder öffnen Sie ein vorhandenes.
3. Fügen Sie Blöcke hinzu, um Ihren Datensatz-Workflow zu definieren.
4. Klicken Sie auf **Validieren** um Konfigurationsprobleme frühzeitig zu erkennen.
5. Führen Sie eine Vorschau aus, um Beispielzeilen schnell zu prüfen.
6. Führen Sie einen vollständigen Datensatzaufbau aus, wenn das Rezept bereit ist.
7. Verfolgen Sie Fortschritt und Ausgabe live im Diagramm oder in **Ausführungen** Ansicht für weitere Details.
8. Wählen Sie den resultierenden Datensatz in **Unsloth** und ein Modell feinabstimmen.

## <i class="fa-box-isometric">:box-isometric:</i> Export - Schnellstart

Verwenden Sie in Unsloth Studio 'Export', um Modelle für Bereitstellung, Weitergabe oder lokale Inferenz in Unsloth, llama.cpp, Ollama, vLLM und mehr nach GGUF, Safetensors oder LoRA zu exportieren, zu speichern oder zu konvertieren. Exportieren Sie einen trainierten Checkpoint oder konvertieren Sie ein beliebiges vorhandenes Modell.

<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%2FrrFY8YczW3dDpfYi1k9f%2FScreenshot%202026-03-15%20at%209.28.19%E2%80%AFPM.png?alt=media&amp;token=d2729e16-799f-48f0-8b07-0248b93fa599" alt="" width="563"><figcaption></figcaption></figure></div>

Hier können Sie unser ausführliches Tutorial/Handbuch zum Exportieren von Modellen mit Unsloth Studio lesen:

{% content-ref url="/pages/13c9d0063a9732a68734b74792f3e30153873bf4" %}
[Model Export](/docs/de/neu/studio/export.md)
{% endcontent-ref %}

## <i class="fa-video">:video:</i> Video-Tutorial

{% hint style="warning" %}
Die in den Videos gezeigten Unsloth Studio-Versionen sind veraltet und entsprechen nicht der aktuellen Version.
{% endhint %}

{% columns %}
{% column %}
{% embed url="<https://www.youtube.com/watch?v=mmbkP8NARH4>" %}

Hier ist ein von NVIDIA erstelltes Video-Tutorial, das Ihnen den Einstieg in Unsloth erleichtert:
{% endcolumn %}

{% column %}
{% embed url="<https://youtu.be/1lEDuRJWHh4?si=GHaS77ZZPOGjn3GJ>" %}

Video-Tutorial: So installieren Sie Unsloth Studio
{% endcolumn %}
{% endcolumns %}

## Erweiterte Einstellungen

### CLI-Befehle

Die Unsloth-CLI (`cli.py`) bietet die folgenden Befehle:

```
Verwendung: cli.py [BEFEHL]

Befehle:
  train             Ein Modell feinabstimmen
  inference         Inferenz auf einem trainierten Modell ausführen
  export            Einen trainierten Adapter exportieren
  list-checkpoints  Gespeicherte Checkpoints auflisten
  ui                Die Web-UI von Unsloth Studio starten
  studio            Das Studio starten (Alias)
```

### Projektstruktur

{% code expandable="true" %}

```
new-ui-prototype/
├── cli.py                     # CLI-Einstiegspunkt
├── cli/                       # Typer-CLI-Befehle
│   └── commands/
│       ├── train.py
│       ├── inference.py
│       ├── export.py
│       ├── ui.py
│       └── studio.py
├── setup.sh                   # Bootstrap-Skript (Linux / WSL / Colab)
├── setup.ps1                  # Bootstrap-Skript (natives Windows)
├── setup.bat                  # Wrapper zum Starten von setup.ps1 per Doppelklick
├── install_python_stack.py    # Plattformübergreifender Python-Abhängigkeitsinstaller
└── studio/
    ├── backend/
    │   ├── main.py            # FastAPI-App und Middleware
    │   ├── run.py             # Server-Startprogramm (uvicorn)
    │   ├── auth/              # Auth-Speicher und JWT-Logik
    │   ├── routes/            # API-Routen-Handler
    │   │   ├── training.py
    │   │   ├── models.py
    │   │   ├── inference.py
    │   │   ├── datasets.py
    │   │   └── auth.py
    │   ├── models/            # Pydantic-Anfrage-/Antwortschemata
    │   ├── core/              # Trainings-Engine und Konfiguration
    │   ├── utils/             # Hardware-Erkennung, Hilfsprogramme
    │   └── requirements.txt
    ├── frontend/
    │   ├── src/
    │   │   ├── features/      # Feature-Module
    │   │   │   ├── auth/      # Login-/Registrierungsablauf
    │   │   │   ├── training/  # Trainingskonfiguration und Überwachung
    │   │   │   ├── studio/    # Haupt-Arbeitsbereich des Studios
    │   │   │   ├── chat/      # Chat-UI für Inferenz
    │   │   │   ├── export/    # Modell-Exportablauf
    │   │   │   └── onboarding/# Onboarding-Assistent
    │   │   ├── components/    # Geteilte UI-Komponenten (shadcn)
    │   │   ├── hooks/         # Benutzerdefinierte React-Hooks
    │   │   ├── stores/        # Zustand-Statusspeicher
    │   │   └── types/         # TypeScript-Typdefinitionen
    │   ├── package.json
    │   └── vite.config.ts
    └── tests/                 # Backend-Test-Suite
```

{% endcode %}

### API-Referenz

Alle Endpunkte erfordern ein gültiges JWT `Authorization: Bearer <token>` Header (außer `/api/auth/*` und `/api/health`).

| Methode | Endpunkt              | Beschreibung                                                  |
| ------- | --------------------- | ------------------------------------------------------------- |
| `GET`   | `/api/health`         | Gesundheitsprüfung                                            |
| `GET`   | `/api/system`         | Systeminformationen (GPU, CPU, Arbeitsspeicher)               |
| `POST`  | `/api/auth/signup`    | Konto erstellen (erfordert beim ersten Start ein Setup-Token) |
| `POST`  | `/api/auth/login`     | Anmelden und JWT-Tokens empfangen                             |
| `POST`  | `/api/auth/refresh`   | Ein abgelaufenes Zugriffstoken aktualisieren                  |
| `GET`   | `/api/auth/status`    | Prüfen, ob die Authentifizierung initialisiert ist            |
| `POST`  | `/api/train/start`    | Trainingsauftrag starten                                      |
| `POST`  | `/api/train/stop`     | Laufenden Trainingsauftrag stoppen                            |
| `POST`  | `/api/train/reset`    | Trainingszustand zurücksetzen                                 |
| `GET`   | `/api/train/status`   | Aktuellen Trainingsstatus abrufen                             |
| `GET`   | `/api/train/metrics`  | Trainingsmetriken abrufen (Loss, LR, Schritte)                |
| `GET`   | `/api/train/stream`   | SSE-Stream des Trainingsfortschritts in Echtzeit              |
| `GET`   | `/api/models/`        | Verfügbare Modelle auflisten                                  |
| `POST`  | `/api/inference/chat` | Eine Chatnachricht für die Inferenz senden                    |
| `GET`   | `/api/datasets/`      | Datensätze auflisten / verwalten                              |


---

# 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/neu/studio/start.md?ask=<question>&goal=<user_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.