Daten für das LLM Fine-Tuning vorbereiten

Das Fine-Tuning eines Large Language Models (LLM) steht und fällt mit der Qualität der verwendeten Trainingsdaten. Saubere, strukturierte und relevante Datensätze beeinflussen direkt, wie präzise ein Modell Anweisungen befolgt, Fragen beantwortet und sich in produktiven Umgebungen verhält.

Dieser Leitfaden beschreibt den gesamten Prozess der Datenvorbereitung für das LLM Fine-Tuning: von unbearbeitetem Ausgangsmaterial bis zu einem Datensatz, der für reale Trainingsprozesse einsatzbereit ist.

Wichtige Erkenntnisse

Beim Fine-Tuning von LLMs ist Datenqualität wichtiger als die reine Datenmenge. Sorgfältig bereinigte, gut organisierte und auf konkrete Aufgaben ausgerichtete Daten liefern in der Regel bessere Ergebnisse als große Datensätze mit Rauschen oder Inkonsistenzen.

Vor der Datensammlung sollte ein klar definiertes Ziel feststehen. Ob das Modell Anweisungen befolgen, domänenspezifisches Wissen aufbauen oder dialogorientiertes Verhalten lernen soll, beeinflusst jede Entscheidung innerhalb der Datenpipeline.

Instruction-Response-Paare bilden die Grundlage für wirksames Fine-Tuning. Verständliche Prompts mit präzisen und korrekten Antworten helfen dem Modell, das gewünschte Verhalten schneller zu erlernen.

Das richtige Datenformat ist entscheidend. Wenn die Struktur des Datensatzes zum Trainingsframework passt, etwa JSON, JSONL oder ein Chat-Format, lassen sich Trainingsfehler vermeiden und die Lernqualität verbessern.

Bewertung und Optimierung müssen fortlaufend erfolgen. Fine-Tuning ist ein iterativer Prozess, bei dem Ergebnisse überwacht, Daten verbessert und Modelle erneut trainiert werden, bis die gewünschte Leistung erreicht ist.

Anforderungen an Daten für LLM Fine-Tuning verstehen

Daten für Fine-Tuning bestehen nicht einfach aus rohem Text, der aus dem Internet gesammelt wurde. Anders als beim Pretraining, bei dem Modelle allgemeine Sprachmuster aus sehr großen Textmengen lernen, bringt Fine-Tuning einem Modell bei, wie es reagieren und sich verhalten soll. Ziel ist es, das Modell so auszurichten, dass es Anweisungen befolgt, präzise antwortet und einen konsistenten Ton oder eine bestimmte Persona beibehält.

Praktisch bedeutet das, Wissen in strukturierte Beispiele zu überführen, die eine Nutzerabsicht mit einer idealen Antwort verbinden. Jedes Beispiel zeigt dem Modell, wie eine hochwertige Antwort auf einen bestimmten Prompt aussehen sollte. Im Verlauf des Trainings verinnerlicht das Modell diese Muster und überträgt sie auf neue Eingaben.

Die meisten modernen Fine-Tuning-Workflows verwenden entweder instruction-basierte Datensätze oder chatbasierte Datensätze. Instruction-basierte Daten enthalten typischerweise eine Anweisung, eine optionale Eingabe und eine Ausgabe. Chatbasierte Daten arbeiten mit rollenbasierten Nachrichten wie system, user und assistant. Beide Formate verfolgen dasselbe Ziel; die passende Wahl hängt vom Zielmodell und vom verwendeten Trainingsframework ab.

Datenformate für LLM Fine-Tuning

Bevor ein Datensatz erstellt oder exportiert wird, sollte klar sein, welche Formate beim LLM Fine-Tuning üblich sind. Das gewählte Format beeinflusst, wie das Modell Anweisungen interpretiert, Gesprächsabläufe erlernt und auf reale Anwendungsfälle generalisiert. Obwohl viele aktuelle Trainingsframeworks mehrere Formate unterstützen, ist jedes Format auf leicht unterschiedliche Fine-Tuning-Ziele ausgerichtet.

Zu den am häufigsten verwendeten Formaten für das Fine-Tuning von Modellen gehören die folgenden Varianten.

Completion-Style-Format

Completion-Style-Datensätze sind die einfachste und traditionellste Form von Fine-Tuning-Daten. Dabei erhält das Modell einen Prompt und lernt, die passende Fortsetzung zu erzeugen. Dieses Format wurde häufig bei früherem GPT-ähnlichem Fine-Tuning eingesetzt und wird weiterhin von vielen Plattformen und APIs unterstützt.

