# Erste Schritte mit Unsloth Studio Unsloth Studio ist eine lokale, browserbasierte GUI zum Fine-Tuning von LLMs, ohne eine einzige Zeile Code zu schreiben. Es kapselt die Trainingspipeline in einer übersichtlichen Oberfläche, die das Laden von Modellen, die Formatierung von Datensätzen, die Konfiguration von Hyperparametern und die Live-Überwachung des Trainings übernimmt. Studio Datenrezept Export Chat #### Unsloth Studio einrichten Starten Sie zunächst Unsloth Studio entweder mit einer lokalen Installation oder einer Cloud-Option. Folgen Sie den [Installationsanweisungen](/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 -H 0.0.0.0 -p 8888 ``` {% columns %} {% column %} Öffnen Sie Ihren bevorzugten Browser und geben Sie `http://127.0.0.1:8888` in das URL-Feld ein. Wenn Sie Unsloth zum ersten Mal installieren, werden Sie zur `http://127.0.0.1:8888/change-password` Seite weitergeleitet. Dort müssen Sie ein neues Passwort erstellen. Sie können Ihr Passwort später jederzeit ändern. {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} ## Chat – Schnellstart [Unsloth Studio Chat](/docs/de/neu/studio/chat.md) ermöglicht es Ihnen, Modelle zu 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. * [**Modelle** verschiedene Modell](#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

Hier können Sie unser ausführliches Tutorial / unseren Leitfaden zur Ausführung von Modellen mit Unsloth Studio lesen: {% content-ref url="/pages/73168493b14a89fa27e95b776ade6bd93679a3e5" %} [Studio Chat](/docs/de/neu/studio/chat.md) {% endcontent-ref %} ### Modell-Ladeanleitung Vor der Verwendung der API 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.

