QLoRA Fine-Tuning mit Unsloth: Eigenes LLM auf einer Consumer-GPU spezialisieren

Mit QLoRA Fine-Tuning mit Unsloth schneiden Sie ein lokales Sprachmodell wie Llama 3.1 8B oder Qwen 2.5 7B auf Produkte, Prozesse oder FAQ-Inhalte Ihres Unternehmens zu. Das Modell erhält schlanke Adapter-Gewichte, trainiert auf Ihren Firmendaten, ohne Volltraining und ohne Cloud auf einer GPU ab 8 GB VRAM. Das Ergebnis importieren Sie als GGUF-Datei in Ollama.

Voraussetzungen

• NVIDIA-GPU mit mindestens 8 GB VRAM und CUDA Capability ≥ 7.0 (ab RTX 20er-Serie, z. B. RTX 2080, RTX 3060 8 GB, RTX 4060 8 GB)
• Python 3.13 (so im offiziellen Installationsbeispiel) in einer eigenen virtuellen Umgebung
• Betriebssystem: Windows 10/11 (nativ via PowerShell-Installer oder WSL2), Linux (Ubuntu 22.04/24.04)
• NVIDIA-Treiber mit CUDA 12.4+ (für RTX 50er Blackwell: CUDA 12.8+); bei der manuellen Installation wählt uv pip install unsloth --torch-backend=auto das passende PyTorch-Paket
• Ollama lokal installiert (für den späteren Import des fertig trainierten Modells)
• Firmendaten im JSONL-Format (Alpaca-Format, mindestens 200 Einträge; siehe Schritt 4)
• Mindestens 10 GB freier Festplattenspeicher für Modell-Download (~4–5 GB für ein 8B-Modell), Adapter und Exportdateien
• Internetverbindung für den initialen Modell-Download von Hugging Face

Was ist QLoRA – und warum Unsloth?

Bei LoRA (Low-Rank Adaptation) trainieren Sie nur kleine Adapter-Matrizen, rund 0,1 bis 1 % der Parameter; das Basismodell bleibt eingefroren, liegt aber in 16 Bit im VRAM (rund 22 GB bei 8B). QLoRA lädt das Basismodell zusätzlich 4-Bit-quantisiert (BitsAndBytes) und trainiert die Adapter weiter in 16 Bit. Der VRAM-Bedarf sinkt so auf rund 6 GB.

Unsloth (Kernpaket Apache 2.0, Unsloth Studio AGPL-3.0; Python-Paket 2026.9.12, Stand September 2026) beschleunigt das mit eigenen CUDA-Kerneln. Der Hersteller nennt 2× schnelleres Training bei 70 % weniger VRAM gegenüber Hugging Face mit PEFT, ohne Genauigkeitsverlust. Unterstützt werden die gängigen Llama-, Qwen-, Mistral- und Phi-Modelle.

Schritt 1: Unsloth installieren

Die offiziellen Installer-Skripte richten Unsloth samt Weboberfläche Unsloth Studio ein. Windows (PowerShell als normaler Benutzer):

irm https://unsloth.ai/install.ps1 | iex

Linux und WSL2:

curl -fsSL https://unsloth.ai/install.sh | sh

Für die Python-Skripte dieser Anleitung genügt Unsloth Core. Installieren Sie es wie im offiziellen README mit uv in eine eigene Umgebung:

# Linux/WSL: uv installieren, Umgebung anlegen und aktivieren
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv unsloth_env --python 3.13
source unsloth_env/bin/activate
# Windows (PowerShell): winget install --id=astral-sh.uv -e
#   uv venv unsloth_env --python 3.13 ; .\unsloth_env\Scripts\activate

# Unsloth mit passendem PyTorch-Backend installieren
uv pip install unsloth --torch-backend=auto

Installieren Sie kein separates CUDA-Toolkit parallel; das PyTorch-Paket bringt die benötigten CUDA-Bibliotheken mit.

Schritt 2: Modell laden und für QLoRA vorbereiten