Ein Beispiel im Completion-Style kann so aussehen:

{
"prompt": "What is a GPU-based virtual server?
Answer:",
"completion": " A GPU-based virtual server is a cloud-hosted machine equipped with NVIDIA GPUs for AI, machine learning, and high-performance computing workloads."
}

In diesem Aufbau lernt das Modell, Text nach dem Prompt fortzuführen. Die Methode ist einfach, bringt aber auch Einschränkungen mit sich. Da die Struktur nur implizit vorhanden ist, kann es für das Modell schwieriger sein, komplexe Anweisungen oder mehrstufige Dialoge zuverlässig zu verarbeiten. Completion-Style-Fine-Tuning eignet sich vor allem für eng begrenzte Aufgaben wie kurze Antworten, Klassifizierung oder kontrollierte Textgenerierung.

Instruction-Style-Format

Instruction-Style-Fine-Tuning macht das Trainingsziel deutlicher, indem Aufgabenanweisung und erwartete Ausgabe klar getrennt werden. Dieses Format hat sich als verbreiteter Standard für die Anpassung von Open-Source-LLMs etabliert, da es die Fähigkeit zur Befolgung von Anweisungen verbessert und Mehrdeutigkeiten reduziert.

Ein Instruction-Style-Beispiel enthält meist drei Felder: eine instruction, eine optionale input-Komponente und eine output-Komponente. Die instruction beschreibt die Aufgabe, input liefert bei Bedarf zusätzlichen Kontext und output stellt die ideale Antwort dar.

{
"instruction": "Explain what a GPU-based virtual server is",
"input": "",
"output": "A GPU-based virtual server is a cloud-hosted machine that includes NVIDIA GPUs and is designed for AI, machine learning, deep learning, and high-performance computing workloads."
}

Diese Struktur ist gut lesbar und einfach zu prüfen. Außerdem lassen sich unterschiedliche Aufgabentypen wie Erklärungen, Zusammenfassungen oder Troubleshooting innerhalb eines Datensatzes kombinieren. Instruction-Style-Daten eignen sich besonders dann, wenn ein Modell zuverlässig Befehle befolgen und konsistente, domänenspezifische Antworten erzeugen soll.

Chat-Style-Format

Chat-Style-Datensätze sind darauf ausgelegt, reale Gesprächsabläufe nachzubilden. Jedes Trainingsbeispiel besteht aus einer Abfolge von Nachrichten, denen jeweils eine Rolle wie system, user oder assistant zugewiesen ist. Diese Struktur entspricht sehr genau der Art und Weise, wie chatbasierte LLMs in produktiven Anwendungen genutzt werden.

Ein Chat-Style-Beispiel kann so aussehen:

{
"messages": [
{"role": "system", "content": "You are a helpful cloud support assistant."},
{"role": "user", "content": "What is a GPU-based virtual server?"},
{"role": "assistant", "content": "A GPU-based virtual server is a cloud machine equipped with NVIDIA GPUs and designed for AI, machine learning, and high-performance computing workloads."}
]
}

Die Systemnachricht legt das erwartete Verhalten und den Ton des Modells fest, während Nutzer- und Assistant-Nachrichten den Gesprächsfluss vermitteln. Dieses Format ist besonders hilfreich für Chatbots, Support-Agenten und Assistenten, die mit mehrstufigem Kontext umgehen müssen.

Chat-Style-Datensätze sind jedoch umfangreicher und etwas aufwendiger in der Vorbereitung. Sie eignen sich vor allem dann, wenn die spätere Anwendung dialogorientiert und kontextabhängig ist.

Bevor ein Trainingsformat ausgewählt wird, sollte die beabsichtigte Aufgabe eindeutig definiert sein.

Für einfache Prompt-Response-Anwendungsfälle kann Completion-Style-Datenmaterial ausreichend sein. Für die meisten Szenarien im Bereich Domain Adaptation und Instruction Following bieten Instruction-Style-Datensätze die beste Kombination aus Klarheit und Flexibilität. Für dialogorientierte Agenten, die Kontext und Persona beibehalten müssen, sind Chat-Style-Datensätze meist die natürlichste Wahl. Entscheidend ist vor allem Konsistenz. Ein sauberer und gut strukturierter Datensatz in einem dieser Formate erzielt in der Regel bessere Ergebnisse als ein größerer, aber schlecht organisierter Datensatz.

Woher Fine-Tuning-Daten stammen

