LoRA Fine-Tuning für Large Language Models mit eigenen Daten
Large Language Models haben die Entwicklung von Anwendungen, die Erstellung von Inhalten und die Automatisierung alltäglicher Aufgaben deutlich verändert. Dennoch sind selbst leistungsstarke LLMs in erster Linie als allgemein einsetzbare Systeme konzipiert. Standardmäßig kennen sie keine internen Dokumentationen, keine individuelle Markenstimme und kein unternehmensspezifisches Wissen. Prompt Engineering kann die Ergebnisse zwar bis zu einem gewissen Punkt verbessern, doch mit wachsenden Anforderungen werden Prompts häufig lang, empfindlich und uneinheitlich.
Eine Möglichkeit besteht darin, ein eigenes Modell mit eigenen Daten zu trainieren. Ein praktischerer Ansatz ist das Fine-Tuning eines bestehenden Modells. Model Fine-Tuning ermöglicht es, das Verhalten eines Modells anhand von Beispielen gezielt anzupassen. Unter den modernen Fine-Tuning-Methoden hat sich LoRA als eine der praktischsten und kosteneffizientesten Optionen etabliert, um einem LLM neues Verhalten oder neue Aufgabenmuster beizubringen.
Dieser Artikel erklärt, was LoRA ist, was LoRA Fine-Tuning tatsächlich bedeutet und zeigt eine vollständige Umsetzung mit eigenen Daten, inklusive Codebeispielen und praxisnaher Hinweise.
Wichtige Erkenntnisse
- LoRA ermöglicht parameter-effizientes Fine-Tuning, indem das Basismodell eingefroren wird und nur eine kleine Anzahl von Low-Rank-Adaptergewichten trainiert wird. Dadurch sinken Rechen- und Speicherbedarf erheblich.
- Der Ansatz erhält die allgemeine Denk- und Schlussfolgerungsfähigkeit großer Sprachmodelle, während Verhalten, Tonalität und Struktur an einen bestimmten Anwendungsbereich angepasst werden.
- LoRA Fine-Tuning eignet sich besonders für Verhaltens- und Aufgabenanpassungen, weniger jedoch für das Einbringen großer Mengen neuen Faktenwissens.
- Gut strukturierte, hochwertige Datensätze haben meist einen größeren Einfluss auf die Leistung von LoRA als die reine Größe des Datensatzes.
- LoRA-Adapter sind leichtgewichtig und modular, sodass mehrere domänenspezifische Verhaltensweisen mit nur einem Basismodell verwaltet werden können.
- LoRA lässt sich gut mit retrieval-basierten Methoden wie RAG kombinieren. Dadurch entstehen skalierbare Systeme, die gelerntes Verhalten mit dynamischem Zugriff auf Wissen verbinden.
- Die niedrigen Kosten und kurzen Iterationszyklen machen LoRA besonders geeignet für Experimente, Prototypen und produktive Einsätze.
LoRA im Detail verstehen
LoRA steht für Low-Rank Adaptation und bezeichnet eine parameter-effiziente Fine-Tuning-Methode, die speziell für große neuronale Netzwerke wie Transformer-Modelle entwickelt wurde. Beim klassischen Fine-Tuning werden alle Modellgewichte aktualisiert. Bei Modellen mit Milliarden von Parametern ist das sehr rechenintensiv und benötigt viel Speicher. LoRA umgeht dieses Problem, indem die ursprünglichen Modellgewichte unverändert bleiben und nur eine kleine Anzahl neuer trainierbarer Parameter ergänzt wird, die lernen, das Verhalten des Modells anzupassen.
In Transformer-Modellen entsteht ein großer Teil der Lernfähigkeit durch umfangreiche Matrixmultiplikationen, vor allem in den Attention-Layern. LoRA nähert die Aktualisierung dieser großen Matrizen mithilfe von zwei deutlich kleineren Matrizen an. Das Produkt dieser kleineren Matrizen beschreibt die Veränderung, die für die jeweilige Aufgabe notwendig ist.
Da diese Matrizen einen niedrigen Rang besitzen, reduziert sich die Anzahl der zu trainierenden Parameter drastisch. Das Basismodell bleibt unverändert und behält sein allgemeines Wissen, während die LoRA-Layer es auf eine neue Aufgabe oder Domäne spezialisieren.
Ein besonders großer Vorteil von LoRA ist die Modularität der Anpassungen. Ein einziges Basismodell kann mehrere LoRA-Adapter nutzen, die jeweils für unterschiedliche Zwecke trainiert wurden. Diese Adapter können ausgetauscht werden, ohne das komplette Modell erneut zu trainieren oder neu bereitzustellen.
Was LoRA Fine-Tuning wirklich bedeutet
LoRA Fine-Tuning bedeutet, dass ausschließlich die LoRA-Adapter-Layer mit einem eigenen Datensatz trainiert werden, während das zugrunde liegende Sprachmodell eingefroren bleibt. Statt dem Modell alles von Grund auf neu beizubringen, wird es durch gezielte Beispiele in eine bestimmte Verhaltensrichtung gelenkt. Dabei wird verändert, wie das Modell Informationen in wichtigen Schichten verarbeitet. Dieser Ansatz ist besonders nützlich, wenn Schreibstil, Antwortstruktur, Tonalität oder domänenspezifisches Verständnis angepasst werden sollen, ohne große Mengen neuen Faktenwissens einzubringen.
Beim Fine-Tuning mit LoRA lernt das Modell Muster aus den bereitgestellten Beispielen und speichert diese in den Adaptergewichten. Während der Inferenz kombiniert das Modell seine ursprünglichen Fähigkeiten mit den gelernten Anpassungen. Das Ergebnis sind Antworten, die zur Ziel-Domäne passen und gleichzeitig die allgemeine Schlussfolgerungsfähigkeit des Modells erhalten.
Das unterscheidet sich grundlegend von retrieval-basierten Ansätzen wie RAG, bei denen externe Dokumente zur Laufzeit abgerufen werden. LoRA Fine-Tuning verändert, wie sich das Modell verhält, während RAG verändert, auf welche Informationen das Modell zugreifen kann.
Eigene Daten für LoRA Fine-Tuning vorbereiten
Die Qualität eines mit LoRA feinabgestimmten Modells hängt stark von der Qualität der Trainingsdaten ab. Da LoRA mit einer geringeren Anzahl trainierbarer Parameter arbeitet, reagiert es besonders empfindlich auf inkonsistente, verrauschte oder schlecht strukturierte Beispiele. Am effektivsten sind Datensätze, die als Instruction-Response-Paare oder Chatverläufe aufgebaut sind und möglichst genau widerspiegeln, wie das Modell später in der Praxis genutzt werden soll.
Jedes Beispiel sollte klar zeigen, welches Verhalten das Modell lernen soll. Geht es um Zusammenfassungen, Erklärungen oder domänenspezifisches Schreiben, sollten die Ausgaben in Tonalität, Länge und Aufbau einheitlich sein. Wiederholte oder widersprüchliche Beispiele sollten vermieden werden, da sie den Adapter verwirren und die Generalisierungsfähigkeit verschlechtern können.
Praxisbeispiel: LoRA Fine-Tuning von Qwen mit einem eigenen Datensatz
In diesem Abschnitt wird ein Qwen-Instruct-Modell mit LoRA feinabgestimmt, um Wissen rund um eine allgemeine Cloud-Infrastrukturumgebung zu vermitteln. Ziel ist es, dass das Modell Support-Fragen zu GPU-fähigen virtuellen Maschinen, SSH-Zugriff und VS-Code-Workflows beantworten kann, ohne das vollständige Modell neu zu trainieren.
Dafür wird ein schlanker JSON-Datensatz verwendet. Trainiert wird nur eine kleine Menge an Parametern mithilfe von LoRA. Dadurch bleibt der Ansatz effizient, selbst wenn er auf einem einzelnen GPU-fähigen Cloud-Server ausgeführt wird.
Datensatzformat definieren
Qwen funktioniert gut mit einem einfachen Causal-Language-Modeling-Format, bei dem jedes Beispiel aus einem Prompt und der erwarteten Completion besteht. Jede Trainingsprobe muss genau zwei Schlüssel enthalten: prompt und completion.
Hier ist ein Beispiel für einen eigenen Datensatz, der als cloud-support.json gespeichert wird:
{
"prompt": "Was ist eine GPU-fähige virtuelle Cloud-Maschine?",
"completion": "Eine GPU-fähige virtuelle Cloud-Maschine ist ein Cloud-Server mit NVIDIA-GPUs, der für rechenintensive Workloads wie Machine-Learning-Training, Deep-Learning-Inferenz und umfangreiche Datenverarbeitung ausgelegt ist."
}
Ein weiteres Beispiel kann so aussehen:
{
"prompt": "Warum kann ich mich nicht per SSH mit meinem GPU-fähigen Cloud-Server verbinden?",
"completion": "SSH-Verbindungsprobleme entstehen häufig durch falsche Benutzernamen, fehlende SSH-Schlüssel oder Firewall-Regeln, die Port 22 blockieren. In der Regel hilft es, den Serverstatus und die SSH-Konfiguration zu prüfen."
}
Dieses Format hilft dem Modell, natürliche Antworten auf Nutzerfragen zu lernen. Dadurch eignet es sich besonders gut für Assistenten im Stil eines Kundensupports.
Datensatz laden
Nachdem der Datensatz vorbereitet wurde, kann er mit der Hugging Face datasets-Bibliothek geladen werden.
from datasets import load_dataset
dataset = load_dataset(
"json",
data_files="cloud-support.json"
)
print(dataset["train"][0])
Zu diesem Zeitpunkt liegen die einzelnen Einträge noch als Rohtext vor und müssen vor dem Training tokenisiert werden.
Tokenisierung und Vorverarbeitung
Qwen-Modelle benötigen tokenisierte Eingaben, bei denen das Modell das nächste Token innerhalb einer Sequenz vorhersagt. Dafür werden Prompt und Completion zu einem einzigen Trainingsstring zusammengeführt. Dieselben Tokens werden anschließend auch als Labels verwendet.
from transformers import AutoTokenizer
model_name = "Qwen/Qwen2.5-3B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
def preprocess(example):
combined_text = example["prompt"] + "\n" + example["completion"]
tokens = tokenizer(
combined_text,
max_length=256,
padding="max_length",
truncation=True
)
tokens["labels"] = tokens["input_ids"].copy()
return tokens
tokenized_data = dataset.map(preprocess)
Wenn die Labels den Input IDs entsprechen, wird das Modell in einem Causal-Language-Modeling-Setup trainiert. Es lernt dabei, auf Basis des Prompts die passende Completion zu erzeugen.
Basismodell von Qwen laden
Als Nächstes wird das Qwen-Basismodell in halber Präzision geladen, um den GPU-Speicherbedarf zu reduzieren. Das ist besonders hilfreich, wenn mit einem einzelnen GPU-fähigen Cloud-Server gearbeitet wird.
import torch
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.float16,
device_map="auto"
)
In diesem Zustand ist das Modell noch unverändert und wurde noch nicht an die eigenen Daten oder die gewünschte Support-Domäne angepasst.
LoRA-Adapter hinzufügen
Statt alle Modellparameter zu trainieren, werden LoRA-Adapter an die Attention-Layer angehängt. Diese Adapter sind während des Trainings die einzigen trainierbaren Bestandteile.
from peft import LoraConfig, get_peft_model, TaskType
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=8,
lora_alpha=16,
lora_dropout=0.05,
target_modules=["q_proj", "k_proj", "v_proj"]
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
Durch diesen Schritt sinkt die Anzahl der trainierbaren Parameter normalerweise auf deutlich weniger als ein Prozent der ursprünglichen Modellgröße.
LoRA-Adapter trainieren
Sobald der Datensatz vorbereitet und LoRA konfiguriert ist, kann das Training beginnen. Die folgende Trainingskonfiguration ist bewusst einfach gehalten und eignet sich gut für kleine bis mittelgroße Datensätze.
from transformers import TrainingArguments, Trainer
training_args = TrainingArguments(
output_dir="./qwen-cloud-lora",
num_train_epochs=8,
per_device_train_batch_size=2,
gradient_accumulation_steps=8,
learning_rate=2e-4,
logging_steps=20,
fp16=True,
save_strategy="epoch",
report_to="none"
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_data["train"]
)
trainer.train()
Je nach Datensatzgröße und Sequenzlänge ist das Training auf einer GPU mit 16 GB VRAM häufig innerhalb weniger Minuten abgeschlossen.
Feinabgestimmten Adapter speichern
Nach Abschluss des Trainings werden nur der LoRA-Adapter und der Tokenizer gespeichert. Dadurch bleibt das Ergebnis leichtgewichtig und einfach bereitzustellen.
model.save_pretrained("./qwen-cloud-lora")
tokenizer.save_pretrained("./qwen-cloud-lora")
Das Basismodell bleibt unverändert und kann mit weiteren Adaptern wiederverwendet werden.
Feinabgestimmtes Modell für die Inferenz laden
Um das feinabgestimmte Modell zu verwenden, wird das Basismodell erneut geladen und anschließend mit dem trainierten LoRA-Adapter verbunden.
from peft import PeftModel, PeftConfig
adapter_path = "./qwen-cloud-lora"
config = PeftConfig.from_pretrained(adapter_path)
base_model = AutoModelForCausalLM.from_pretrained(
config.base_model_name_or_path,
torch_dtype=torch.float16,
device_map="auto"
)
model = PeftModel.from_pretrained(base_model, adapter_path)
tokenizer = AutoTokenizer.from_pretrained(adapter_path)
Dem feinabgestimmten Modell eine Frage stellen
Das Modell kann nun Fragen auf Grundlage des eigenen Datensatzes beantworten, selbst wenn diese Fragen nicht explizit Teil des ursprünglichen Pretrainings waren.
inputs = tokenizer(
"Wie verbindet sich VS Code mit einer GPU-fähigen virtuellen Cloud-Maschine?",
return_tensors="pt"
).to(model.device)
outputs = model.generate(
input_ids=inputs["input_ids"],
attention_mask=inputs["attention_mask"],
max_new_tokens=150
)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
VS Code verbindet sich mit einer GPU-fähigen virtuellen Cloud-Maschine per SSH über die Remote-SSH-Erweiterung.
Nach der Installation der Erweiterung wird ein SSH-Host konfiguriert, der auf die öffentliche IP-Adresse des Servers und den passenden Authentifizierungsschlüssel verweist.
Sobald die Verbindung hergestellt ist, führt VS Code Befehle direkt auf der entfernten Maschine aus. Dadurch können Dateien bearbeitet, Trainingsskripte gestartet und GPU-Workloads überwacht werden, als wäre die Umgebung lokal verfügbar.
Die Antwort spiegelt die Tonalität, Klarheit und technische Ausrichtung wider, die aus dem eigenen Datensatz gelernt wurden.
LoRA, also Low-Rank-Adaptation-Fine-Tuning, funktioniert am besten, wenn der Datensatz zur tatsächlichen Nutzung passt. Ist der Trainingsdatensatz zu klein, widersprüchlich oder fehlerhaft, kann das Modell überanpassen oder instabile Antworten erzeugen. Die Qualität der Trainingsdaten bestimmt direkt, was das Modell lernt und wie zuverlässig es später arbeitet.
Die Anpassung von Rang, Lernrate und Anzahl der Epochen kann die Ergebnisse deutlich verbessern. Solche Änderungen sollten jedoch immer mit Testbeispielen überprüft werden. In vielen produktiven Systemen wird LoRA mit RAG kombiniert, um Verhaltensanpassung mit aktueller faktischer Genauigkeit zu verbinden.
FAQs
Ist LoRA Fine-Tuning dasselbe wie vollständiges Fine-Tuning?
Nein, LoRA Fine-Tuning unterscheidet sich deutlich vom vollständigen Fine-Tuning. Beim vollständigen Fine-Tuning werden alle Modellparameter aktualisiert, was teuer und häufig nicht notwendig ist. Beim LoRA Fine-Tuning bleibt das Basismodell eingefroren, und nur eine kleine Anzahl zusätzlicher Parameter wird trainiert. Dadurch wird der Prozess schneller, günstiger und stabiler, während trotzdem eine starke Anpassung an eine Domäne möglich bleibt.
Wie viele Daten werden für LoRA Fine-Tuning benötigt?
LoRA kann bereits mit einem vergleichsweise kleinen Datensatz sinnvolle Ergebnisse liefern, oft mit einigen hundert hochwertigen Beispielen. Entscheidend ist weniger die Datenmenge, sondern vielmehr deren Konsistenz und Relevanz. Sorgfältig kuratierte Beispiele, die echte Nutzungsszenarien abbilden, sind deutlich wirksamer als große, verrauschte Datensätze.
Kann LoRA neues Faktenwissen in ein Modell einbringen?
LoRA ist nicht die beste Methode, um große Mengen neuen Faktenwissens in ein Modell einzubringen. Der Ansatz eignet sich besser, um Stil, Tonalität, Aufgabenstruktur und domänenspezifisches Schlussfolgern zu trainieren. Für große oder häufig wechselnde Faktenbestände ist Retrieval-Augmented Generation meist die bessere Lösung.
Welche Modelle funktionieren besonders gut mit LoRA?
LoRA funktioniert gut mit den meisten transformer-basierten kausalen Sprachmodellen, darunter Qwen, LLaMA, Mistral und DeepSeek. Besonders einfach lassen sich Modelle anpassen, deren Attention-Projection-Layer klar definiert sind, da diese Layer häufig als Zielmodule für Low-Rank-Adapter verwendet werden.
Beeinflusst LoRA die Inferenzgeschwindigkeit?
LoRA verursacht während der Inferenz nur einen sehr geringen zusätzlichen Aufwand. Da die Adapter klein sind und nur einen Teil der Berechnungen verändern, ist der Leistungseinfluss im Vergleich zum Basismodell meist minimal. In vielen Fällen bleibt die Inferenzgeschwindigkeit nahezu unverändert.
Können mehrere LoRA-Adapter mit einem Basismodell genutzt werden?
Ja. Eine der größten Stärken von LoRA ist der modulare Aufbau. Für unterschiedliche Domänen oder Aufgaben können mehrere Adapter gepflegt und dynamisch auf dasselbe Basismodell geladen werden. Dadurch müssen nicht mehrere vollständige Modell-Checkpoints gespeichert oder bereitgestellt werden.
Wie lässt sich prüfen, ob LoRA Fine-Tuning erfolgreich war?
Die Bewertung sollte sich auf aufgabenspezifische Ergebnisse konzentrieren und nicht nur auf allgemeine Benchmarks. Besonders hilfreich ist es, Antworten vor und nach dem Fine-Tuning zu vergleichen, zurückgehaltene Testbeispiele zu nutzen und die Konsistenz des gewünschten Verhaltens zu überprüfen.
Eignet sich LoRA für produktive Systeme?
Ja, LoRA eignet sich gut für den produktiven Einsatz. Der geringe Speicherbedarf, die kurze Trainingsdauer und das modulare Bereitstellungsmodell machen es einfacher, Modelle zu versionieren, zu überwachen und zu aktualisieren als vollständig feinabgestimmte Modelle.
Fazit
LoRA Fine-Tuning ist eine der einfachsten und kosteneffizientesten Möglichkeiten, ein Modell an eigene Daten anzupassen. Statt Fine-Tuning als teuren und riskanten Prozess zu betrachten, macht LoRA daraus einen schlanken und wiederholbaren Workflow, der gut in moderne Entwicklungsprozesse passt. Da das Basismodell unverändert bleibt und nur das Notwendige gelernt wird, wirkt die Anpassung deutlich zugänglicher und weniger komplex.
Besonders wertvoll ist die Flexibilität dieses Ansatzes. Für jeden Anwendungsfall wird kein eigenes vollständiges Modell benötigt. Ein starkes Foundation Model kann über kleine, austauschbare Adapter viele verschiedene Verhaltensweisen unterstützen. Dadurch lassen sich Systeme leichter weiterentwickeln, neue Anforderungen schneller umsetzen und Kosten kontrollieren, ohne die Qualität zu beeinträchtigen.
Im Kern geht es bei LoRA nicht vor allem darum, Modelle immer mehr Daten auswendig lernen zu lassen. Es geht darum, ihnen das passende Verhalten beizubringen. Mit durchdachten Beispielen und einem klaren Ziel kann ein Modell lernen, die Sprache einer bestimmten Domäne zu verwenden, einer gewünschten Struktur zu folgen und echte Nutzer wirksamer zu unterstützen.