Arbeiten Sie in einem Python-Skript oder Jupyter-Notebook. Für 8 GB VRAM eignen sich Llama 3.1 8B Instruct, Qwen 2.5 7B oder Mistral 7B. Unsloth stellt sie vorquantisiert auf Hugging Face bereit:

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.1-8B-Instruct-bnb-4bit",
    max_seq_length=2048,
    dtype=None,         # Auto: BF16 auf Ampere+, FP16 sonst
    load_in_4bit=True,  # QLoRA: 4-Bit-Quantisierung aktivieren
)

load_in_4bit=True aktiviert die 4-Bit-Quantisierung per BitsAndBytes und ist für 7B- bis 8B-Modelle auf 8-GB-GPUs Pflicht.

Schritt 3: LoRA-Adapter konfigurieren

Richten Sie nun die Adapter-Parameter ein. Der Rank r bestimmt, wie viele Adapter-Parameter trainiert werden, und damit Qualität und VRAM-Bedarf. Beginnen Sie mit r=16:

model = FastLanguageModel.get_peft_model(
    model,
    r=16,               # Rank: 8 für schmal, 32+ für größere Datasets
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=32,      # Empfehlung: 2× Rank
    lora_dropout=0,     # 0 für Effizienz; 0.05–0.1 bei Overfitting
    bias="none",
    use_gradient_checkpointing="unsloth",  # Speicheroptimiertes Backprop
    random_state=42,
)

Faustregel: lora_alpha gleich r oder 2 × r (das offizielle Unsloth-Notebook nutzt 16). Höhere Ränge (32, 64) erhöhen Anpassungsfähigkeit und VRAM-Bedarf. Auf 8 GB VRAM ist r=16 der sichere Ausgangspunkt.

Schritt 4: Firmendaten aufbereiten

Legen Sie Ihre Trainingsdaten im JSONL-Format an. Das verbreitete Alpaca-Format enthält je Zeile ein JSON-Objekt mit drei Feldern:

# Beispiel: firmendaten.jsonl (jede Zeile ein JSON-Objekt)
{"instruction": "Erkläre unsere Rückgaberichtlinie.", "input": "", "output": "Unsere Rückgaberichtlinie gilt 30 Tage ab Kaufdatum ..."}
{"instruction": "Beantworte die Kundenfrage.", "input": "Welche Zahlungsmethoden akzeptieren Sie?", "output": "Wir akzeptieren Kreditkarte, SEPA-Lastschrift und PayPal ..."}

Richtwerte:

1. 200–500 Einträge: Stil- und Format-Anpassung (Tonalität, Antwortstruktur)
2. 1.000–3.000 Einträge: Domänenspezifisches Wissen (Produkt-FAQ, Prozesse)
3. 5.000+: Tiefe Wissens-Injektion

300 sorgfältige Beispiele erzielen bessere Ergebnisse als 3.000 inkonsistente; Tippfehler und widersprüchliche Antworten übernimmt das Modell direkt.

from datasets import load_dataset

dataset = load_dataset("json", data_files="firmendaten.jsonl", split="train")

def formatting_prompts_func(examples):
    texts = []
    for instruction, input_text, output in zip(
        examples["instruction"], examples["input"], examples["output"]
    ):
        prompt = f"### Instruction:\n{instruction}"
        if input_text:
            prompt += f"\n### Input:\n{input_text}"
        prompt += f"\n### Response:\n{output}"
        texts.append(prompt)
    return {"text": texts}

dataset = dataset.map(formatting_prompts_func, batched=True)

Schritt 5: Training starten

Unsloth nutzt den SFTTrainer aus der TRL-Bibliothek, konfiguriert über SFTConfig. Die Parameter sind auf 8 GB VRAM ausgelegt. Bei einem Out-of-Memory-Fehler (OOM) setzen Sie zuerst per_device_train_batch_size=1:

from trl import SFTConfig, SFTTrainer

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=SFTConfig(
        per_device_train_batch_size=2,   # Bei OOM auf 1 reduzieren
        gradient_accumulation_steps=4,   # Dann auf 8 erhöhen
        warmup_steps=5,
        num_train_epochs=1,              # 1–3 Epochen empfohlen
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        output_dir="outputs",
    ),
)

trainer.train()