Hochwertige Fine-Tuning-Datensätze werden normalerweise aus vertrauenswürdigen und autoritativen Quellen aufgebaut. Dazu können Produktdokumentationen, API-Referenzen, interne Support-Tickets, Help-Center-Inhalte und von Experten verfasste Erklärungen gehören. In vielen realen Workflows erstellen Teams zusätzlich synthetische Beispiele, um Edge Cases oder unterrepräsentierte Fragen abzudecken.

Zuverlässige Quellen müssen das Wissen und Verhalten widerspiegeln, das das Modell lernen soll. Für domänenspezifisches Fine-Tuning gehören dazu häufig offizielle Dokumentationen, interne Wissensdatenbanken, Support-Tickets, FAQs und von Fachleuten erstellte Leitfäden. Je näher die Daten an echten Nutzerfragen und geprüften Antworten liegen, desto stärker wird in der Regel das feinabgestimmte Modell. In bestimmten Fällen kann auch ethisches Web Scraping eingesetzt werden, um zuverlässige Daten für das Training domänenspezifischer Chatbots zu sammeln.

In der Praxis kombinieren viele Teams proprietäre Daten mit offenen Datensätzen. Plattformen wie Hugging Face spielen dabei eine wichtige Rolle. Hugging Face stellt Tausende öffentliche Datensätze für Instruction Tuning, Question Answering, Zusammenfassung und dialogorientierte Aufgaben bereit. Diese Datensätze können direkt verwendet, an eine bestimmte Domäne angepasst oder als Vorlage für eigene Daten genutzt werden. Hugging Face Datasets bieten außerdem standardisierte Werkzeuge für Laden, Versionierung und Streaming, wodurch groß angelegte Datenerfassung und Vorverarbeitung deutlich einfacher werden.

LLM-generierte Daten und synthetische Datensatzerstellung

Ein moderner Ansatz beim LLM Fine-Tuning besteht darin, Trainingsdaten mithilfe eines bestehenden Large Language Models zu erzeugen. Diese Methode wird häufig als synthetische Datengenerierung oder LLM-generierte Daten bezeichnet und hat an Bedeutung gewonnen, weil sie Zeit und Kosten bei der Erstellung hochwertiger Datensätze reduzieren kann.

In diesem Workflow wird ein leistungsfähiges Basismodell dazu aufgefordert, Instruction-Response-Paare, Frage-Antwort-Beispiele oder mehrstufige Dialoge auf Basis eines vorgegebenen Schemas zu erstellen. Die generierten Ergebnisse werden anschließend geprüft, gefiltert und verfeinert, bevor sie in den Trainingsdatensatz übernommen werden. Bei sorgfältiger Umsetzung kann diese Methode Daten erzeugen, die echten Nutzerinteraktionen sehr nahekommen.

LLM-generierte Daten sind besonders nützlich, wenn nicht genügend von Menschen geschriebene Beispiele vorhanden sind, Edge Cases abgedeckt werden müssen oder ein bestehender Datensatz für mehr Vielfalt erweitert werden soll. Wenn beispielsweise eine kleine Menge geprüfter Fakten zu einem Cloud-Infrastruktur-Thema vorliegt, kann ein LLM viele semantisch unterschiedliche Fragen und präzise Antworten erzeugen, die konsistent mit dem Ausgangswissen bleiben.

Synthetische Daten sollten dennoch mit Vorsicht eingesetzt werden. Modelle können eigene Verzerrungen und Formulierungsmuster wiederholen, was zu Overfitting oder geringerer sprachlicher Vielfalt führen kann, wenn ein Datensatz ausschließlich synthetisch aufgebaut ist. Deshalb funktionieren synthetische Daten am besten, wenn sie mit menschlich kuratierten oder autoritativen Quellen kombiniert werden. Menschliche Prüfung, automatische Validierung und Deduplizierung sind wesentliche Bestandteile dieses Prozesses.

Produktive Pipelines nutzen häufig einen hybriden Ansatz. Menschlich erstellte Inhalte legen Korrektheit und Tonalität fest, während LLM-generierte Daten den Datensatz skalieren und Lücken schließen. Dieses Gleichgewicht hilft Teams, starke Fine-Tuning-Ergebnisse zu erzielen, ohne Genauigkeit oder Zuverlässigkeit zu gefährden.

Hugging-Face-Datensätze für LLM Fine-Tuning vorbereiten

Hugging Face bietet viele Open-Source-Datensätze, die für den Aufbau hochwertiger Fine-Tuning-Daten genutzt werden können. Viele dieser Datensätze enthalten bereits Instruction-Response-Paare, müssen aber häufig noch in ein einheitliches Prompt-Format überführt werden, bevor sie trainiert werden können.

Beispiel 1

