LLM Fine-Tuning mit eigenen Daten – Ein Praxisleitfaden

Dieser Leitfaden zeigt Ihnen, wie Sie ein großes Sprachmodell (LLM) gezielt an Ihre Anforderungen anpassen können. Von der Einführung in die Low-Rank-Adaption bis zur effizienten Datenvorbereitung und Bereitstellung erhalten Sie eine klare Anleitung, um ein Modell aufzubauen, das Ihre spezifischen Bedürfnisse erfüllt.

Schritt für Schritt lernen Sie, moderne Methoden wie LoRA zu nutzen, mit minimalem Ressourcenaufwand zu arbeiten und ein leistungsfähiges, individuelles Modell zu entwickeln. Ob für Ihr Unternehmen oder Ihre eigenen Projekte – dieser Leitfaden bietet Ihnen eine praktische und nachvollziehbare Grundlage.

Mit diesen klaren Anweisungen sind Sie in der Lage, ein LLM eigenständig zu optimieren und Ihre Anwendungsideen erfolgreich umzusetzen. Starten Sie mit einem Modell, das auf Ihre Anforderungen zugeschnitten ist.

Warum ein Fahrzeugschein als Beispiel?

Ein Fahrzeugschein (Zulassungsbescheinigung Teil 1) mag auf den ersten Blick unscheinbar wirken, er stellt jedoch in der Praxis eine beeindruckend komplexe Herausforderung dar. Dieses Dokument enthält zahlreiche strukturierte Datenpunkte in einem klar definierten Format: von der Fahrzeug-Identifizierungsnummer (FIN) über das Erstzulassungsdatum bis zu technischen Daten wie Gesamtmasse, Hubraum oder CO₂-Werten. Neben allen anderen Dokumenten kann Konfuzio IDP einen Fahrzeugschein auslesen und darin enthaltene Daten automatisch validieren.

Auch das Layout des Fahrzeugscheins ist anspruchsvoll: Die Daten sind auf engstem Raum verteilt, begleitet von beschreibenden Schlüsselnummern und teilweise fälschungssicheren Elementen. Hinzu kommen variable Schreibweisen oder Abkürzungen bei Hersteller- und Typbezeichnungen, die die korrekte Extraktion zusätzlich erschweren. Besonders schwierig wird es bei schlecht belichteten Scans oder Bildern, die aus ungünstigen Winkeln aufgenommen wurden – Herausforderungen, bei denen herkömmliche OCR-Systeme oft scheitern.

Wieso ist der Fahrzeugschein komplex?

• Hohes Datenvolumen: Viele relevante Informationen müssen identifiziert, extrahiert und in korrektes Verhältnis zueinander gebracht werden.
• Unterschiedliche Formatierungen: Elemente wie Tabellen, Felder und Zeilenumbrüche variieren leicht je nach Ausstellung.
• Fälschungsschutz: Sicherheitsmerkmale wie Hologramme, spezielle Farbprägungen oder Schattierungen erschweren die Texterkennung.
• Präzision erforderlich: Die extrahierten Daten dürfen keine Fehler enthalten; selbst ein zusätzlicher Buchstabe in der FIN besitzt gravierende Konsequenzen.

Mit einem Fahrzeugschein können wir exemplarisch zeigen, wie ein LLM so abgestimmt werden kann, dass es diese komplexen Datenstrukturen sicher und präzise verarbeitet. Das Ziel ist es, ein System zu schaffen, das selbst unter schwierigen Bedingungen leistungsfähig bleibt – präzise, skalierbar und robust.

Anleitung: LLM auf eigene Daten abstimmen

Was macht Low-Rank-Adaption?

Low-Rank Adaptation ist eine effiziente Methode zum Fine-Tuning großer Sprachmodelle. Statt alle Modellgewichte zu verändern, werden nur gezielte, kompakte Anpassungen vorgenommen – in einem reduzierten Unterraum der ursprünglichen Parameter. Dadurch bleibt die Leistung des Modells erhalten, während der Ressourcenverbrauch deutlich sinkt. Weniger Speicher, kürzere Trainingszeiten, weniger Rechenlast – ideal für produktionsnahe Anwendungen oder Edge-Deployments.

Warum QLoRA?

QLoRA kombiniert Low-Rank Adaptation mit quantisierter Speicherung – also einer extrem kompakten Repräsentation der Modellgewichte. Das ermöglicht es, selbst große Modelle auf begrenzter Hardware effizient zu betreiben, z. B. auf einem einzelnen GPU-Server oder sogar lokal. Für Entwickler bedeutet das: kein vollständiges Fine-Tuning, keine High-End-Infrastruktur, aber dennoch starke Ergebnisse. QLoRA reduziert die Hürden bei der Modellanpassung – bei gleichbleibender Leistung.

Einsatzbereiche

QLoRA ist der perfekte Partner für jedes Projekt, das genau zugeschnittene Sprachmodelle benötigt. Sei es im lokalen Betrieb, für spezifische Workflows oder für datenschutzsensible Aufgaben. Kein Ausbau von unnötigen Systemen, keine Verschwendung von Ressourcen. Nur Präzision – für heute und morgen.

Daten aufbereiten nutzen

Um ein zuverlässiges Extraktionsmodell zu trainieren, müssen unstrukturierte Dokumente in strukturierte Daten überführt werden. Konfuzio unterstützt diesen Prozess in mehreren Schritten:

1. Labels und Kategorien definieren – z. B. Datum, Fahrzeugtyp oder Kennzeichen.
2. Texte annotieren – markieren Sie relevante Textstellen und ordnen Sie sie den entsprechenden Labels zu.
3. Qualitätssicherung durchführen – prüfen Sie die Annotationen auf Vollständigkeit und Korrektheit und korrigieren Sie bei Bedarf.

