# Erste Schritte mit Unsloth Studio Unsloth Studio ist eine lokale, browserbasierte GUI zum Fine-Tuning von LLMs, ohne dass Sie Code schreiben müssen. Es kapselt die Trainingspipeline in einer übersichtlichen Oberfläche, die das Laden von Modellen, die Dataset-Formatierung, die Hyperparameter-Konfiguration und die Live-Überwachung des Trainings übernimmt. StudioDatenrezeptExportChatVideo #### Unsloth Studio einrichten Starten Sie Unsloth Studio zunächst entweder mit einer lokalen Installation oder über eine Cloud-Option. Folgen Sie den [Installationsanweisungen](/docs/de/neu/studio/install.md) für Ihr Setup, oder verwenden Sie unser [kostenloses Colab](/docs/de/neu/studio.md#google-colab-notebook) Notebook. Für ein lokales Setup führen Sie aus: ```bash unsloth studio -H 0.0.0.0 -p 8888 ``` Dann öffnen Sie `http://localhost:8888` in Ihrem Browser. {% columns %} {% column %} Beim ersten Start müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern, und sich später erneut anmelden. Anschließend sehen Sie einen kurzen Einrichtungsassistenten, um ein Modell, ein Dataset und grundlegende Einstellungen auszuwählen. Sie können ihn jederzeit überspringen und alles manuell konfigurieren. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} ## :bolt: Studio - Schnellstart Die Unsloth-Studio-Startseite hat 4 Hauptbereiche: [Modell](#id-1.-select-model-and-method), [Dataset](#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 ausgefüllten Standardwerten * **Hilfreiche Konfigurationstools** für Splits, Spaltenzuordnung, Hyperparameter und YAML-Konfigurationen * **Große Transparenz beim Training** mit Live-Fortschritt, GPU-Statistiken, Diagrammen und 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** | Sprach-/Audioverständnis | | **Embeddings** | Satz-Embeddings, Retrieval | #### **Trainingsmethode** Drei Methoden sind verfügbar und werden mit einem Pillen-Selektor umgeschaltet: | Methode | Beschreibung | VRAM | | ----------------------------- | ----------------------------------------------- | ------------ | | **QLoRA** | 4-Bit quantisiertes Basismodell + LoRA-Adapter | Am wenigsten | | **LoRA** | Basismodell mit voller Präzision + LoRA-Adapter | Mittel | | **Vollständiges Fine-Tuning** | Alle Gewichte werden trainiert | Am meisten | Geben Sie einen beliebigen Hugging-Face-Modellnamen ein oder durchsuchen Sie den Hub direkt über das Kombinationsfeld. Lokale Modelle, die unter `~/.unsloth/studio/models` gespeichert sind, sowie Ihr Hugging-Face-Cache erscheinen ebenfalls in der Liste. {% hint style="warning" %} GGUF-Formatmodelle sind vom Training ausgeschlossen – sie dienen nur der Inferenz. {% endhint %} Wenn Sie ein Modell auswählen, ruft Studio automatisch seine Konfiguration vom Backend ab und füllt für alle Hyperparameter sinnvolle Standardwerte vor. **HuggingFace-Token** Fügen Sie hier Ihr Hugging-Face-Zugriffstoken ein, falls das Modell geschützt ist (z. B. Llama, Gemma). Das Token wird in Echtzeit validiert, und bei Ungültigkeit wird inline ein Fehler angezeigt. ### 2. Dataset {% columns %} {% column %} Wechseln Sie zwischen zwei Tabs, um die Datenquelle auszuwählen: * **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 Datasets erscheinen in einer Liste, die sich automatisch aktualisiert. Sie können unseren ausführlichen [Datasets-Leitfaden hier](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md). Prompt Studio, um Ihre Daten zu interpretieren und zu formatieren: {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} | Format | Wann verwenden | | ---------- | ------------------------------------------------- | | `auto` | Unsloth den Formattyp automatisch erkennen lassen | | `alpaca` | `instruction` / `input` / `output` Spalten | | `chatml` | OpenAI-Stil `messages` Array | | `sharegpt` | ShareGPT-ähnliche 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. Wenn ein Eval-Split gesetzt wird, wird das **Eval Loss** -Diagramm während des Trainings aktiviert. * **Dataset-Slice** - begrenzt das Training optional auf einen Zeilenbereich (Startindex / Endindex) für schnelle Experimente. **Spaltenzuordnung** Wenn Studio Ihre Dataset-Spalten nicht automatisch den richtigen Rollen zuordnen kann, öffnet sich ein **Dataset-Vorschau-Dialog** Er zeigt Beispielzeilen und erlaubt Ihnen, jede Spalte zuzuweisen zu `instruction`, `input`, `output`, `Bild`, usw. Vorgeschlagene Zuordnungen werden, soweit möglich, vorab ausgefüllt. ### 3. Hyperparameter Die Parameter sind in einklappbaren Abschnitten gruppiert. Sie können unseren ausführlichen [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** *(Wird 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 Bild-Dataset erscheinen vier zusätzliche Kontrollkästchen. Fine-Tuning: | Vision-Layer | Sprach-Layer | Attention-Module | MLP-Module | | ------------ | ------------ | ---------------- | ---------- | **Trainings-Hyperparameter** Organisiert in drei Tabs: {% tabs %} {% tab title="Optimierung" %} | Parameter | Standard | | ---------------------- | ----------- | | Epochen | 3 | | Batch-Größe | 4 | | Gradientenakkumulation | 8 | | Gewichtszerfall | 0.01 | | Optimierer | AdamW 8-Bit | {% endtab %} {% tab title="Zeitplan" %} | Parameter | Standard | | ---------------------------------- | -------- | | LR-Scheduler | linear | | Warmup-Schritte | 5 | | Gradienten-Checkpointing | unsloth | | Zufalls-Seed | 3407 | | Speicherschritte | 0 | | Eval-Schritte | 0 | | Packing | false | | Auf Vervollständigungen 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 Gradient Checkpointing**](/docs/de/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)**: `unsloth`** verwendet Unsloths benutzerdefinierte speichereffiziente Implementierung, die den VRAM-Verbrauch im Vergleich zur standardmäßigen PyTorch-Option erheblich reduzieren kann. Es ist die empfohlene Standardeinstellung. {% endhint %} ### 4. Training und Konfiguration Die Karte unten rechts enthält 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 Dataset konfiguriert sind. Validierungsfehler werden inline angezeigt – zum Beispiel, wenn Evaluierungs-Schritte festgelegt werden, ohne einen Eval-Split auszuwählen, oder wenn ein reines Textmodell mit einem Bild-Dataset gekoppelt 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-Phasen-Updates: * Blau: Modell / Dataset wird heruntergeladen * Bernstein: Modell / Dataset wird geladen * Blau: Wird konfiguriert * Grün: Training Sie können jederzeit abbrechen, indem Sie die **×** -Schaltfläche in der Ecke verwenden. Vor dem Stoppen erscheint ein Bestätigungsdialog. {% endcolumn %} {% endcolumns %} ### Trainingsfortschritt und Beobachtbarkeit Sobald der erste Trainingsschritt eintrifft, wird das Overlay geschlossen und die Live-Trainingsansicht angezeigt. Der Fine-Tuning-Prozess ist abgeschlossen, wenn die Schritte in der Fortschrittsleiste 100 % erreichen. Sie können die verstrichene Zeit und die Tokens ansehen.
{% columns %} {% column %} #### Statusbereich Die linke Spalte zeigt: * **Epoche** - aktuelle Bruchteil-Epoche (z. B. `Epoche 1.23`) * **Fortschrittsleiste** - schrittbasiert, mit Prozentanzeige * **Wichtige Metriken**: * **Loss** - Trainingsverlust auf 4 Dezimalstellen * **LR** - aktuelle Lernrate in wissenschaftlicher Notation * **Grad Norm** - Gradienten-Norm * **Modell** - das trainierte Modell * **Methode** - `QLoRA` / `LoRA` / `Voll` * **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** - Prozentanzeige * **Temperatur** - °C-Leiste * **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 Optionen: * **Stopp & Speichern** - speichert vor dem Stopp einen Checkpoint * **Abbrechen** - stoppt sofort ohne Checkpoint {% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Diagramme Vier Live-Diagramme aktualisieren sich während des Trainingsfortschritts: 1. **Trainingsverlust** - Rohwerte plus eine EMA-geglättete Linie und eine Referenzlinie des laufenden Durchschnitts 2. **Lernrate** - die Kurve des LR-Zeitplans 3. **Gradienten-Norm** - Gradienten-Norm ü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 (Zahnrad-Symbol) mit: | Option | Standard | | --------------------------- | ---------------------------------------- | | Anzeigefenster | Schieberegler für die letzten N Schritte | | EMA-Glättung | `0.6` | | Roh anzeigen | Ein | | Geglättet anzeigen | Ein | | Durchschnittslinie anzeigen | Ein | | Skalierung (pro Serie) | Linear / Log | | Ausreißer-Abschneiden | 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 %} Die YAML-Struktur besteht aus drei Abschnitten: {% 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 Versionsverwaltung nachverfolgen. ## :hat-chef: 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 Datasets umzuwandeln. Erstellen und bearbeiten Sie Datasets visuell über einen Graph-Knoten-Workflow. Die Rezeptseite ist der Haupt-Einstiegspunkt. Rezepte werden lokal im Browser gespeichert, sodass Sie später zu 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 dem gleichen 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 starten dann das vollständige Dataset, sobald das Ergebnis passt. Fügen Sie Seed-Daten- und Generierungsblöcke hinzu, validieren Sie den Workflow, sehen Sie sich eine Vorschau der Beispieldaten an und führen Sie dann einen vollständigen Dataset-Build aus. Unsloth Data Recipes wird von NVIDIA unterstützt [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 Dataset-Workflow zu definieren. 4. Klicken Sie **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 Fortschritt und Ausgabe live im Graphen oder in der **Ausführungen** -Ansicht für Modusdetails. 8. Wählen Sie das resultierende Dataset in **Studio** aus und führen Sie ein Fine-Tuning für ein Modell durch. ## :box-isometric: Export - Schnellstart Verwenden Sie Unsloth Studio „Export“, um Modelle für Deployment, Teilen oder lokale Inferenz in Unsloth, llama.cpp, Ollama, vLLM und mehr zu exportieren, zu speichern oder in GGUF, Safetensors oder LoRA zu konvertieren. Exportieren Sie einen trainierten Checkpoint oder konvertieren Sie ein beliebiges vorhandenes Modell.
Sie können unser ausführliches Tutorial / unseren Leitfaden zum Exportieren von Modellen mit Unsloth Studio hier lesen: {% content-ref url="/pages/13c9d0063a9732a68734b74792f3e30153873bf4" %} [Model Export](/docs/de/neu/studio/export.md) {% endcontent-ref %} ## :comment-dots: 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, fein abgestimmte 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 System-Prompt
Sie können unser ausführliches Tutorial / unseren Leitfaden zum Ausführen von Modellen mit Unsloth Studio hier lesen: {% content-ref url="/pages/73168493b14a89fa27e95b776ade6bd93679a3e5" %} [Studio Chat](/docs/de/neu/studio/chat.md) {% endcontent-ref %} ## :video: Video-Tutorial {% hint style="warning" %} Die in den Videos gezeigten Unsloth-Studio-Versionen sind alt und spiegeln nicht die aktuelle Version wider. {% endhint %} {% columns fullWidth="true" %} {% column %} {% embed url="" %} Hier ist ein von NVIDIA erstelltes Video-Tutorial, das Ihnen den Einstieg in Studio erleichtert: {% 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 Ein Modell feinabstimmen inference Inferenz auf einem trainierten Modell ausführen export Einen trainierten Adapter exportieren list-checkpoints Gespeicherte Checkpoints auflisten ui Die Unsloth-Studio-Weboberfläche 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 Python-Abhängigkeitsinstaller └── studio/ ├── backend/ │ ├── main.py # FastAPI-App & Middleware │ ├── run.py # Server-Launcher (uvicorn) │ ├── auth/ # Auth-Speicher & JWT-Logik │ ├── routes/ # API-Routenhandler │ │ ├── training.py │ │ ├── models.py │ │ ├── inference.py │ │ ├── datasets.py │ │ └── auth.py │ ├── models/ # Pydantic-Anfrage-/Antwortschemas │ ├── 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/# Einrichtungsassistent │ │ ├── components/ # Gemeinsame UI-Komponenten (shadcn) │ │ ├── hooks/ # Benutzerdefinierte React-Hooks │ │ ├── stores/ # Zustand-State-Stores │ │ └── types/ # TypeScript-Typdefinitionen │ ├── package.json │ └── vite.config.ts └── tests/ # Backend-Test-Suite ``` {% 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` | Health-Check | | `GET` | `/api/system` | Systeminformationen (GPU, CPU, Arbeitsspeicher) | | `POST` | `/api/auth/signup` | Konto erstellen (erfordert beim ersten Start einen Setup-Token) | | `POST` | `/api/auth/login` | Anmelden und JWT-Token erhalten | | `POST` | `/api/auth/refresh` | Ein abgelaufenes Zugriffstoken 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 (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 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.