from datasets import load_dataset
from itertools import islice

# Load Dolly dataset without streaming because it is small enough
dataset = load_dataset("databricks/databricks-dolly-15k", split="train")

# Select the first 1000 samples
samples = list(islice(dataset, 1000))

print("Dolly sample structure:")
print(samples[0])

# Prepare the data for instruction fine-tuning
def format_dolly(example):
   instruction = example["instruction"]
   context = example.get("context", "")
   response = example["response"]

   prompt_parts = [
       f"### Instruction:\n{instruction}"
   ]

   if context.strip():
       prompt_parts.append(f"### Input:\n{context}")

   prompt_parts.append(f"### Response:\n{response}")

   return {"text": "\n".join(prompt_parts)}

# Format all selected samples
formatted_samples = [format_dolly(sample) for sample in samples]

Dolly sample structure:
{'instruction': 'When did Virgin Australia start operating?', 'context': "Virgin Australia, the trading name of Virgin Australia Airlines Pty Ltd, is an Australian-based airline. It is the largest airline by fleet size to use the Virgin brand. It commenced services on 31 August 2000 as Virgin Blue, with two aircraft on a single route. It suddenly found itself as a major airline in Australia's domestic market after the collapse of Ansett Australia in September 2001. The airline has since grown to directly serve 32 cities in Australia, from hubs in Brisbane, Melbourne and Sydney.", 'response': 'Virgin Australia commenced services on 31 August 2000 as Virgin Blue, with two aircraft on a single route.', 'category': 'closed_qa'}

Beispiel 2

from datasets import load_dataset
from itertools import islice

dataset = load_dataset(
   "Open-Orca/OpenOrca",
   split="train",
   streaming=True
)

samples = list(islice(dataset, 1000))

def format_openorca(example):
   system = example.get("system_prompt", "You are a helpful assistant.")
   question = example["question"]
   answer = example["response"]

   text = (
       f"### System:\n{system}\n"
       f"### Instruction:\n{question}\n"
       f"### Response:\n{answer}"
   )

   return {"text": text}

formatted_samples = [format_openorca(s) for s in samples]

{   'text': '### System:\n'
            '\n'
            '### Instruction:\n'
            'You will be given a definition of a task first, then some input '
            'of the task.\n'
            'This task is about using the specified sentence and converting '
            'the sentence to Resource Description Framework (RDF) triplets of '
            'the form (subject, predicate object). The RDF triplets generated '
            'must be such that the triplets accurately capture the structure '
            'and semantics of the input sentence. The input is a sentence and '
            'the output is a list of triplets of the form [subject, predicate, '
            'object] that capture the relationships present in the sentence. '
            'When a sentence has more than 1 RDF triplet possible, the output '
            'must contain all of them.\n'
            '\n'
            "AFC Ajax (amateurs)'s ground is Sportpark De Toekomst where Ajax "
            'Youth Academy also play.\n'
            'Output:\n'
            '### Response:\n'
            '[\n'
            '  ["AFC Ajax (amateurs)", "has ground", "Sportpark De '
            'Toekomst"],\n'
            '  ["Ajax Youth Academy", "plays at", "Sportpark De Toekomst"]\n'
            ']'}

Dieser Ansatz sorgt für ein einheitliches Prompt-Format über alle Beispiele hinweg, behandelt optionale Eingabefelder sauber, erzeugt ein einzelnes „text“-Feld, das gut mit Tokenizern funktioniert, und bleibt kompatibel mit LoRA, QLoRA sowie vollständigen Fine-Tuning-Pipelines.

Nach der Formatierung kann der Datensatz tokenisiert und direkt an eine Trainingsschleife übergeben werden, zum Beispiel mit Hugging Face Trainer, SFTTrainer oder eigenem PyTorch-Code.

Tipp: Prüfen Sie vor dem Training immer mehrere formatierte Beispiele. Bereits kleine Formatierungsfehler können das Verhalten des Modells während des Fine-Tunings spürbar beeinflussen.

Daten für domänenspezifisches LLM Fine-Tuning erstellen

Das Fine-Tuning eines Large Language Models für eine bestimmte Domäne, etwa Gesundheitswesen, Recht, Finanzen oder Bildung, erfordert die Sammlung geeigneter Rohdaten.

Dieser Abschnitt beschreibt eine strukturierte Methode, um hochwertige, domänenspezifische Fine-Tuning-Daten zu erstellen.

Domänenumfang und Zielaufgaben definieren