Konfuzio wandelt Dokumente so in strukturierte, maschinenlesbare Daten um – eine zentrale Grundlage für das Training und den produktiven Einsatz von KI-Modellen zur Informationsextraktion.

Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.
Mehr erfahren

Video laden

YouTube immer entsperren

Ein Datensatz, bei dem bestimmte Informationen (z. B. „Datum der Zulassung“) sicher markiert und exportierbar sind.

Vom Text zum Trainingsdatensatz

Anforderungen an den Eingabedatensatz

Ein Modell benötigt strukturierte Vorgaben, um trainiert werden zu können. Standardformate enthalten:

• Beschreibung der Aufgabe (Instruction).
• Den Eingabetext (Input).
• Ein Beispiel für die Antwort (Output).

Datenformatierung automatisieren

Mit einem Python-Skript übertragen Sie die annotierten Daten aus Konfuzio in ein trainingsfähiges Format. Beispielcode:

import json
from copy import deepcopy
from konfuzio_sdk.data import Project
# Projekt und Kategorie laden (IDs z. B. aus der Weboberfläche)
project = Project(id_="DEIN_PROJEKT_ID", update=True)
category = project.get_category_by_id("DEINE_KATEGORIE_ID")
for (name, documents) in [("train", category.documents()), ("test", category.test_documents())]:
    dataset = []
    for doc in documents:
        copy_doc = deepcopy(doc)
        entry = {
            "instruction": "Extrahiere Informationen aus Dokumenten.",
            "input": copy_doc.text,
            "output": {label.name: ann.offset_string[0] for label in doc.labels for ann in doc.annotations() if ann.label.id == label.id},
            "id": copy_doc.id_
        }
        dataset.append(entry)
    with open(f"{name}_dataset.json", "w", encoding="utf-8") as f:
        json.dump(dataset, f, indent=4, ensure_ascii=False)

Nach der Ausführung haben Sie eine JSON-Datei, z. B.:

{
    "instruction": "Extrahiere Kennzeichen und Zulassungsdaten.",
    "input": "1. Kennzeichen: B-MW123...",
    "output": {
        "Kennzeichen": "B-MW123",
        "Zulassungsdatum": "01.01.2020"
    },
    "id": "abc123"
}

Wir verwenden Instruktion im Alpaca Format.

# Definition der ALPACA-Prompt-Vorlage
alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
### Instruction:
{}
### Input:
{}
### Response:
{}"""
EOS_TOKEN = tokenizer.eos_token  # Sicherstellen, dass das EOS-Token angehängt wird

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs = examples["input"]
    outputs = examples["output"]
    texts = []
    for instruction, input_text, output in zip(instructions, inputs, outputs):
        text = alpaca_prompt.format(instruction, input_text, output) + EOS_TOKEN
        texts.append(text)
    return {"text": texts}

Diese Datei kann nun geladen werden.

import json
import random
import pandas as pd
from datasets import Dataset
from transformers import AutoTokenizer
file_path = "train_dataset.json"  # Pfad zur Datei (bei Bedarf anpassen)
with open(file_path, "r", encoding="utf-8") as f:
    dataset = json.load(f)
# In ein Pandas DataFrame umwandeln
random.shuffle(dataset)
df = pd.DataFrame(dataset)
# Formatierung anwenden
hf_dataset = Dataset.from_pandas(df)
dataset = hf_dataset.map(formatting_prompts_func, batched=True)

Modell anpassen

Vorgehen beim Finetuning

Beim Finetuning benötigen Sie:

1. Ein Basis-Modell (z. B. Llama- oder Mistral-Reihe).
2. Ein Trainingswerkzeug, wie das Hugging Face Framework.
3. Formatierte Daten aus Schritt 3.

Training mit LoRA

LoRA ist effizient, weil nur spezifische Modellbereiche verändert werden. Schritte:

• Adapter konfigurieren.
• Daten laden.
• Parameter wie Batchgröße und Lernrate festlegen.
• Training ausführen.

Beispiel:

import torch
from unsloth import FastLanguageModel
# Lade das ursprüngliche Modell
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Llama-3.2-3B-Instruct",
    max_seq_length = 4096,
    dtype = None,
    load_in_4bit = True,
)
# Füge QLoRA hinzu
model = FastLanguageModel.get_peft_model(
    model,
    r = 128,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 32,
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,
    loftq_config = None,
)
from transformers import TrainingArguments, Trainer
training_args = TrainingArguments(
    output_dir="./results",
    per_device_train_batch_size=4,
    num_train_epochs=5,
    learning_rate=2e-4,
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=formatted_data,
)
trainer.train()
model.save_pretrained("finetuned_model") 
tokenizer.save_pretrained("finetuned_model")

Das Modell wird so angepasst, dass es spezifische Aufgaben Ihrer Daten effizient bearbeiten kann.

Fazit

Das hier beschriebene System demonstriert eindrucksvoll, was durch optimiertes LLM-Finetuning und moderne Techniken erreichbar ist. Mit gerade einmal 4 GB VRAM wird eine beeindruckende Leistungsfähigkeit erzielt:

• 99,57 % F1-Score: Ein Maß für Genauigkeit und Präzision, gemessen auf zeichen-genauer Ebene – ein Niveau, das selbst bei anspruchsvollen Dokumenten höchste Verlässlichkeit bietet.
• 1,5 Sekunden pro Dokument: Eine Verarbeitungsgeschwindigkeit, die nicht nur effizient, sondern skalierbar ist.

Dieses Setup zeigt, wie KI-basierte Datenverarbeitung selbst unter beschränkten Ressourcen produktionsreif ist – ohne Kompromisse bei Qualität oder Geschwindigkeit.