> 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/loslegen/fine-tuning-llms-guide/datasets-guide.md). # Datensätze-Anleitung ## Was ist ein Datensatz? Für LLMs sind Datensätze Sammlungen von Daten, die zum Trainieren unserer Modelle verwendet werden können. Damit sie für das Training nützlich sind, müssen Textdaten in einem Format vorliegen, das tokenisiert werden kann. Du wirst auch lernen, wie man [Datensätze innerhalb von Unsloth verwendet](#applying-chat-templates-with-unsloth). Einer der wichtigsten Teile bei der Erstellung eines Datensatzes ist dein [Chat-Template](/docs/de/grundlagen/chat-templates.md) und wie du ihn gestalten wirst. Die Tokenisierung ist ebenfalls wichtig, da sie Text in Tokens zerlegt, die Wörter, Wortbestandteile oder Zeichen sein können, damit LLMs ihn effektiv verarbeiten können. Diese Tokens werden dann in Embeddings umgewandelt und angepasst, um dem Modell zu helfen, Bedeutung und Kontext zu verstehen. ### Datenformat Um den Tokenisierungsprozess zu ermöglichen, müssen Datensätze in einem Format vorliegen, das von einem Tokenizer gelesen werden kann.
FormatBeschreibungTrainingsart
RohkorpusRohtext aus einer Quelle wie einer Website, einem Buch oder einem Artikel.Fortgesetztes Pretraining (CPT)
InstruktAnweisungen, denen das Modell folgen soll, und ein Beispiel für die Ausgabe, die angestrebt werden soll.Überwachtes Feintuning (SFT)
KonversationMehrturnige Konversation zwischen einem Benutzer und einem KI-Assistenten.Überwachtes Feintuning (SFT)
RLHFKonversation zwischen einem Benutzer und einem KI-Assistenten, wobei die Antworten des Assistenten von einem Skript, einem anderen Modell oder einem menschlichen Bewerter bewertet werden.Verstärkendes Lernen (RL)
{% hint style="info" %} Es ist erwähnenswert, dass es für jeden dieser Typen unterschiedliche Formatstile gibt. {% endhint %} ## Erste Schritte Bevor wir unsere Daten formatieren, möchten wir Folgendes identifizieren: {% stepper %} {% step %} Zweck des Datensatzes Wenn wir den Zweck des Datensatzes kennen, können wir bestimmen, welche Daten wir benötigen und welches Format wir verwenden sollten. Der Zweck könnte sein, ein Modell an eine neue Aufgabe wie Zusammenfassung anzupassen oder die Fähigkeit eines Modells zu verbessern, eine bestimmte Figur zu spielen. Zum Beispiel: * Chatbasierte Dialoge (Q\&A, eine neue Sprache lernen, Kundensupport, Gespräche). * Strukturierte Aufgaben ([Klassifikation](https://colab.research.google.com/github/timothelaborie/text_classification_scripts/blob/main/unsloth_classification.ipynb), Zusammenfassung, Generierungsaufgaben). * Domänenspezifische Daten (Medizin, Finanzen, Technik). {% endstep %} {% step %} Stil der Ausgabe Der Ausgabestil sagt uns, welche Datenquellen wir verwenden werden, um unsere gewünschte Ausgabe zu erreichen. Zum Beispiel könnte die Art der gewünschten Ausgabe JSON, HTML, Text oder Code sein. Oder vielleicht soll sie Spanisch, Englisch oder Deutsch usw. sein. {% endstep %} {% step %} Datenquelle Wenn wir den Zweck und den Stil der benötigten Daten kennen, müssen wir die Qualität und [Menge](#how-big-should-my-dataset-be) der Daten analysieren. Hugging Face und Wikipedia sind großartige Quellen für Datensätze, und Wikipedia ist besonders nützlich, wenn du ein Modell darauf trainieren möchtest, eine Sprache zu lernen. Die Datenquelle kann eine CSV-Datei, ein PDF oder sogar eine Website sein. Du kannst auch [synthetisch erzeugen](#synthetic-data-generation) Daten, aber es ist besondere Sorgfalt erforderlich, um sicherzustellen, dass jedes Beispiel hochwertig und relevant ist. {% endstep %} {% endstepper %} {% hint style="success" %} Eine der besten Möglichkeiten, einen besseren Datensatz zu erstellen, besteht darin, ihn mit einem stärker generalisierten Datensatz von Hugging Face wie ShareGPT zu kombinieren, um dein Modell intelligenter und vielfältiger zu machen. Du könntest auch [synthetisch erzeugte Daten](#synthetic-data-generation). {% endhint %} ## 🦥 Unsloth Daten-Rezepte [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 Rezepte-Seite ist der zentrale 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 folgen demselben grundlegenden Ablauf. Du öffnest die Rezepte-Seite, erstellst oder wählst ein Rezept, baust den Workflow im Editor, validierst ihn, führst eine Vorschau aus und startest dann den vollständigen Datensatz, sobald die Ausgabe richtig aussieht. Füge Seed-Daten und Generierungsblöcke hinzu, validiere den Workflow, schaue dir eine Beispielausgabe an und starte dann einen vollständigen Datensatzaufbau. Auf den ersten Blick sollte ein üblicher Workflow so aussehen: 1. Öffnen Sie die Rezepte-Seite. 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. Überprüfen Sie Fortschritt und Ausgabe live im Diagramm oder in **Ausführungen** Ansicht für weitere Details. 8. Wähle den resultierenden Datensatz in Unsloth aus und feintune ein Modell. Mehr dazu: {% content-ref url="/pages/dd9f9c69fff351709e4886e820d7d6facf3ec2b3" %} [Data Recipes](/docs/de/neu/studio/data-recipe.md) {% endcontent-ref %} ## Die Daten formatieren Wenn wir die relevanten Kriterien identifiziert und die notwendigen Daten gesammelt haben, können wir unsere Daten in ein maschinenlesbares Format bringen, das für das Training bereit ist. ### Häufige Datenformate für das LLM-Training Für [**fortgesetztes Pretraining**](/docs/de/grundlagen/continued-pretraining.md), verwenden wir Rohtextformat ohne spezifische Struktur: ```json "text": "Pasta Carbonara ist ein traditionelles römisches Pastagericht. Die Sauce wird hergestellt, indem rohe Eier mit geriebenem Pecorino-Romano-Käse und schwarzem Pfeffer vermischt werden. Die heiße Pasta wird dann mit knusprigem Guanciale (gepökelte Schweinebacke) und der Eiermischung vermengt, wodurch durch die Restwärme eine cremige Sauce entsteht. Entgegen der landläufigen Meinung enthält authentische Carbonara niemals Sahne oder Knoblauch. Das Gericht stammt wahrscheinlich aus Rom aus der Mitte des 20. Jahrhunderts, auch wenn seine genaue Herkunft umstritten ist..." ``` Dieses Format bewahrt den natürlichen Sprachfluss und ermöglicht es dem Modell, aus fortlaufendem Text zu lernen. Wenn wir ein Modell an eine neue Aufgabe anpassen und wollen, dass das Modell Text in einem einzigen Durchgang auf Grundlage einer bestimmten Reihe von Anweisungen ausgibt, können wir **Instruktions-** Format in [Alpaca-Stil](https://docs.unsloth.ai/basics/tutorial-how-to-finetune-llama-3-and-use-in-ollama#id-6.-alpaca-dataset) ```json "Instruction": "Aufgabe, die das Modell ausführen soll." "Input": "Optional, aber nützlich; es wird im Wesentlichen die Anfrage des Benutzers sein." "Output": "Das erwartete Ergebnis der Aufgabe und die Ausgabe des Modells." ``` Wenn wir mehrere Gesprächsrunden wollen, können wir das ShareGPT-Format verwenden: ```json { "conversations": [ { "from": "human", "value": "Kannst du mir helfen, Pasta Carbonara zu machen?" }, { "from": "gpt", "value": "Möchtest du das traditionelle römische Rezept oder eine einfachere Version?" }, { "from": "human", "value": "Bitte die traditionelle Version" }, { "from": "gpt", "value": "Die authentische römische Carbonara verwendet nur wenige Zutaten: Pasta, Guanciale, Eier, Pecorino Romano und schwarzen Pfeffer. Möchtest du das ausführliche Rezept?" } ] } ``` Das Vorlagenformat verwendet die Attributschlüssel "from"/"value", und die Nachrichten wechseln zwischen `human`und `gpt`, was einen natürlichen Dialogfluss ermöglicht. Das andere gängige Format ist OpenAIs ChatML-Format und ist der Standard von Hugging Face. Dies ist wahrscheinlich das am häufigsten verwendete Format und wechselt zwischen `user` und `assistant` ``` { "messages": [ { "role": "user", "content": "Was ist 1+1?" }, { "role": "assistant", "content": "Es ist 2!" }, ] } ``` ### Chat-Vorlagen mit Unsloth anwenden Bei Datensätzen, die normalerweise dem gängigen ChatML-Format folgen, besteht der Prozess der Vorbereitung des Datensatzes für Training oder Finetuning aus vier einfachen Schritten: * Überprüfe die Chat-Vorlagen, die Unsloth derzeit unterstützt:\\ ``` from unsloth.chat_templates import CHAT_TEMPLATES print(list(CHAT_TEMPLATES.keys())) ``` \ Dies gibt die Liste der Vorlagen aus, die derzeit von Unsloth unterstützt werden. Hier ist ein Beispiel für die Ausgabe:\\ ``` ['unsloth', 'zephyr', 'chatml', 'mistral', 'llama', 'vicuna', 'vicuna_old', 'vicuna old', 'alpaca', 'gemma', 'gemma_chatml', 'gemma2', 'gemma2_chatml', 'llama-3', 'llama3', 'phi-3', 'phi-35', 'phi-3.5', 'llama-3.1', 'llama-31', 'llama-3.2', 'llama-3.3', 'llama-32', 'llama-33', 'qwen-2.5', 'qwen-25', 'qwen25', 'qwen2.5', 'phi-4', 'gemma-3', 'gemma3'] ``` \\ * Verwende `get_chat_template` um die richtige Chat-Vorlage auf deinen Tokenizer anzuwenden:\\ ``` from unsloth.chat_templates import get_chat_template tokenizer = get_chat_template( tokenizer, chat_template = "gemma-3", # ändere dies in den richtigen chat_template-Namen ) ``` \\ * Definiere deine Formatierungsfunktion. Hier ist ein Beispiel:\\ ``` def formatting_prompts_func(examples): convos = examples["conversations"] texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos] return { "text" : texts, } ``` \ \ Diese Funktion durchläuft deinen Datensatz und wendet die von dir definierte Chat-Vorlage auf jedes Beispiel an.\\ * Lass uns nun den Datensatz laden und die erforderlichen Änderungen an unserem Datensatz vornehmen: \\ ``` # Datensatz importieren und laden from datasets import load_dataset dataset = load_dataset("repo_name/dataset_name", split = "train") # Wende die Formatierungsfunktion mit der map-Methode auf deinen Datensatz an dataset = dataset.map(formatting_prompts_func, batched = True,) ``` \ Wenn dein Datensatz das ShareGPT-Format mit "from"/"value"-Schlüsseln anstelle des ChatML-Formats "role"/"content" verwendet, kannst du die `standardize_sharegpt` Funktion verwenden, um ihn zuerst zu konvertieren. Der überarbeitete Code sieht nun wie folgt aus:\ \\ ``` # Datensatz importieren from datasets import load_dataset dataset = load_dataset("mlabonne/FineTome-100k", split = "train") # Wandle deinen Datensatz bei Bedarf in das "role"/"content"-Format um from unsloth.chat_templates import standardize_sharegpt dataset = standardize_sharegpt(dataset) # Wende die Formatierungsfunktion mit der map-Methode auf deinen Datensatz an dataset = dataset.map(formatting_prompts_func, batched = True,) ``` ### Datenformatierung Q\&A **F:** Wie kann ich das Alpaca-Instruct-Format verwenden? **A:** Wenn dein Datensatz bereits im Alpaca-Format vorliegt, befolge die Formatierungsschritte, wie im Llama3.1 [Notizbuch ](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.1_\(8B\)-Alpaca.ipynb#scrollTo=LjY75GoYUCB8). Wenn du deine Daten in das Alpaca-Format umwandeln musst, kannst du einen Python-Skript erstellen, um deine Rohdaten zu verarbeiten. Wenn du an einer Zusammenfassungsaufgabe arbeitest, kannst du ein lokales LLM verwenden, um für jedes Beispiel Anweisungen und Ausgaben zu erzeugen. **F:** Sollte ich immer die Methode standardize\_sharegpt verwenden? **A:** Verwende die Methode standardize\_sharegpt nur, wenn dein Zieldatensatz im sharegpt-Format vorliegt, dein Modell jedoch stattdessen ein ChatML-Format erwartet. \ **F:** Warum nicht die Funktion apply\_chat\_template verwenden, die mit dem Tokenizer mitgeliefert wird. **A:** Der `chat_template` Attribut, wenn ein Modell erstmals von den ursprünglichen Modellbesitzern hochgeladen wird, enthält manchmal Fehler und kann Zeit brauchen, um aktualisiert zu werden. Bei Unsloth prüfen und beheben wir dagegen gründlich alle Fehler in der `chat_template` für jedes Modell, wenn wir die quantisierten Versionen in unsere Repositories hochladen. Außerdem bieten unsere `get_chat_template` und `apply_chat_template` Methoden erweiterte Funktionen zur Datenmanipulation, die in unserer Chat-Vorlagen-Dokumentation vollständig beschrieben sind [Seite](https://docs.unsloth.ai/basics/chat-templates). **F:** Was ist, wenn meine Vorlage derzeit nicht von Unsloth unterstützt wird? **A:** Reiche einen Feature-Wunsch im unsloth GitHub-Issues- [Forum ein](https://github.com/unslothai/unsloth). Als vorübergehende Lösung könntest du auch die eigene Funktion apply\_chat\_template des Tokenizers verwenden, bis dein Feature-Wunsch genehmigt und zusammengeführt wird. ## Synthetische Datengenerierung Du kannst auch jedes lokale LLM wie Llama 3.3 (70B) oder OpenAIs GPT 4.5 verwenden, um synthetische Daten zu erzeugen. Im Allgemeinen ist es besser, ein größeres Modell wie Llama 3.3 (70B) zu verwenden, um die höchstmögliche Ausgabequalität sicherzustellen. Du kannst Inferenz-Engines wie vLLM, Ollama oder llama.cpp direkt verwenden, um synthetische Daten zu erzeugen, aber es erfordert etwas manuelle Arbeit, sie zu sammeln und für mehr Daten zu prompten. Es gibt 3 Ziele für synthetische Daten: * Völlig neue Daten erzeugen – entweder von Grund auf oder ausgehend von deinem bestehenden Datensatz * Deinen Datensatz diversifizieren, damit dein Modell nicht [überfitten](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md#avoiding-overfitting-and-underfitting) und zu spezifisch werden * Bestehende Daten erweitern, z. B. deinen Datensatz automatisch in das korrekt gewählte Format strukturieren ### Unsloth für synthetische Daten verwenden Du kannst beliebige unstrukturierte oder strukturierte Daten ganz einfach in das [Datenrezepte](/docs/de/neu/studio/data-recipe.md) von Unsloth Studio hochladen und es wird sie automatisch in einen verwendbaren / synthetischen Datensatz umwandeln. Mehr Details in [unserer Anleitung](/docs/de/neu/studio/data-recipe.md).
### Einen lokalen LLM oder ChatGPT für synthetische Daten verwenden Dein Ziel ist es, das Modell dazu zu bringen, QA-Daten zu erzeugen und zu verarbeiten, die in deinem angegebenen Format vorliegen. Das Modell muss die von dir vorgegebene Struktur und auch den Kontext lernen, daher solltest du zumindest 10 Beispiele von Daten bereits haben. Beispiel-Prompts: * **Prompt zur Erzeugung weiterer Dialoge auf einem bestehenden Datensatz**: 
Verwende das von mir bereitgestellte Datensatzbeispiel, folge der Struktur und generiere auf Basis der Beispiele Konversationen.
* **Prompt, wenn du keinen Datensatz hast**: {% code overflow="wrap" %} ``` Erstelle 10 Beispiele für Produktbewertungen zu Coca-Cola, klassifiziert als positiv, negativ oder neutral. ``` {% endcode %} * **Prompt für einen Datensatz ohne Formatierung**: {% code overflow="wrap" %} ``` Strukturiere meinen Datensatz so, dass er für das Fine-Tuning im QA-ChatML-Format vorliegt. Generiere dann 5 synthetische Datenbeispiele mit demselben Thema und Format. ``` {% endcode %} Es wird empfohlen, die Qualität der generierten Daten zu überprüfen, um irrelevante oder minderwertige Antworten zu entfernen oder zu verbessern. Abhängig von deinem Datensatz muss er möglicherweise auch in vielen Bereichen ausbalanciert werden, damit dein Modell nicht überfitten kann. Du kannst diesen bereinigten Datensatz dann wieder in dein LLM einspeisen, um Daten erneut zu generieren, nun mit noch mehr Anleitung. ## Datensatz-FAQ + Tipps ### Wie groß sollte mein Datensatz sein? Wir empfehlen im Allgemeinen, für das Fine-Tuning mindestens 100 Zeilen Daten als absolutes Minimum zu verwenden, um vernünftige Ergebnisse zu erzielen. Für optimale Leistung ist ein Datensatz mit über 1.000 Zeilen vorzuziehen, und in diesem Fall führt mehr Datenmaterial in der Regel zu besseren Ergebnissen. Wenn dein Datensatz zu klein ist, kannst du auch synthetische Daten hinzufügen oder einen Datensatz von Hugging Face ergänzen, um ihn zu diversifizieren. Die Wirksamkeit deines feinabgestimmten Modells hängt jedoch stark von der Qualität des Datensatzes ab, daher solltest du deine Daten gründlich bereinigen und vorbereiten. ### Wie sollte ich meinen Datensatz strukturieren, wenn ich ein Reasoning-Modell feinabstimmen möchte? Wenn du ein Modell feinabstimmen möchtest, das bereits über Reasoning-Fähigkeiten verfügt, wie die destillierten Versionen von DeepSeek-R1 (z. B. DeepSeek-R1-Distill-Llama-8B), musst du weiterhin Frage/Aufgabe- und Antwortpaare verwenden; allerdings musst du bei deiner Antwort die Antwort so ändern, dass sie den Reasoning-/Chain-of-Thought-Prozess und die Schritte enthält, die zur Ableitung der Antwort geführt haben.\ \ Für ein Modell, das kein Reasoning hat und das du so trainieren möchtest, dass es später Reasoning-Fähigkeiten umfasst, musst du einen Standarddatensatz verwenden, diesmal jedoch ohne Reasoning in den Antworten. Dieser Trainingsprozess ist bekannt als [Reinforcement Learning und GRPO](/docs/de/loslegen/reinforcement-learning-rl-guide.md). ### Mehrere Datensätze Wenn du mehrere Datensätze für das Fine-Tuning hast, kannst du entweder: * Das Format aller Datensätze standardisieren, sie zu einem einzigen Datensatz zusammenführen und auf diesem vereinheitlichten Datensatz feinabstimmen. * Verwenden Sie die [Mehrere Datensätze](https://colab.research.google.com/drive/1njCCbE1YVal9xC83hjdo2hiGItpY_D6t?usp=sharing) Notizbuch, um direkt auf mehreren Datensätzen feinabzustimmen. ### Kann ich dasselbe Modell mehrmals feinabstimmen? Du kannst ein bereits feinabgestimmtes Modell mehrmals feinabstimmen, aber es ist besser, stattdessen alle Datensätze zu kombinieren und das Fine-Tuning in einem einzigen Prozess durchzuführen. Das Training eines bereits feinabgestimmten Modells kann die Qualität und das Wissen, das während des vorherigen Fine-Tuning-Prozesses erworben wurde, potenziell verändern. ## Datensätze in Unsloth verwenden ### Alpaca-Datensatz Sieh dir ein Beispiel an, wie man den Alpaca-Datensatz innerhalb von Unsloth auf Google Colab verwendet:
Wir werden nun den Alpaca-Datensatz verwenden, der erstellt wurde, indem GPT-4 selbst aufgerufen wurde. Es ist eine Liste von 52.000 Anweisungen und Ausgaben, die sehr beliebt war, als Llama-1 veröffentlicht wurde, da sie das Feintuning eines Basis-LLMs mit ChatGPT selbst konkurrenzfähig machte. Du kannst auf die GPT4-Version des Alpaca-Datensatzes zugreifen [hier](https://huggingface.co/datasets/vicgalle/alpaca-gpt4.). Unten siehst du einige Beispiele des Datensatzes:
Du kannst sehen, dass es in jeder Zeile 3 Spalten gibt – eine Anweisung, eine Eingabe und eine Ausgabe. Wir kombinieren im Wesentlichen jede Zeile zu einem großen Prompt wie unten. Dies verwenden wir dann, um das Sprachmodell feinabzustimmen, und so wurde es ChatGPT sehr ähnlich. Wir nennen diesen Prozess **überwachtes Instruktions-Finetuning**.
### Mehrere Spalten für das Finetuning Aber ein großes Problem ist, dass wir bei ChatGPT-ähnlichen Assistenten nur 1 Anweisung / 1 Prompt zulassen und nicht mehrere Spalten / Eingaben. In ChatGPT zum Beispiel kannst du sehen, dass wir 1 Prompt einreichen müssen und nicht mehrere Prompts.
Das bedeutet im Wesentlichen, dass wir mehrere Spalten zu einem großen Prompt „zusammenführen“ müssen, damit das Finetuning tatsächlich funktioniert! Zum Beispiel hat der sehr berühmte Titanic-Datensatz sehr, sehr viele Spalten. Deine Aufgabe war es, vorherzusagen, ob ein Passagier überlebt hat oder gestorben ist, basierend auf seinem Alter, der Passagierklasse, dem Fahrpreis usw. Wir können das nicht einfach in ChatGPT einspeisen, sondern müssen diese Informationen in einen großen Prompt „zusammenführen“.
Wenn wir ChatGPT zum Beispiel mit unserem „zusammengeführten“ einzelnen Prompt fragen, der alle Informationen zu diesem Passagier enthält, können wir es dann bitten zu raten oder vorherzusagen, ob der Passagier gestorben ist oder überlebt hat.
Andere Finetuning-Bibliotheken verlangen von dir, deinen Datensatz für das Finetuning manuell vorzubereiten, indem du alle deine Spalten in einen einzigen Prompt zusammenführst. In Unsloth stellen wir einfach die Funktion bereit, die heißt `to_sharegpt` die das alles in einem Schritt erledigt!
Jetzt ist das etwas komplizierter, da wir viele Anpassungsmöglichkeiten erlauben, aber es gibt ein paar Punkte: * Du musst alle Spalten in geschweifte Klammern einschließen `{}`. Das sind die Spaltennamen in der tatsächlichen CSV- / Excel-Datei. * Optionale Textkomponenten müssen in `[[]]`eingeschlossen werden. Wenn zum Beispiel die Spalte "input" leer ist, zeigt die Zusammenführungsfunktion den Text nicht an und überspringt ihn. Das ist nützlich für Datensätze mit fehlenden Werten. * Wähle die Ausgabe- oder Ziel-/Vorhersagespalte in `output_column_name`. Für den Alpaca-Datensatz ist das `Ausgabe`. Zum Beispiel können wir im Titanic-Datensatz ein großes zusammengeführtes Prompt-Format wie unten erstellen, wobei jede Spalte / jedes Textstück optional wird.
Stell dir zum Beispiel vor, der Datensatz sähe so aus, mit vielen fehlenden Daten: | Eingeschifft in | Alter | Fahrpreis | | --------------- | ----- | --------- | | S | 23 | | | | 18 | 7.25 | Dann möchten wir nicht, dass das Ergebnis lautet: 1. Der Passagier ging in S an Bord. Sein Alter beträgt 23. Sein Fahrpreis ist **LEER**. 2. Der Passagier ging in **LEER**. Sein Alter beträgt 18. Sein Fahrpreis ist 7,25 $. Indem wir Spalten optional in `[[]]`einschließen, können wir diese Informationen vollständig ausschließen. 1. \[\[Der Passagier ging in S an Bord.]] \[\[Sein Alter beträgt 23.]] \[\[Sein Fahrpreis ist **LEER**.]] 2. \[\[Der Passagier ging in **LEER**.]] \[\[Sein Alter beträgt 18.]] \[\[Sein Fahrpreis ist 7,25 $.]] wird zu: 1. Der Passagier ging in S an Bord. Sein Alter beträgt 23. 2. Sein Alter beträgt 18. Sein Fahrpreis ist 7,25 $. ### Mehrturnige Gespräche Ein Problem, falls du es nicht bemerkt hast: Der Alpaca-Datensatz ist ein Einzeldurchgangsformat, während ChatGPT interaktiv ist und du in mehreren Runden mit ihm sprechen kannst. Zum Beispiel ist links das, was wir wollen, aber rechts, also der Alpaca-Datensatz, bietet nur einzelne Gespräche. Wir möchten, dass das feinabgestimmte Sprachmodell irgendwie lernt, wie man mehrturnige Gespräche führt, genau wie ChatGPT.
Also haben wir den `conversation_extension` Parameter eingeführt, der im Wesentlichen einige zufällige Zeilen in deinem Einzeldurchgangsdatensatz auswählt und sie zu einer Konversation zusammenführt! Wenn du ihn zum Beispiel auf 3 setzt, wählen wir zufällig 3 Zeilen aus und führen sie zu einer zusammen! Wenn du sie zu lang einstellst, kann das Training langsamer machen, aber deinen Chatbot und das finale Finetuning viel besser machen!
Dann setze `output_column_name` zur Vorhersage- / Ausgabespalte. Beim Alpaca-Datensatz wäre das die Ausgabespalte. Dann verwenden wir die `standardize_sharegpt` Funktion, um den Datensatz einfach in das richtige Format für das Finetuning zu bringen! Rufe diese immer auf!
## Vision-Finetuning Der Datensatz für das Finetuning eines Vision- oder Multimodalmodells enthält auch Bildeingaben. Zum Beispiel verwendet das [Llama-3.2-Vision-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_\(11B\)-Vision.ipynb#scrollTo=vITh0KVJ10qX) einen Radiographie-Fall, um zu zeigen, wie KI medizinischem Fachpersonal helfen kann, Röntgenaufnahmen, CT-Scans und Ultraschalluntersuchungen effizienter zu analysieren. Wir werden eine Stichprobenversion des ROCO-Radiographie-Datensatzes verwenden. Du kannst auf den Datensatz zugreifen [hier](https://www.google.com/url?q=https%3A%2F%2Fhuggingface.co%2Fdatasets%2Funsloth%2FRadiology_mini). Der Datensatz enthält Röntgenaufnahmen, CT-Scans und Ultraschallbilder, die medizinische Zustände und Krankheiten zeigen. Jedes Bild hat eine von Experten verfasste Bildunterschrift, die es beschreibt. Das Ziel ist es, ein VLM feinabzustimmen, damit es ein nützliches Analysewerkzeug für medizinische Fachkräfte wird. Werfen wir einen Blick auf den Datensatz und prüfen wir, was das erste Beispiel zeigt: ``` Datensatz({ features: ['image', 'image_id', 'caption', 'cui'], num_rows: 1978 }) ``` | Bild | Bildunterschrift | | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | | Die panoramische Radiographie zeigt eine osteolytische Läsion in der rechten hinteren Maxilla mit Resorption des Bodens der Kieferhöhle (Pfeile). | Um den Datensatz zu formatieren, sollten alle Vision-Finetuning-Aufgaben wie folgt formatiert werden: ```python [ { "role": "user", "content": [{"type": "text", "text": instruktion}, {"type": "image", "image": image} ] }, { "role": "assistant", "content": [{"type": "text", "text": antwort} ] }, ] ``` Wir werden eine benutzerdefinierte Anweisung formulieren, die das VLM dazu auffordert, ein Experte für Radiographie zu sein. Beachte auch, dass du statt nur 1 Anweisung mehrere Runden hinzufügen kannst, um daraus eine dynamische Konversation zu machen. ```notebook-python instruction = "Du bist ein Experte für Radiographie. Beschreibe genau, was du in diesem Bild siehst." def convert_to_conversation(sample): conversation = [ { "role": "user", "content" : [ {"type" : "text", "text" : instruction}, {"type" : "image", "image" : sample["image"]} ] }, { "role" : "assistant", "content" : [ {"type" : "text", "text" : sample["caption"]} ] }, ] return { "messages" : conversation } pass ``` Lass uns den Datensatz in das „richtige“ Format für das Finetuning umwandeln: ```notebook-python converted_dataset = [convert_to_conversation(sample) for sample in dataset] ``` Das erste Beispiel ist nun wie unten dargestellt strukturiert: ```notebook-python converted_dataset[0] ``` {% code overflow="wrap" %} ``` {'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'Du bist ein Experte für Radiographie. Beschreibe genau, was du in diesem Bild siehst.'}, {'type': 'image', 'image': }]}, {'role': 'assistant', 'content': [{'type': 'text', 'text': 'Die panoramische Radiographie zeigt eine osteolytische Läsion in der rechten hinteren Maxilla mit Resorption des Bodens der Kieferhöhle (Pfeile).'}]}]} ``` {% endcode %} Bevor wir irgendein Finetuning durchführen, kennt das Vision-Modell vielleicht schon, wie man die Bilder analysiert? Lass uns prüfen, ob das der Fall ist! ```notebook-python FastVisionModel.for_inference(model) # Für Inferenz aktivieren! image = dataset[0]["image"] instruction = "Du bist ein Experte für Radiographie. Beschreibe genau, was du in diesem Bild siehst." messages = [ {"role": "user", "content": [ {"type": "image"}, {"type": "text", "text": instruction} ]} ] input_text = tokenizer.apply_chat_template(messages, add_generation_prompt = True) inputs = tokenizer( image, input_text, add_special_tokens = False, return_tensors = "pt", ).to("cuda") from transformers import TextStreamer text_streamer = TextStreamer(tokenizer, skip_prompt = True) _ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 128, use_cache = True, temperature = 1.5, min_p = 0.1) ``` Und das Ergebnis: ``` Diese Röntgenaufnahme scheint eine panoramische Ansicht des oberen und unteren Gebisses zu sein, genauer gesagt ein Orthopantomogramm (OPG). * Die panoramische Röntgenaufnahme zeigt normale Zahnstrukturen. * Im oberen rechten Bereich gibt es einen abnormalen Bereich, dargestellt durch eine Zone strahlendurchlässigen Knochens, die dem Antrum entspricht. **Wichtige Beobachtungen** * Der Knochen zwischen den linken oberen Zähnen ist relativ strahlendicht. * Oberhalb des Bildes befinden sich zwei große Pfeile, die darauf hindeuten, dass dieser Bereich genauer untersucht werden muss. Einer der Pfeile befindet sich auf der linken Seite, der andere auf der rechten Seite. Allerdings nur ``` Für weitere Details sieh dir unseren Datensatzbereich im [Notizbuch hier](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_\(11B\)-Vision.ipynb#scrollTo=vITh0KVJ10qX). --- # 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 dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://unsloth.ai/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.