Zu Beginn sollte klar festgelegt werden, was das Modell lernen soll und wie es später eingesetzt wird. Domänenspezifisches Fine-Tuning ist besonders wirksam, wenn der Umfang fokussiert und auf konkrete Aufgaben ausgerichtet ist.

Wichtige Fragen sind:

• Auf welches Domänenwissen soll sich das Modell spezialisieren?
• Welche Aufgaben sollen Nutzer mit dem Modell ausführen können?
• Welches fachliche Niveau sollen die Antworten widerspiegeln?

Beispiele:

• Gesundheitswesen: klinische Notizen zusammenfassen, medizinische Konzepte erklären
• Finanzen: Finanzkennzahlen interpretieren, Geschäftszahlen analysieren
• DevOps: Logs auswerten, Incidents untersuchen

Ein klar definierter Umfang hilft dabei, irrelevante oder verrauschte Daten zu vermeiden, die die Modellleistung verschlechtern könnten.

Hochwertige Domänendaten sammeln

Domänenspezifische Datensätze sollten aus zuverlässigen und autoritativen Quellen stammen.

Typische Quellen sind:

• Interne Dokumentationen und Wissensdatenbanken
• Branchen-Whitepaper und wissenschaftliche Publikationen
• Technische Handbücher und Produktdokumentationen
• Support-Tickets, FAQs und Kundengespräche
• Transkripte oder Notizen von Fachexperten

Die gesamte Datenerhebung muss Datenschutz-, Sicherheits- und Lizenzanforderungen erfüllen.

Rohinhalte in Instruction-Response-Paare umwandeln

Rohdaten aus einer Domäne müssen in überwachte Lernbeispiele umgewandelt werden, die dem Modell zeigen, wie es domänenspezifische Fragen beantworten soll.

Jedes Beispiel sollte eine realistische Aufgabe darstellen, die das Modell später bearbeiten soll.

Beispiel aus dem Finanzbereich:

Instruction: Explain EBITDA and its role in company valuation.

Response: EBITDA means earnings before interest, taxes, depreciation, and amortization. It is often used to assess a company’s operating performance.

Diese Umwandlung kann manuell, halbautomatisch mit LLM-Unterstützung oder programmatisch mit Validierungsprüfungen erfolgen.

Eine konsistente Prompt-Struktur verwenden

Einheitliche Formatierung ist entscheidend für stabiles Fine-Tuning. Eine standardisierte Prompt-Vorlage hilft dem Modell, Aufgabengrenzen und Antworterwartungen besser zu erkennen.

Empfohlenes Format für Instruction Tuning:

### Instruction:
<Task description>

### Input:
<Optional domain context>

### Response:
<Expected output>

Dieses Format ist breit kompatibel mit Alpaca-Style-, Dolly-Style- und LLaMA-basierten Fine-Tuning-Pipelines.

Domänendaten programmatisch formatieren

Sobald Instruction-Response-Paare vorbereitet sind, können sie in trainingsfähige Textbeispiele umgewandelt werden.

def format_domain_example(example):
    instruction = example["instruction"]
    context = example.get("context", "")
    response = example["response"]

    sections = [f"### Instruction:\n{instruction}"]

    if context.strip():
        sections.append(f"### Input:\n{context}")

    sections.append(f"### Response:\n{response}")

    return {"text": "\n".join(sections)}

Das entstehende „text“-Feld kann direkt tokenisiert und in Workflows für Supervised Fine-Tuning verwendet werden.

Datenqualität vor dem Fine-Tuning prüfen

Vor Trainingsbeginn sollte eine Stichprobe des Datensatzes manuell geprüft werden, um sicherzustellen, dass die Inhalte fachlich korrekt sind, die Anweisungen klar und eindeutig formuliert wurden und die Antworten eine hohe Qualität aufweisen.

Schon eine kleine Menge schlechter Daten kann das Verhalten eines Modells nach dem Fine-Tuning stark beeinflussen. Für weiterführende Informationen zu diesem Thema kann ein eigener Beitrag zu LLM Poisoning zusätzlichen Kontext liefern.

Eine passende Fine-Tuning-Strategie wählen

Für die meisten domänenspezifischen Anwendungsfälle bieten LoRA und QLoRA eine schnelle und kosteneffiziente Anpassung, während vollständiges Fine-Tuning maximale Leistung bei höheren Kosten ermöglichen kann.

Viele Teams erzielen starke Ergebnisse mit LoRA-basiertem Supervised Fine-Tuning, wenn der Datensatz sorgfältig kuratiert wurde. Ein separater Schritt-für-Schritt-Leitfaden kann verwendet werden, um zu lernen, wie LoRA-Fine-Tuning mit einem eigenen Datensatz funktioniert.

