> 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 außerdem lernen, wie man [Datensätze in Unsloth verwendet](#applying-chat-templates-with-unsloth). Einer der wichtigsten Bestandteile beim Erstellen eines Datensatzes ist dein [Chat-Template](/docs/de/grundlagen/chat-templates.md) und wie du es gestalten wirst. Tokenisierung ist ebenfalls wichtig, da sie Text in Tokens zerlegt, die Wörter, Wortteile 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 Damit der Tokenisierungsprozess funktioniert, müssen Datensätze in einem Format vorliegen, das von einem Tokenizer gelesen werden kann.
FormatBeschreibungTrainingstyp
RohkorpusRohtext aus einer Quelle wie einer Website, einem Buch oder einem Artikel.Fortgesetztes Pretraining (CPT)
InstructAnweisungen, denen das Modell folgen soll, und ein Beispiel der gewünschten Ausgabe.Überwachtes Fine-Tuning (SFT)
KonversationMehrturn-Konversation zwischen einem Benutzer und einem KI-Assistenten.Überwachtes Fine-Tuning (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.Bestä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 darin bestehen, ein Modell an eine neue Aufgabe wie Zusammenfassung anzupassen oder die Fähigkeit eines Modells zu verbessern, eine bestimmte Figur zu spielen. Zum Beispiel: * Dialoge auf Chat-Basis (Q\&A, eine neue Sprache lernen, Kundensupport, Gespräche). * Strukturierte Aufgaben ([Klassifizierung](https://colab.research.google.com/github/timothelaborie/text_classification_scripts/blob/main/unsloth_classification.ipynb), Zusammenfassungs- und Generierungsaufgaben). * Domänenspezifische Daten (Medizin, Finanzen, Technik). {% endstep %} {% step %} Ausgabestil Der Ausgabestil lässt uns wissen, welche Datenquellen wir verwenden werden, um unsere gewünschte Ausgabe zu erreichen. Zum Beispiel könnte die gewünschte 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 so trainieren möchtest, dass es eine Sprache lernt. Die Datenquelle kann eine CSV-Datei, ein PDF oder sogar eine Website sein. Du kannst auch [synthetisch generieren](#synthetic-data-generation) von Daten, aber es ist besondere Sorgfalt erforderlich, um sicherzustellen, dass jedes Beispiel von hoher Qualität 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, damit dein Modell intelligenter und vielfältiger wird. Du könntest auch [synthetisch erzeugte Daten](#synthetic-data-generation). {% endhint %} ## 🦥 Unsloth Data Recipes [Unsloth Data Recipes](/docs/de/neu/studio/data-recipe.md) ermöglicht es dir, Dokumente wie PDFs oder CSV-Dateien hochzuladen und sie in nutzbare Datensätze umzuwandeln. Erstelle und bearbeite Datensätze visuell über einen Graph-Node-Workflow. Die Rezepte-Seite ist der Haupteinstiegspunkt. Rezepte werden lokal im Browser gespeichert, sodass du später zu gespeicherten Arbeiten zurückkehren kannst. Von hier aus kannst du 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 aus, baust den Workflow im Editor, validierst ihn, führst eine Vorschau aus und erstellst dann den vollständigen Datensatz, sobald die Ausgabe korrekt aussieht. Füge Seed-Daten und Generierungsblöcke hinzu, validiere den Workflow, sieh dir Beispielausgaben in der Vorschau an und führe dann einen vollständigen Datensatzaufbau aus. Auf einen Blick sollte ein üblicher Workflow so aussehen: 1. Öffne die Rezepte-Seite. 2. Erstelle ein neues Rezept oder öffne ein vorhandenes. 3. Füge Blöcke hinzu, um deinen Datensatz-Workflow zu definieren. 4. Klicken Sie auf **Validiere** um Konfigurationsprobleme frühzeitig zu erkennen. 5. Führe eine Vorschau aus, um Beispielzeilen schnell zu prüfen. 6. Führe einen vollständigen Datensatzaufbau aus, wenn das Rezept fertig ist. 7. Überprüfe den Fortschritt und die Ausgabe live im Graphen oder in der **Ausführungen** Ansicht für weitere Details. 8. Wähle den resultierenden Datensatz in **Studio** aus und führe ein Fine-Tuning eines Modells durch. Mehr lesen: {% 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 Eimischung vermengt, wodurch durch die Restwärme eine cremige Sauce entsteht. Trotz weit verbreiteter Annahme enthält authentische Carbonara niemals Sahne oder Knoblauch. Das Gericht stammt wahrscheinlich aus Rom in der Mitte des 20. Jahrhunderts, obwohl seine genauen Ursprünge umstritten sind..." ``` Dieses Format bewahrt den natürlichen Sprachfluss und ermöglicht es dem Modell, aus zusammenhängendem Text zu lernen. Wenn wir ein Modell an eine neue Aufgabe anpassen und möchten, dass das Modell Text in einem einzigen Durchgang auf der Grundlage eines bestimmten Satzes 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; im Wesentlichen ist es die Anfrage des Benutzers." "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 detaillierte Rezept?" } ] } ``` Das Template-Format verwendet die Attributschlüssel "from"/"value" und die Nachrichten wechseln zwischen `Mensch`und `gpt`, was einen natürlichen Dialogfluss ermöglicht. Das andere gängige Format ist OpenAIs ChatML-Format und ist das Standardformat 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 Für Datensätze, die normalerweise dem gängigen ChatML-Format folgen, besteht der Prozess der Vorbereitung des Datensatzes für Training oder Finetuning aus vier einfachen Schritten: * Prüft 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 eine Beispielausgabe:\\ ``` ['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'] ``` \\\\ * Verwenden Sie `get_chat_template` um die richtige Chat-Vorlage auf euren Tokenizer anzuwenden:\\ ``` from unsloth.chat_templates import get_chat_template tokenizer = get_chat_template( tokenizer, chat_template = "gemma-3", # Ändert dies in den richtigen chat_template-Namen ) ``` \\\\ * Definiert eure 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 läuft durch euren Datensatz und wendet die von euch definierte Chat-Vorlage auf jedes Beispiel an.\\ * Lassen wir 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") # Wendet die Formatierungsfunktion mit der map-Methode auf euren Datensatz an dataset = dataset.map(formatting_prompts_func, batched = True,) ``` \ Wenn euer Datensatz das ShareGPT-Format mit "from"/"value"-Schlüsseln anstelle des ChatML-Formats "role"/"content" verwendet, könnt ihr die `standardize_sharegpt` Funktion verwenden, um ihn zuerst zu konvertieren. Der überarbeitete Code sieht dann so aus:\ \\ ``` # Datensatz importieren from datasets import load_dataset dataset = load_dataset("mlabonne/FineTome-100k", split = "train") # Konvertiert euren Datensatz bei Bedarf in das Format "role"/"content" from unsloth.chat_templates import standardize_sharegpt dataset = standardize_sharegpt(dataset) # Wendet die Formatierungsfunktion mit der map-Methode auf euren Datensatz an dataset = dataset.map(formatting_prompts_func, batched = True,) ``` ### Datenformatierung Q\&A **F:** Wie kann ich das Alpaca-Instruktionsformat verwenden? **A:** Wenn dein Datensatz bereits im Alpaca-Format vorliegt, befolge dann die Formatierungsschritte wie im Llama3.1 [Notebook ](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 konvertieren musst, besteht ein Ansatz darin, ein Python-Skript zu erstellen, das deine Rohdaten verarbeitet. 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 Ziel-Datensatz im ShareGPT-Format vorliegt, dein Modell jedoch stattdessen ein ChatML-Format erwartet. \ **F:** Warum nicht die apply\_chat\_template-Funktion verwenden, die mit dem Tokenizer geliefert wird. **A:** Der `chat_template` Attribut kann bei der ersten Veröffentlichung eines Modells durch die ursprünglichen Modellbesitzer manchmal Fehler enthalten und braucht möglicherweise Zeit, bis es aktualisiert wird. Im Gegensatz dazu prüfen wir bei Unsloth gründlich alles und beheben eventuelle Fehler im `chat_template` für jedes Modell, wenn wir die quantisierten Versionen in unsere Repositories hochladen. Zusätzlich bieten unsere `get_chat_template` und `apply_chat_template` Methoden erweiterte Funktionen zur Datenmanipulation, die in unserer Chat-Templates-Dokumentation vollständig dokumentiert sind [Seite](https://docs.unsloth.ai/basics/chat-templates). **F:** Was ist, wenn mein Template derzeit nicht von Unsloth unterstützt wird? **A:** Reiche eine Feature-Anfrage im Unsloth-GitHub-Issues- [Forum](https://github.com/unslothai/unsloth)ein. Als vorübergehende Lösung könntest du auch die eigene apply\_chat\_template-Funktion des Tokenizers verwenden, bis deine Feature-Anfrage genehmigt und übernommen wurde. ## Synthetische Datenerzeugung 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 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 nach mehr Daten zu fragen. Es gibt 3 Ziele für synthetische Daten: * Vollständig neue Daten erzeugen – entweder von Grund auf oder aus deinem vorhandenen Datensatz * Diversifiziere deinen Datensatz, damit dein Modell nicht [überanpasst](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md#avoiding-overfitting-and-underfitting) und zu spezifisch wird * Vorhandene 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 Unsloth Studios [Data Recipes](/docs/de/neu/studio/data-recipe.md) hochladen, und es wird sie automatisch in einen nutzbaren / synthetischen Datensatz umwandeln. Weitere Details in [unserem Leitfaden](/docs/de/neu/studio/data-recipe.md).
### Einen lokalen LLM oder ChatGPT für synthetische Daten verwenden Dein Ziel ist es, das Modell dazu aufzufordern, 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, also stelle sicher, dass du mindestens 10 Beispiele von Daten bereits hast. Beispiel-Prompts: * **Prompt zum Erzeugen weiterer Dialoge auf einem vorhandenen Datensatz**: 
Verwende das Datensatzbeispiel, das ich bereitgestellt habe, befolge die Struktur und generiere Gespräche basierend auf den Beispielen.
* **Prompt, wenn du keinen Datensatz hast**: {% code overflow="wrap" %} ``` Erstelle 10 Beispiele für Produktbewertungen für Coca-Cola, klassifiziert als positiv, negativ oder neutral. ``` {% endcode %} * **Prompt für einen nicht formatierten Datensatz**: {% code overflow="wrap" %} ``` Strukturiere meinen Datensatz so, dass er für das Fine-Tuning ein QA-ChatML-Format hat. Erzeuge 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 qualitativ schlechte Antworten zu entfernen oder zu verbessern. Abhängig von deinem Datensatz muss er möglicherweise auch in vielen Bereichen ausgeglichen werden, damit dein Modell nicht überanpasst. Du kannst diesen bereinigten Datensatz dann wieder in dein LLM einspeisen, um Daten erneut zu erzeugen, 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 brauchbare Ergebnisse zu erzielen. Für optimale Leistung ist ein Datensatz mit über 1.000 Zeilen vorzuziehen, und in diesem Fall führt mehr Daten 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 vielfältiger zu machen. 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 Reasoning-Fähigkeiten besitzt, wie die destillierten Versionen von DeepSeek-R1 (z. B. DeepSeek-R1-Distill-Llama-8B), musst du weiterhin Frage-/Aufgaben- und Antwortpaare verwenden; für deine Antwort musst du sie jedoch so ändern, dass sie den Reasoning-/Chain-of-Thought-Prozess und die Schritte enthält, die zur Ableitung der Antwort unternommen wurden.\ \ 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 seinen 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 kombinieren und auf diesem vereinheitlichten Datensatz feinabstimmen. * Verwende das [Mehrere Datensätze](https://colab.research.google.com/drive/1njCCbE1YVal9xC83hjdo2hiGItpY_D6t?usp=sharing) Notebook, 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, alle Datensätze zu kombinieren und das Fine-Tuning stattdessen in einem einzigen Durchlauf 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 in Unsloth auf Google Colab verwendet:
Wir werden jetzt den Alpaca-Datensatz verwenden, der durch Aufruf von GPT-4 selbst erstellt wurde. Es ist eine Liste von 52.000 Anweisungen und Ausgaben, die sehr beliebt war, als Llama-1 veröffentlicht wurde, da sie die Feinabstimmung eines Basismodells so gut machte, dass es mit ChatGPT selbst konkurrieren konnte. Du kannst auf die GPT4-Version des Alpaca-Datensatzes zugreifen [hier](https://huggingface.co/datasets/vicgalle/alpaca-gpt4.). Unten sind einige Beispiele des Datensatzes zu sehen:
Du kannst sehen, dass es in jeder Zeile 3 Spalten gibt – eine Anweisung sowie Eingabe und Ausgabe. Wir kombinieren im Wesentlichen jede Zeile zu einem großen Prompt wie unten. Dies verwenden wir dann, um das Sprachmodell feinabzustimmen, und das machte es ChatGPT sehr ähnlich. Wir nennen diesen Prozess **überwachtes Instruction-Finetuning**.
### Mehrere Spalten für das Fine-Tuning Ein großes Problem ist jedoch, dass wir bei ChatGPT-ähnlichen Assistenten nur 1 Anweisung / 1 Prompt erlauben und nicht mehrere Spalten / Eingaben. In ChatGPT zum Beispiel kannst du sehen, dass wir 1 Prompt und nicht mehrere Prompts übermitteln müssen.
Das bedeutet im Wesentlichen, dass wir für eine funktionierende Feinabstimmung mehrere Spalten zu 1 großen Prompt „zusammenführen“ müssen! Zum Beispiel hat der sehr berühmte Titanic-Datensatz viele, viele Spalten. Deine Aufgabe war es, vorherzusagen, ob ein Passagier überlebt oder gestorben ist, basierend auf seinem Alter, der Passagierklasse, dem Fahrpreis usw. Wir können das nicht einfach in ChatGPT eingeben, sondern müssen diese Informationen zu 1 großen Prompt „zusammenführen“.
Wenn wir ChatGPT beispielsweise mit unserem „zusammengeführten“ einzelnen Prompt fragen, der alle Informationen für diesen Passagier enthält, können wir es dann bitten zu raten oder vorherzusagen, ob der Passagier gestorben oder überlebt hat.
Andere Feinabstimmungsbibliotheken verlangen, dass du dein Datenset für die Feinabstimmung manuell vorbereitest, indem du alle deine Spalten zu 1 Prompt zusammenführst. In Unsloth stellen wir einfach die Funktion namens `to_sharegpt` bereit, die dies in einem Schritt erledigt!
Jetzt ist das etwas komplizierter, da wir viele Anpassungen erlauben, aber es gibt einige Punkte: * Du musst alle Spalten in geschweifte Klammern einschließen `{}`. Dies sind die Spaltennamen in der eigentlichen CSV-/Excel-Datei. * Optionale Textbestandteile müssen in `[[]]`eingeschlossen werden. Wenn beispielsweise die Spalte „input“ leer ist, wird die Zusammenführungsfunktion den Text nicht anzeigen und diesen überspringen. 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 wird dies `output`. Zum Beispiel können wir für den Titanic-Datensatz ein großes zusammengeführtes Prompt-Format wie unten erstellen, bei dem jede Spalte / jeder Textbestandteil optional wird.
Zum Beispiel stelle dir vor, der Datensatz sieht mit vielen fehlenden Daten so aus: | Eingeschifft | Alter | Fahrpreis | | ------------ | ----- | --------- | | S | 23 | | | | 18 | 7.25 | Dann möchten wir nicht, dass das Ergebnis so lautet: 1. Der Passagier ist in S eingeschifft. Sein Alter ist 23. Sein Fahrpreis beträgt **LEER**. 2. Der Passagier ist eingeschifft von **LEER**. Sein Alter ist 18. Sein Fahrpreis beträgt 7,25 $. Stattdessen können wir durch das optionale Einschließen von Spalten mit `[[]]`diese Informationen vollständig ausschließen. 1. \[\[Der Passagier ist in S eingeschifft.]] \[\[Sein Alter ist 23.]] \[\[Sein Fahrpreis beträgt **LEER**.]] 2. \[\[Der Passagier ist eingeschifft von **LEER**.]] \[\[Sein Alter ist 18.]] \[\[Sein Fahrpreis beträgt 7,25 $.]] wird zu: 1. Der Passagier ist in S eingeschifft. Sein Alter ist 23. 2. Sein Alter ist 18. Sein Fahrpreis beträgt 7,25 $. ### Mehrturn-Konversationen Ein Problem, falls du es nicht bemerkt hast, ist, dass der Alpaca-Datensatz nur eine einzelne Gesprächsrunde hat, während die Verwendung von ChatGPT interaktiv war und du in mehreren Runden mit ihm sprechen kannst. Zum Beispiel ist links das, was wir wollen, aber rechts, der Alpaca-Datensatz, bietet nur einzelne Gespräche. Wir wollen, dass das feinabgestimmte Sprachmodell irgendwie lernt, wie man mehrrundige 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 Ein-Runden-Datensatz auswählt und sie zu 1 Gespräch zusammenführt! Wenn du ihn zum Beispiel auf 3 setzt, wählen wir zufällig 3 Zeilen aus und führen sie zu 1 zusammen! Wenn du ihn zu lang setzt, kann das Training langsamer machen, aber deinen Chatbot und die finale Feinabstimmung deutlich verbessern!
Dann setze `output_column_name` auf die Vorhersage-/Ausgabespalte. Für den Alpaca-Datensatz wäre das die Ausgabespalte. Dann verwenden wir die `standardize_sharegpt` Funktion, um das Datenset einfach in ein korrektes Format für die Feinabstimmung zu bringen! Immer aufrufen!
## Vision Fine-Tuning Der Datensatz für das Fine-Tuning eines Vision- oder multimodalen Modells enthält ebenfalls 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 radiologischen 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-Radiografie-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 Analysetool für medizinisches Fachpersonal wird. Werfen wir einen Blick auf den Datensatz und prüfen wir, was das 1. Beispiel zeigt: ``` Datensatz({ features: ['image', 'image_id', 'caption', 'cui'], num_rows: 1978 }) ``` | Bild | Bildunterschrift | | --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | | Panoramaröntgen zeigt eine osteolytische Läsion im rechten hinteren Oberkiefer mit Resorption des Bodens der Kieferhöhle (Pfeile). | Um den Datensatz zu formatieren, sollten alle Vision-Fine-Tuning-Aufgaben wie folgt formatiert werden: ```python [ { "role": "user", "content": [{"type": "text", "text": instruction}, {"type": "image", "image": image} ] }, { "role": "assistant", "content": [{"type": "text", "text": answer} ] }, ] ``` Wir werden eine benutzerdefinierte Anweisung formulieren, die das VLM auffordert, ein Experte für Radiografie zu sein. Beachte außerdem, dass du statt nur 1 Anweisung mehrere Gesprächsrunden hinzufügen kannst, um daraus eine dynamische Konversation zu machen. ```notebook-python instruction = "Du bist ein Experte für Radiografie. Beschreibe genau, was du auf 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 "korrekte" Format für das Fine-Tuning umwandeln: ```notebook-python converted_dataset = [convert_to_conversation(sample) for sample in dataset] ``` Das erste Beispiel ist jetzt wie unten strukturiert: ```notebook-python converted_dataset[0] ``` {% code overflow="wrap" %} ``` {'messages': [{'role': 'user', 'content': [{'type': 'text', 'text': 'Du bist ein Experte für Radiografie. Beschreibe genau, was du auf diesem Bild siehst.'}, {'type': 'image', 'image': }]}, {'role': 'assistant', 'content': [{'type': 'text', 'text': 'Panoramaröntgen zeigt eine osteolytische Läsion im rechten hinteren Oberkiefer mit Resorption des Bodens der Kieferhöhle (Pfeile).'}]}]} ``` {% endcode %} Bevor wir irgendein Fine-Tuning durchführen, weiß 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 Radiografie. Beschreibe genau, was du auf 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: ``` Dieses Röntgenbild scheint eine Panoramaaufnahme des oberen und unteren Gebisses zu sein, insbesondere ein Orthopantomogramm (OPG). * Die Panoramaröntgenaufnahme zeigt normale Zahnstrukturen. * Es gibt einen unauffälligen Bereich oben rechts, dargestellt durch einen Bereich strahlendurchlässigen Knochens, entsprechend dem Antrum. **Wichtige Beobachtungen** * Der Knochen zwischen den linken oberen Zähnen ist relativ strahlundurchlässig. * Über dem Bild sind zwei große Pfeile zu sehen, die auf die Notwendigkeit einer genaueren Untersuchung dieses Bereichs hinweisen. Einer der Pfeile befindet sich links, der andere rechts. Allerdings nur ``` Für weitere Details sieh dir unseren Datensatzabschnitt in der [Notebook 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: ``` GET https://unsloth.ai/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.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.