Auf einer RTX 4060 mit 8 GB VRAM dauert eine Epoche über rund 1.000 Beispiele erfahrungsgemäß 10 bis 30 Minuten.

Schritt 6: Adapter speichern und Inferenz testen

Speichern Sie den Adapter getrennt vom Basismodell. Er ist typischerweise rund 100 MB groß:

model.save_pretrained("lora_model")
tokenizer.save_pretrained("lora_model")

Testen Sie die Ausgabequalität vor dem Export:

FastLanguageModel.for_inference(model)
inputs = tokenizer(
    "### Instruction:\nBeantworte die folgende Kundenfrage.\n### Input:\nWie lautet meine Kundennummer?\n### Response:\n",
    return_tensors="pt",
).to("cuda")
outputs = model.generate(**inputs, max_new_tokens=128)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Schritt 7: Als GGUF exportieren und in Ollama importieren

Exportieren Sie das Modell für Ollama ins GGUF-Format. q4_k_m ist der übliche Kompromiss aus Qualität und Dateigröße:

# Direkt zu GGUF (benötigt llama.cpp-Build mit CUDA)
model.save_pretrained_gguf("gguf_model", tokenizer, quantization_method="q4_k_m")

Schlägt der direkte Export fehl (fehlender llama.cpp-Build), nutzen Sie den zweistufigen Weg:

# Erst zu 16-Bit mergen, dann GGUF
model.save_pretrained_merged("merged_model", tokenizer, save_method="merged_16bit")
model.save_pretrained_gguf("gguf_model", tokenizer, quantization_method="q4_k_m")

Legen Sie anschließend ein Modelfile für Ollama an. Unsloth erzeugt es beim Export automatisch, Sie können es auch manuell schreiben:

# Modelfile (Textdatei im GGUF-Exportverzeichnis)
FROM ./gguf_model/unsloth.Q4_K_M.gguf
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM "Sie sind ein spezialisierter Unternehmensassistent für [Firmenname]."
# In PowerShell / Terminal: Modell importieren und starten
ollama create mein-firmenmodell -f Modelfile
ollama run mein-firmenmodell "Was sind unsere Servicezeiten?"

Unsloth Studio: Die No-Code-Alternative

Ohne Python-Skript arbeiten Sie mit Unsloth Studio, einer Weboberfläche für den gesamten Fine-Tuning-Ablauf (Installation über die Installer-Skripte aus Schritt 1). Starten Sie es nur lokal:

unsloth studio -H 127.0.0.1 -p 8888

Anschließend öffnen Sie http://localhost:8888. Binden Sie das Studio nicht mit -H 0.0.0.0 ins Netz: Es bringt serverseitige Werkzeuge mit, die laut Hersteller standardmäßig aktiv sind. Für Fernzugriff nutzen Sie einen SSH-Tunnel. Unsloth Studio steht unter AGPL-3.0.

Troubleshooting / Typische Fehler

OOM-Fehler (Out of Memory)

Setzen Sie per_device_train_batch_size=1 und gradient_accumulation_steps=8, um die effektive Batch-Größe von 8 (2×4) beizubehalten. Zusätzlich max_seq_length auf 1024 reduzieren, wenn Ihre Daten es erlauben.

Falsches Chat-Template nach Export

Das Chat-Template beim Training (z. B. Alpaca, ChatML) muss im Ollama-Modelfile identisch übernommen werden. Sonst liefert das Modell unbrauchbare Ausgaben. Unsloth schreibt das Template normalerweise automatisch ins Modelfile; prüfen Sie es trotzdem.

EOS-Token fehlt im Modelfile

Ohne korrekten End-of-Sequence-Token schreibt das Modell in Ollama endlos weiter. Den Token lesen Sie aus dem Tokenizer aus (tokenizer.eos_token) und manuell ins Modelfile als PARAMETER stop "<token>" eintragen.

GGUF-Konvertierung schlägt fehl

save_pretrained_gguf benötigt einen funktionierenden llama.cpp-Build. Kompilieren Sie llama.cpp bei Fehlern manuell (cmake -B build -DGGML_CUDA=ON, dann cmake --build build --config Release) oder speichern Sie erst als merged_16bit und konvertieren danach.