Domänenspezifische Fine-Tuning-Daten per Web Scraping erzeugen

Web Scraping kann eine praktische Möglichkeit sein, domänenspezifische Inhalte aus öffentlichen Dokumentationen, Blogs oder Wissensdatenbanken zu sammeln. Nach dem Scraping können die Rohtexte in Instruction-Response-Paare für Supervised Fine-Tuning umgewandelt werden.

Warnung: Prüfen Sie immer, ob eine Website Scraping erlaubt, und stellen Sie sicher, dass der Vorgang ethisch durchgeführt wird.

Schritt 1: Erforderliche Bibliotheken installieren

Verwenden Sie pip, um die benötigten Bibliotheken zu installieren.

pip install requests beautifulsoup4

Schritt 2: Inhalte mit Beautiful Soup auslesen

In diesem Beispiel werden Überschriften und Absätze aus einer technischen Dokumentationsseite gesammelt.

import requests
from bs4 import BeautifulSoup

def scrape_page(url):
    response = requests.get(url, timeout=10)
    response.raise_for_status()

    soup = BeautifulSoup(response.text, "html.parser")

    title = soup.find("h1")
    paragraphs = soup.find_all("p")

    content = {
        "title": title.get_text(strip=True) if title else "",
        "paragraphs": [
            p.get_text(strip=True)
            for p in paragraphs
            if len(p.get_text(strip=True)) > 100
        ]
    }

    return content

Schritt 3: Ausgelesene Inhalte in Instruction-Response-Paare umwandeln

Nach dem Scraping kann der Rohtext in Trainingsbeispiele umgewandelt werden, die für Instruction Tuning geeignet sind.

def create_instruction_data(scraped_content):
    instruction = (
        f"Explain the following topic in a clear and concise manner: "
        f"{scraped_content['title']}"
    )

    response = " ".join(scraped_content["paragraphs"])

    return {
        "instruction": instruction,
        "response": response
    }

Schritt 4: Daten für LLM Fine-Tuning formatieren

Zum Schluss werden die Instruction-Response-Paare in ein einzelnes Prompt-Feld formatiert.

def format_for_finetuning(example):
    text = (
        f"### Instruction:\n{example['instruction']}\n\n"
        f"### Response:\n{example['response']}"
    )
    return {"text": text}

Schritt 5: End-to-End-Beispiel

url = "https://www.example.com/tutorials/deploy-coreflux-mqtt-mongodb"

scraped = scrape_page(url)

instruction_data = create_instruction_data(scraped)
formatted_sample = format_for_finetuning(instruction_data)

print(formatted_sample["text"][:500])

### Instruction:
Explain the following topic in a clear and concise manner: Deploy Coreflux MQTT Broker with MongoDB on a cloud server

### Response:
MQTT brokers are essential for modern IoT infrastructure and automation systems, where a centralized, unified, and fast data hub is required for interoperability and data exchange. Coreflux is a powerful, low-code MQTT broker that expands the traditional MQTT broker into a system with advanced features for real-time data processing.

Synthetische Daten mit LLMs ohne kostenpflichtige APIs erzeugen

Das Sammeln und manuelle Labeln domänenspezifischer Daten kann teuer und zeitaufwendig sein. Eine praktische Alternative ist die synthetische Datengenerierung mit LLMs, bei der ein Modell realistische Instruction-Response-Paare in größerem Umfang erzeugt. Obwohl häufig kostenpflichtige APIs für synthetische Daten genutzt werden können, zeigt diese Pipeline, wie sich synthetische Customer-Support-Daten mit einem kostenlosen, lokal laufenden LLM von Hugging Face erstellen lassen, ohne API-Schlüssel oder kostenpflichtige Dienste zu benötigen.

Beispiel: Generator für synthetische Customer-Support-Daten

Das folgende Beispiel nutzt die Hugging Face transformers-Bibliothek mit dem schlanken Open-Source-Modell flan-t5-base, um Instruction-Response-Paare für Customer-Support-Szenarien zu erzeugen.

Abhängigkeiten installieren

pip install transformers torch

Python-Code: Synthetische Daten mit einem lokalen LLM erzeugen

import random
import json
from transformers import pipeline