{% hint style="info" %} Auf einer anderen Seite? Nutzen Sie die linke Seitenleiste und klicken Sie `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 über den Tab \`Fine-tuned\` geladen werden. {% endcolumn %} {% column width="50%" %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### GGUF-Auswahl Modell-Repositories enthalten mehrere Quantisierungen. Wählen Sie die Quantisierung, die am besten zu Ihrem verfügbaren RAM / VRAM passt.\ \ In diesem Leitfaden verwenden wir `unsloth/gemma-4-26B-A4B-it-GGUF` und wählen die empfohlene `UD-Q4_K_XL` Variante {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} #### Das Modell herunterladen {% columns %} {% column %} Suchen Sie nach dem Modell, das Sie verwenden möchten, und **klicken Sie darauf** um den Download und das Laden zu beginnen. Nachdem Sie eine Modellvariante ausgewählt haben, beginnt Unsloth mit dem Herunterladen und Laden des Modells in den Speicher. Sobald das Laden abgeschlossen ist, sehen Sie die folgende Bestätigung: {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Das Modell ist geladen und einsatzbereit. Sie können jetzt direkt in Unsloth mit dem Modell chatten oder es mit Tools wie [Claude Code](/docs/de/grundlagen/claude-code.md) und [Codex](/docs/de/grundlagen/codex.md).

## Studio – 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 vollständiges Fine-Tuning, mit vorausgefüllten Standardwerten * **Hilfreiche Konfigurationstools** für Splits, Spaltenzuordnung, Hyperparameter und YAML-Konfigurationen * **Großartige Transparenz beim Training** mit Live-Fortschritt, GPU-Statistiken, Diagrammen, Startstatus

### 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** | Sprache / Audioverständnis | | **Embeddings** | Satz-Embeddings, Retrieval | #### **Trainingsmethode** Es stehen drei Methoden zur Verfügung, umschaltbar 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 Fine-Tuning** | Alle Gewichte werden trainiert | Am höchsten | Geben Sie einen beliebigen Hugging-Face-Modellnamen ein oder suchen Sie den Hub direkt über das Kombinationsfeld. Lokale Modelle, die in `~/.unsloth/studio/models` gespeichert sind, sowie Ihr Hugging-Face-Cache erscheinen ebenfalls in der Liste. {% hint style="warning" %} Modelle im GGUF-Format sind vom Training ausgeschlossen – sie dienen nur der Inferenz. {% endhint %} Wenn Sie ein Modell auswählen, ruft Studio automatisch dessen Konfiguration vom Backend ab und füllt sinnvolle Standardwerte für alle Hyperparameter vor. **HuggingFace-Token** Fügen Sie hier Ihren Hugging-Face-Zugriffstoken ein, wenn das Modell eingeschränkt ist (z. B. Llama, Gemma). Der Token wird in Echtzeit validiert und bei Ungültigkeit wird inline ein Fehler 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 & 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 ausführlichen [Datensatz-Leitfaden hier](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md). Prompt Studio, wie Ihre Daten interpretiert und formatiert werden sollen: {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} | Format | Wann verwenden | | ----------------------------------- | ---------------------------------------------- | | `wird sauber zugeordnet: Anthropic` | Unsloth das Format automatisch erkennen lassen | | `alpaca` | `instruction` / `input` / `output` Spalten | | `chatml` | OpenAI-Stil `messages` Array | | `sharegpt` | ShareGPT-ähnliche Unterhaltungen | **Splits und Slicing** * **Subset** - wird automatisch aus der Datensatzkarte übernommen. * **Train-Split / Eval-Split** - wählen Sie, welche Splits verwendet werden sollen. Das Festlegen eines Eval-Splits aktiviert das **Eval Loss** Diagramm während des Trainings. * **Datensatz-Ausschnitt** - das Training optional auf einen Zeilenbereich beschränken (Startindex / Endindex) für schnelle Experimente. **Spaltenzuordnung** Wenn Studio Ihre Datensatzspalten nicht automatisch den richtigen Rollen zuordnen kann, öffnet sich ein **Datensatz-Vorschau-Dialog** . Er zeigt Beispielzeilen und ermöglicht es Ihnen, jede Spalte zuzuweisen zu `instruction`, `input`, `output`, `Bild`, usw. Vorgeschlagene Zuordnungen werden, soweit möglich, vorausgefüllt. ### 3. Hyperparameter Parameter sind in aufklappbare Abschnitte gruppiert. Sie können unseren ausführlichen [LoRA-Hyperparameter-Leitfaden](/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 | | ----------------- | -------- | ------------------------------------------ | | **Max. Schritte** | `0` | `0` bedeutet stattdessen Epochen verwenden | | **Kontextlänge** | `2048` | Optionen: 512 → 32768 | | **Lernrate** | `2e-4` | | **LoRA-Einstellungen** *(Ausgeblendet, wenn Vollständiges Fine-Tuning 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** Modelle mit einem Bilddatensatz erscheinen vier zusätzliche Kontrollkästchen. Fine-Tuning: | 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 | | Gewichtsabnahme | 0.01 | | Optimizer | AdamW 8-bit | {% endtab %} {% tab title="Zeitplan" %} | Parameter | Standard | | ---------------------------------- | -------- | | LR-Scheduler | linear | | Warmup-Schritte | 5 | | Gradienten-Checkpointing | unsloth | | Zufalls-Seed | 3407 | | Speicher-Schritte | 0 | | Eval-Schritte | 0 | | Packing | false | | Auf Vervollständigungen trainieren | false | | {% endtab %} | | {% tab title="Logging" %} | Parameter | Standard | | ----------------------- | -------------- | | W\&B aktivieren | false | | W\&B-Projekt | llm-finetuning | | TensorBoard aktivieren | false | | TensorBoard-Verzeichnis | runs | | Log-Frequenz | 10 | | {% endtab %} | | | {% endtabs %} | | {% hint style="info" %} [**Unsloth Gradient 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 deutlich reduzieren kann. Sie ist die empfohlene Standardeinstellung. {% 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 inline angezeigt – zum Beispiel, wenn Eval-Schritte festgelegt werden, ohne einen Eval-Split auszuwählen, oder wenn ein textbasiertes Modell mit einem Vision-Datensatz kombiniert wird. #### Ladebildschirm {% columns %} {% column %} Nachdem Sie **Training starten**geklickt haben, erscheint ein Vollbild-Overlay, während das Backend alles vorbereitet.

{% endcolumn %} {% column %} Das Overlay zeigt ein animiertes Terminal mit Live-Phasenaktualisierungen: * Blau: Modell / Datensatz wird heruntergeladen * Bernstein: Modell / Datensatz wird geladen * Blau: Konfiguration wird durchgeführt * Grün: Training Sie können jederzeit abbrechen, indem Sie die **×** Schaltfläche in der Ecke verwenden. Bevor etwas gestoppt wird, erscheint ein Bestätigungsdialog. {% endcolumn %} {% endcolumns %} ### Trainingsfortschritt und Beobachtbarkeit Sobald der erste Trainingsschritt eintrifft, schließt sich das Overlay und die Live-Trainingsansicht wird angezeigt. Der Fine-Tuning-Prozess ist abgeschlossen, wenn die Schritte auf der Fortschrittsleiste 100 % erreichen. Sie können die vergangene Zeit und die Token anzeigen.

{% columns %} {% column %} #### Status-Panel Die linke Spalte zeigt: * **Epoche** - aktuelle anteilige Epoche (z. B. `Epoche 1.23`) * **Fortschrittsbalken** - schrittbasiert, mit Prozentsatz * **Wichtige Metriken**: * **Verlust** - Trainingsverlust auf 4 Dezimalstellen * **LR** - aktuelle Lernrate in wissenschaftlicher Schreibweise * **Grad Norm** - Gradienten-Norm * **Modell** - das trainierte Modell * **Methode** - `QLoRA` / `LoRA` / `Voll` * **Zeitzeile** - vergangene Zeit, ETA, Schritte pro Sekunde und insgesamt verarbeitete Token {% 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 in der Fortschrittskarte. Ein Dialog bietet Ihnen zwei Auswahlmöglichkeiten: * **Stoppen & Speichern** - speichert einen Checkpoint, bevor gestoppt wird * **Abbrechen** - stoppt sofort ohne Checkpoint {% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Diagramme Vier Live-Diagramme werden während des Trainings fortlaufend aktualisiert: 1. **Trainingsverlust** - Rohwerte plus eine EMA-geglättete Linie und eine Referenzlinie des gleitenden Durchschnitts 2. **Lernrate** - die LR-Zeitplankurve 3. **Gradientennorm** - Gradientennorm über die Schritte 4. **Eval Loss** - wird nur angezeigt, wenn Sie einen Eval-Split konfiguriert haben {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Jedes Diagramm hat Einstellungen (Zahnradsymbol) mit: | Option | Standard | | --------------------------- | ---------------------------------------- | | Anzeigefenster | 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ßer-Beschneidung | Kein Clip / p99 / p95 | | {% endcolumn %} | | {% column %}

{% endcolumn %} {% endcolumns %} #### Konfigurationsdateien {% columns %} {% column %} Alle Trainingskonfigurationen können als YAML-Dateien gespeichert und erneut geladen werden. Die Dateien werden automatisch benannt als: ``` {model}_{method}_{dataset}_{timestamp}.yaml ``` {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Das YAML ist in drei Abschnitte gegliedert: {% 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 lassen sich Läufe leicht reproduzieren, Konfigurationen teilen oder Ihre Experimente per Versionskontrolle verwalten. ## Datenrezepte – Schnellstart [Unsloth Data Recipes](/docs/de/neu/studio/data-recipe.md) ermöglicht es Ihnen, Dokumente wie PDFs oder CSV-Dateien hochzuladen und sie in nutzbare Datensätze umzuwandeln. Erstellen und bearbeiten Sie Datensätze visuell über einen Graph-Knoten-Workflow. Die Rezeptseite ist der Haupteinstiegspunkt. Rezepte werden lokal im Browser gespeichert, sodass Sie später zu Ihren gespeicherten Arbeiten zurückkehren können. Von hier aus können Sie ein leeres Rezept erstellen oder ein geführtes Lernrezept öffnen.

Data Recipes folgt demselben grundlegenden Ablauf. Sie öffnen die Rezeptseite, erstellen oder wählen ein Rezept, bauen den Workflow im Editor auf, validieren ihn, führen eine Vorschau aus und erstellen dann den vollständigen Datensatz, sobald das Ergebnis korrekt aussieht. Fügen Sie Ausgangsdaten und Generierungsblöcke hinzu, validieren Sie den Workflow, sehen Sie sich Beispielausgaben in der Vorschau an und führen Sie dann einen vollständigen Dataset-Build aus. Unsloth Data Recipes wird von NVIDIA [DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner). Auf einen Blick sollte ein typischer Workflow so aussehen: 1. Öffnen Sie die Rezeptseite. 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 Dataset-Build aus, wenn das Rezept bereit ist. 7. Überprüfen Sie den Fortschritt und die Ausgabe live im Graph oder in der **Ausführungen** Ansicht für weitere Details. 8. Wählen Sie den resultierenden Datensatz in **Studio** aus und feinabstimmen Sie ein Modell. ## Export – Schnellstart Verwenden Sie in Unsloth Studio „Export“, um Modelle für Bereitstellung, Teilen oder lokale Inferenz in Unsloth, llama.cpp, Ollama, vLLM und mehr zu exportieren, zu speichern oder in GGUF, Safetensors oder LoRA umzuwandeln. Exportieren Sie einen trainierten Checkpoint oder konvertieren Sie ein beliebiges vorhandenes Modell.

Hier können Sie unser ausführliches Tutorial / unseren Leitfaden zum Exportieren von Modellen mit Unsloth Studio lesen: {% content-ref url="/pages/13c9d0063a9732a68734b74792f3e30153873bf4" %} [Model Export](/docs/de/neu/studio/export.md) {% endcontent-ref %} ## Video-Tutorial {% hint style="warning" %} Die in den Videos gezeigten Versionen von Unsloth Studio sind alt und entsprechen nicht der aktuellen Version. {% endhint %} {% columns fullWidth="true" %} {% column %} {% embed url="" %} Hier ist ein von NVIDIA erstelltes Video-Tutorial, um Ihnen den Einstieg in Studio zu erleichtern: {% endcolumn %} {% column %} {% embed url="" %} Video-Tutorial zur Installation von Unsloth Studio {% endcolumn %} {% endcolumns %} ## Erweiterte Einstellungen ### CLI-Befehle Die Unsloth CLI (`cli.py`) bietet die folgenden Befehle: ``` Verwendung: cli.py [BEFEHL] Befehle: train Modell feinabstimmen inference Inferenz auf einem trainierten Modell ausführen export Einen trainierten Adapter exportieren list-checkpoints Gespeicherte Checkpoints auflisten ui Die Unsloth Studio-Web-UI 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 (Windows nativ) ├── setup.bat # Wrapper zum Starten von setup.ps1 per Doppelklick ├── install_python_stack.py # Plattformübergreifender Installer für Python-Abhängigkeiten └── studio/ ├── backend/ │ ├── main.py # FastAPI-App & Middleware │ ├── run.py # Server-Launcher (uvicorn) │ ├── auth/ # Auth-Speicher & JWT-Logik │ ├── routes/ # API-Routen-Handler │ │ ├── training.py │ │ ├── models.py │ │ ├── inference.py │ │ ├── datasets.py │ │ └── auth.py │ ├── models/ # Pydantic Anfrage-/Antwortschemata │ ├── core/ # Trainings-Engine & Konfiguration │ ├── utils/ # Hardware-Erkennung, Hilfsfunktionen │ └── requirements.txt ├── frontend/ │ ├── src/ │ │ ├── features/ # Feature-Module │ │ │ ├── auth/ # Login-/Registrierungsablauf │ │ │ ├── training/ # Trainingskonfiguration & Monitoring │ │ │ ├── studio/ # Hauptarbeitsbereich des Studios │ │ │ ├── chat/ # Inferenz-Chat-UI │ │ │ ├── export/ # Modell-Export-Ablauf │ │ │ └── onboarding/# Onboarding-Assistent │ │ ├── components/ # Gemeinsame UI-Komponenten (shadcn) │ │ ├── hooks/ # Benutzerdefinierte React-Hooks │ │ ├── stores/ # Zustand-Statusspeicher │ │ └── types/ # TypeScript-Typdefinitionen │ ├── package.json │ └── vite.config.ts └── tests/ # Backend-Testsuite ``` {% endcode %} ### API-Referenz Alle Endpunkte erfordern ein gültiges JWT `Authorization: Bearer ` Header (außer `/api/auth/*` und `/api/health`). | Methode | Endpunkt | Beschreibung | | ------- | --------------------- | -------------------------------------------------------------------- | | `GET` | `/api/health` | Systemstatusprüfung | | `GET` | `/api/system` | Systeminformationen (GPU, CPU, Speicher) | | `POST` | `/api/auth/signup` | Konto erstellen (erfordert beim ersten Start ein Einrichtungs-Token) | | `POST` | `/api/auth/login` | Anmelden und JWT-Token erhalten | | `POST` | `/api/auth/refresh` | Einen abgelaufenen Access-Token aktualisieren | | `GET` | `/api/auth/status` | Prüfen, ob die Authentifizierung initialisiert ist | | `POST` | `/api/train/start` | Einen Trainingsauftrag starten | | `POST` | `/api/train/stop` | Einen laufenden Trainingsauftrag stoppen | | `POST` | `/api/train/reset` | Trainingsstatus zurücksetzen | | `GET` | `/api/train/status` | Aktuellen Trainingsstatus abrufen | | `GET` | `/api/train/metrics` | Trainingsmetriken abrufen (Verlust, LR, Schritte) | | `GET` | `/api/train/stream` | SSE-Stream des Trainingsfortschritts in Echtzeit | | `GET` | `/api/models/` | Verfügbare Modelle auflisten | | `POST` | `/api/inference/chat` | Eine Chat-Nachricht für die Inferenz senden | | `GET` | `/api/datasets/` | Datensätze auflisten / verwalten | --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/neu/studio/start.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.