Overfitting bei kleinem Dataset

Bei mehr als 3 Epochen oder unter 200 Einträgen lernt das Modell die Trainingsdaten auswendig, erkennbar an Wiederholungen in der Ausgabe. Epochen auf 1–2 begrenzen und lora_dropout=0.05 setzen.

Learning-Rate-Instabilität (NaN-Loss)

Loss springt auf NaN: Learning Rate auf 5e-5 oder 2e-5 senken, warmup_steps auf 10 bis 20 erhöhen.

Falsches Modell für 8 GB VRAM gewählt

Modelle ab 13B passen auch mit QLoRA nicht in 8 GB VRAM (siehe VRAM-Tabelle).

Häufige Fragen

Lässt sich auch ohne GPU trainieren?

Nein. Das Training braucht eine NVIDIA-GPU ab RTX 20er-Serie; die CPU reicht nur für Inferenz mit GGUF-Modellen. Ohne passende Hardware nutzen Sie die offiziellen Unsloth-Notebooks in Google Colab mit einer T4 (16 GB VRAM). Beachten Sie: Die Daten liegen dann bei Google.

Wie viele Beispiele sind mindestens nötig?

200 bis 500 sorgfältige Einträge für Stil und Format, 1.000 bis 3.000 für Fachwissen, das im Basismodell fehlt. Qualität geht vor Menge.

Was ist der Unterschied zwischen LoRA und QLoRA?

Bei LoRA liegt das Basismodell in 16 Bit im VRAM, bei QLoRA 4-Bit-quantisiert; die Adapter trainieren beide in 16 Bit. QLoRA spart so 60 bis 75 % VRAM bei geringen Qualitätseinbußen.

Bleiben die Firmendaten im Haus?

Ja. Das Training läuft lokal, Trainingsdaten und Modell werden nicht automatisch hochgeladen. Daten verlassen den Rechner nur, wenn Sie push_to_hub() aufrufen; lassen Sie diesen Aufruf bei internen Daten weg. Das erleichtert den Einsatz mit personenbezogenen Daten nach DSGVO.

Lässt sich das Modell in ein bestehendes Ollama integrieren?

Ja, per ollama create (Schritt 7). Danach nutzen Sie es in Open WebUI, AnythingLLM oder per API.

Welche Lizenz gilt für das fine-getunete Modell?

Die Lizenz des Basismodells gilt weiter. Qwen 2.5 7B und Mistral 7B stehen unter Apache 2.0. Die Llama-Lizenz erlaubt kommerzielle Nutzung, verlangt ab 700 Millionen Monatsnutzern aber eine gesonderte Lizenz. Prüfen Sie die Lizenz Ihres Basismodells.

Fazit

QLoRA mit Unsloth macht Fine-Tuning auf einer GPU ab 8 GB VRAM praktikabel: 4-Bit-Quantisierung und optimierte Kernel bringen ein 8B-Modell in rund 90 Minuten von der Installation zum laufenden Firmenmodell. Entscheidend ist die Qualität der Trainingsdaten, nicht die Hardware. Das GGUF-Modell fügen Sie anschließend in Ihren bestehenden Ollama-Stack ein; passende Basismodelle vergleicht die Übersicht Ollama-Modelle richtig auswählen.

Weiterführende Anleitungen und Quellen

1. Ollama-Modelle 2026 richtig auswählen: VRAM, Quantisierung und Modellvergleich für KMU
2. Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud betreiben
3. GGUF, AWQ und GPTQ erklärt: Welches Quantisierungsformat für welchen Zweck
4. CUDA-Umgebung korrekt aufsetzen: Treiber, Toolkit, cuDNN und PyTorch auf Ubuntu
5. Lokales RAG-System mit Qdrant und Embeddings selbst bauen
6. Unsloth-Dokumentation: Fine-Tuning LLMs Guide
7. Unsloth GitHub Repository (README, Benchmarks)

Passende Anleitungen auf S-EDV

1. Microsoft Phi-4 lokal betreiben: 14B Reasoning-Modell auf Consumer-GPU