class FreeSyntheticDataGenerator:
    def __init__(self):
        # Instruction-tuned model
        self.generator = pipeline(
            "text2text-generation",
            model="google/flan-t5-base"
        )

        self.templates = {
            "order_inquiry": [
                "Where is my order #{order_id}?",
                "Can you track order #{order_id}?",
                "What is the status of order #{order_id}?"
            ],
            "return_request": [
                "I want to return my {product}",
                "How do I get a refund for {product}?"
            ],
            "technical_support": [
                "My {device} is not turning on.",
                "I am facing error code {error_code} on {software}"
            ]
        }

        self.variables = {
            "order_id": ["12345", "67890", "ABC999"],
            "product": ["laptop", "phone", "headphones"],
            "device": ["laptop", "router", "tablet"],
            "software": ["Windows", "Android", "website"],
            "error_code": ["404", "E-001"]
        }

    def generate_examples(self, category, count=5):
        dataset = []

        for _ in range(count):
            instruction = random.choice(self.templates[category])

            for var, values in self.variables.items():
                instruction = instruction.replace(
                    f"{}", random.choice(values)
                )

            prompt = f"""
You are a professional customer support agent.
Respond clearly and concisely.
Customer query: {instruction}
"""

            response = self.generator(
                prompt,
                max_length=150,
                do_sample=False
            )[0]["generated_text"]

            dataset.append({
                "instruction": instruction,
                "output": response.strip(),
                "category": category
            })

        return dataset


if __name__ == "__main__":
    generator = FreeSyntheticDataGenerator()
    samples = generator.generate_examples("order_inquiry", 3)
    print(json.dumps(samples, indent=2))

Ausgabeformat für Fine-Tuning

Jedes generierte Beispiel folgt einer Instruction-Tuning-Struktur und eignet sich damit für Supervised Fine-Tuning (SFT):

[
  {
    "instruction": "What is the status of order #12345?",
    "output": "Order #12345 has been placed.",
    "category": "order_inquiry"
  },
  {
    "instruction": "What is the status of order #12345?",
    "output": "Your order is currently being processed and is expected to be delivered within the estimated delivery timeline.",
    "category": "order_inquiry"
  },
  {
    "instruction": "Where is my order #12345?",
    "output": "Where is your order #12345?",
    "category": "order_inquiry"
  }
]

Auch andere kostenlose Optionen können geprüft werden. Wenn kostenpflichtige API-Angebote genutzt werden, können sie häufig eine qualitativ hochwertigere synthetische Datengenerierung und zusätzliche Möglichkeiten bieten. Beispiele sind:

Kostenpflichtige APIs können für synthetische Datengenerierung manchmal besser geeignet sein, weil sie häufig große instruction-optimierte Modelle verwenden, die speziell darauf trainiert wurden, Prompts präzise zu befolgen und strukturierte, hochwertige Antworten zu erzeugen.

Im Vergleich zu kostenlosen oder Basis-Modellen verstehen kostenpflichtige APIs Absicht, Rollenangaben und Formatierungsanforderungen meist zuverlässiger. Dadurch entstehen Ausgaben, die über viele Beispiele hinweg kohärent, relevant und konsistent sind. Halluzinationen, Wiederholungen und themenfremde Inhalte werden reduziert, sodass die generierten Daten vor dem Fine-Tuning oft weniger manuell bereinigt werden müssen.

Kostenpflichtige APIs übernehmen außerdem Skalierbarkeit, Zuverlässigkeit und Performance automatisch. Dadurch können Teams große Mengen synthetischer Daten schnell erzeugen, was sie für produktionsreife Datensätze zu einer effizienten Option machen kann.

Warum Datenqualität wichtiger ist als Datenmenge

Ein häufiger Fehler beim Fine-Tuning besteht darin, die Größe des Datensatzes höher zu bewerten als seine Qualität. Große Mengen verrauschter, repetitiver oder unklarer Beispiele können die Modellleistung verschlechtern. Ein kleinerer Datensatz mit sauberen Anweisungen und präzisen Antworten erzielt dagegen häufig deutlich bessere Ergebnisse.

Hochwertige Fine-Tuning-Daten weisen mehrere klare Merkmale auf. Jedes Beispiel behandelt genau eine Absicht, die Antwort ist vollständig und zugleich knapp, der Ton bleibt im gesamten Datensatz konsistent und Widersprüche oder halluzinierte Fakten werden vermieden. Doppelte oder nahezu doppelte Beispiele sollten entfernt werden, sofern Wiederholung nicht bewusst zur Verstärkung eingesetzt wird.

Als allgemeine Orientierung reichen oft einige Tausend sorgfältig kuratierte Beispiele für Domain Adaptation und Verhaltenssteuerung aus. Zehntausende Beispiele werden meist erst benötigt, wenn eine sehr tiefe Spezialisierung oder eine besonders breite Aufgabenabdeckung angestrebt wird.

FAQs

Wie viele Daten werden für das Fine-Tuning eines LLM benötigt?

Die benötigte Datenmenge hängt von der Fine-Tuning-Methode und der Aufgabe ab. Mit parameter-effizienten Methoden wie LoRA oder QLoRA lassen sich häufig bereits mit etwa 500 bis 5.000 hochwertigen Instruction-Response-Paaren starke Ergebnisse erzielen. Vollständiges Modell-Fine-Tuning erfordert meist deutlich größere Datensätze, oft Zehntausende oder Hunderttausende Beispiele. In den meisten Fällen sind Qualität und Relevanz wichtiger als reine Menge.

Kann ich ein LLM ausschließlich mit synthetischen Daten feinabstimmen?

Ja. Ein LLM kann ausschließlich mit synthetischen Daten feinabgestimmt werden, insbesondere wenn der Anwendungsfall klar definiert ist, beispielsweise Support-Automatisierung, Zusammenfassungen oder domänenspezifisches Question Answering. Die besten Ergebnisse werden meist mit synthetischen Beispielen erzielt, die von instruktionsoptimierten Modellen erzeugt und anschließend durch automatisierte Prüfungen sowie menschliche Qualitätskontrollen validiert werden. In der Praxis werden synthetische und reale Daten häufig kombiniert, doch sorgfältig aufbereitete synthetische Datensätze können auch allein sehr effektiv sein.

Welches Datenformat eignet sich am besten für das Fine-Tuning von LLMs?

JSONL (JSON Lines) gilt in der Regel als bevorzugtes Format. Jede Zeile enthält ein einzelnes Trainingsbeispiel, wodurch sich Datensätze effizient verarbeiten und skalieren lassen. Beim Instruction Tuning enthalten die Einträge häufig Felder wie instruction und output. JSONL wird von Hugging Face, PEFT, LoRA, QLoRA und vielen weiteren Fine-Tuning-Workflows direkt unterstützt.

Wie lange dauert die Datenaufbereitung?

Die benötigte Zeit hängt vor allem von Umfang und Komplexität des Datensatzes ab. Kleinere bis mittelgroße Datensätze mit etwa 1.000 bis 5.000 Beispielen können inklusive Bereinigung und Validierung innerhalb weniger Stunden bis einiger Tage vorbereitet werden. Größere Datensätze oder hochspezialisierte Fachgebiete erfordern oft mehrere Tage oder sogar Wochen, insbesondere wenn eine manuelle Qualitätsprüfung notwendig ist. Automatisierung kann den Aufwand dabei erheblich reduzieren.

Wie häufig sollten Fine-Tuning-Daten aktualisiert werden?

Fine-Tuning-Datensätze sollten immer dann aktualisiert werden, wenn sich die Domäne, das Nutzerverhalten oder die Anforderungen verändern. Bei Produkten oder Support-Umgebungen mit häufigen Änderungen sind Aktualisierungen im Abstand von einigen Wochen oder Monaten oft sinnvoll. Regelmäßige Aktualisierungen helfen dabei, die Genauigkeit aufrechtzuerhalten, Model Drift zu reduzieren und das Modell an neue Begriffe, Richtlinien und Nutzererwartungen anzupassen.

Fazit

Die Vorbereitung hochwertiger Daten ist einer der wichtigsten Schritte für erfolgreiches LLM Fine-Tuning. Obwohl Modellauswahl und Trainingsmethoden häufig im Mittelpunkt stehen, bestimmen letztlich Qualität, Struktur und Relevanz der Daten, wie gut ein feinabgestimmtes Modell funktioniert. Eine starke Datenpipeline mit Erfassung, Bereinigung, Validierung, Bias-Prüfungen und menschlicher Kontrolle sorgt dafür, dass das Modell das richtige Verhalten lernt und zuverlässige, ausgerichtete Antworten erzeugt.

Wie dieser Beitrag zeigt, muss Datenvorbereitung nicht ausschließlich von teuren oder schwer zugänglichen Datensätzen abhängen. Synthetische Daten, die mit instruction-optimierten LLMs erzeugt und mit geeigneten Qualitätskontrollen kombiniert werden, können für viele Fine-Tuning-Szenarien eine effektive und skalierbare Lösung sein. Durch den Export in standardisierten Formaten und regelmäßige Aktualisierung bei veränderten Anforderungen können Teams Fine-Tuning-Workflows aufbauen, die effizient und zukunftssicher sind. Letztlich führt die Investition in gute Datenvorbereitung zu stabileren Modellen, besserer Generalisierung und stärkerer Leistung in realen Anwendungen.