Gemma 4 Fine-Tuning-Leitfaden | Unsloth-Dokumentation

Gemma 4 Fine-Tuning-Anleitung | Unsloth-Dokumentation

Das Feintuning eines Open-Weight-Large-Language-Modells ist längst keine rein forschungsbezogene Tätigkeit mehr; es ist ein Standard-Schritt in vielen Produktionspipelines. Ein Basismodell weiß, wie es fließenden Text erzeugt, aber es kennt weder Ihr Datenformat, noch Ihren Fachwortschatz oder den Ton Ihres Produkts. Genau hier kommt das Feintuning ins Spiel. Mit der Gemma-4-Familie von Google und dem optimierten Trainings-Stack von Unsloth schrumpft die Lücke zwischen „vortrainiertem Modell" und „einsatzbereitem Assistenten" auf einen einzigen, schnellen Trainingslauf.

Dieser Leitfaden ist ein praktischer Durchlauf des Gemma-4-Feintuning-Workflows, wie er in der Unsloth-Dokumentation beschrieben wird. Er behandelt die benötigte Umgebung, die Installationsschritte, die Datensatzvorbereitung, die LoRA-Konfiguration, das Training und schließlich das Ausführen und Exportieren Ihres feinabgestimmten Modells. Die Dokumentationsseite, auf der dieser Leitfaden basiert, wurde zuletzt am 2026-07-18T14:46:20.453Z aktualisiert, daher spiegeln die folgenden Anweisungen den aktuellen Stand der Unsloth-Toolchain wider.

Was dieser Leitfaden voraussetzt

Unsloth basiert auf einer einfachen Idee: Feintuning soll schnell sein, möglichst wenig VRAM verbrauchen und Sie nicht dazu zwingen, Ihre Trainingsschleife neu zu schreiben. Dies wird durch eine Reihe optimierter Kernel für Aufmerksamkeits- und lineare Schichten, automatische Quantisierungsverwaltung und eine enge Integration mit den Transformers- und TRL-Trainings-Stacks von Hugging Face erreicht.

Gemma 4 von Google ist die Open-Weight-Modellfamilie, für die dieser Workflow entwickelt wurde. Je nach Größe der gewählten Variante benötigen Sie mehr oder weniger GPU-Speicher, aber der Trainingscode selbst bleibt nahezu identisch.

Sie sollten mit Python vertraut sein, ein grundlegendes Verständnis davon haben, was LoRA und QLoRA sind, und sich in einem Terminal zurechtfinden. Sie müssen kein Machine-Learning-Ingenieur sein – Sie brauchen eine GPU und die Bereitschaft, ein paar Befehlen zu folgen.

Anforderungen

Bevor Sie etwas ausführen, stellen Sie sicher, dass Ihre Umgebung die Mindestanforderungen erfüllt.

Hardware

• Eine NVIDIA-GPU mit CUDA-Unterstützung. Die Beschleunigungen von Unsloth stammen von benutzerdefinierten Kernels, die auf moderne GPU-Architekturen abzielen. Daher wird eine GPU aus der Turing-Generation (RTX-20-Serie) oder neuer empfohlen. Ampere-, Ada-Lovelace- und Hopper-Architekturen liefern die besten Ergebnisse.
• Ausreichend VRAM. Der genaue Betrag hängt von der Gemma-4-Variante ab, die Sie feinabstimmen möchten, sowie von der verwendeten Quantisierungsstufe. Mit 4-Bit-QLoRA können Sie ein kleineres Gemma-4-Modell auf Consumer-Hardware mit 8–16 GB VRAM feinabstimmen. Größere Varianten erfordern eine Workstation oder Cloud-GPU mit 24 GB oder mehr.
• Genügend System-RAM und Speicherplatz, um die Modellgewichte, den Trainingsdatensatz und die gespeicherten Checkpoints aufzunehmen.

Software

• Eine 64-Bit-Linux-Distribution oder Windows Subsystem for Linux (WSL2). Die meisten Anweisungen gehen von einer Unix-ähnlichen Shell aus.
• Python 3.9 oder neuer.
• CUDA-Toolkit und NVIDIA-Treiber. Welche Version genau benötigt wird, hängt von der PyTorch-Version ab, die Sie installieren; die offizielle PyTorch-Website und die Unsloth-Dokumentation listen kompatible Kombinationen auf.
• Eine aktuelle Version von PyTorch. Unsloth verfolgt PyTorch-Veröffentlichungen genau, und die Installation eines aktuellen Builds erspart Ihnen Versionskonflikte.

Wenn Sie Google Colab verwenden, sind Sie weitgehend abgedeckt: Colab wird mit aktuellen PyTorch- und CUDA-Versionen ausgeliefert, und Unsloth bietet einen spezifischen Installationspfad für Colab-Umgebungen.

Schritt-für-Schritt-Installation

Der Installationsprozess von Unsloth ist bewusst kurz gehalten. Die Bibliothek wird als Python-Paket verteilt, und der einfachste Weg, sie zu erhalten, ist über pip.

Öffnen Sie ein Terminal und installieren Sie das Kernpaket:

pip install unsloth

Dies zieht das Hauptpaket von Unsloth zusammen mit seinen Abhängigkeiten ein, einschließlich transformers, datasets, trl, peft und accelerate. Wenn Sie feststellen, dass Ihre Umgebung bereits eine bestimmte Version von PyTorch hat und Sie vermeiden möchten, dass Unsloth diese überschreibt, können Sie die Abhängigkeitsauflösung überspringen und nur die Bibliothek selbst installieren:

pip install --no-deps unsloth

Auf Google Colab wird empfohlen, das Extra colab-new zu installieren, das die umgebungsspezifischen Abhängigkeitsversionen automatisch auflöst:

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"

Für eine brandaktuelle Installation direkt aus dem Repository können Sie denselben Befehl mit dem Extra colab-new auf jeder Linux-Maschine verwenden:

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"

Sobald die Installation abgeschlossen ist, überprüfen Sie, ob die Bibliothek sauber importiert und die Version plausibel aussieht:

python -c "import unsloth; print(unsloth.__version__)"

Sie sollten eine Versionszeichenfolge sehen, ohne Warnungen zu fehlenden CUDA-Erweiterungen. Wenn Sie eine Fehlermeldung erhalten, die eine fehlende CUDA-Laufzeitumgebung erwähnt, überprüfen Sie vor dem Fortfahren Ihre PyTorch-Installation und Ihre CUDA-Treiberversion.

Einige Benutzer installieren auch bevorzugt zuerst eine bestimmte Version von PyTorch und fügen dann Unsloth hinzu. Dies ist ein guter Ansatz, wenn Ihr Projekt an eine bestimmte transformers-Version gebunden ist:

pip install torch --index-url https://download.pytorch.org/whl/cu124
pip install unsloth

Denken Sie daran: Installieren Sie zuerst PyTorch, dann Unsloth, und lassen Sie Unsloth den Rest des Trainings-Stacks ausrichten.

Laden von Gemma 4 mit Unsloth

Die gesamte Unsloth-API dreht sich um zwei Funktionen: FastLanguageModel.from_pretrained und FastLanguageModel.get_peft_model. Die erste lädt ein Modell und wendet Optimierungen und Quantisierung an; die zweite verwandelt das geladene Modell in ein parameter-effizientes, trainierbares LoRA-Modell.

Der Standard-Ladeblock sieht so aus:

import torch
from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-4-...",  # Wählen Sie die benötigte Gemma-4-Variante
    max_seq_length=2048,
    dtype=None,
    load_in_4bit=True,
)

Drei Argumente verdienen besondere Aufmerksamkeit:

• model_name – Dies ist die Hugging-Face-Kennung des Gemma-4-Checkpoints, den Sie feinabstimmen möchten. Die genaue Kennung hängt von der Größe des Modells ab und davon, ob Sie das Basismodell oder eine instruktionsoptimierte Version wünschen. Unsloth hostet vorquantisierte und optimierte Varianten dieser Modelle auf seinem Hugging-Face-Hub, und genau diese sollten Sie verwenden, um von den Geschwindigkeitsverbesserungen zu profitieren.
• max_seq_length – Legt den Kontextfenster für das Training fest. Die Gemma-4-Familie unterstützt lange Kontexte, aber Sie sollten diesen Wert auf eine Größe setzen, die zu Ihren tatsächlichen Daten passt. Ein Wert von 2048 ist für die meisten Chat-Datensätze geeignet, während Aufgaben mit längeren Dokumenten 4096 oder mehr benötigen können. Beachten Sie, dass der Speicherverbrauch mit der Sequenzlänge wächst.
• load_in_4bit – Aktiviert QLoRA-ähnliche Quantisierung. Dies reduziert den VRAM-Fußabdruck des Modells drastisch und ermöglicht das Feintuning auf Consumer-GPUs, die sonst zu klein wären. Wenn Sie eine High-End-GPU mit viel Speicher haben, können Sie dies auf False setzen und in voller oder 8-Bit-Genauigkeit feinabstimmen.

Die Variable dtype kann auf None belassen werden, wodurch Unsloth den optimalen Gleitkommatyp basierend auf Ihrer Hardware wählt. Auf Ampere- und neueren GPUs ist das typischerweise bfloat16, was während des Trainings stabiler ist als float16.

Vorbereiten Ihres Datensatzes

Unsloth zwingt Sie nicht auf ein einziges Datenformat. Wenn Sie jemals die Hugging-Face-datasets-Bibliothek oder den TRL-SFTTrainer verwendet haben, wissen Sie bereits, wie Sie Daten einspeisen. Das häufigste Format für Chat-Feintuning ist ein gesprächsähnliches Layout, bei dem jedes Gespräch eine Liste von Nachrichten mit den Feldern role und content ist.

Beispielsweise sieht das beliebte ShareGPT-Format so aus:

{
    "conversations": [
        {"from": "human", "value": "Erkläre, was eine Vektordatenbank ist."},
        {"from": "gpt", "value": "Eine Vektordatenbank speichert Einbettungen..."}
    ]
}

Sie können einen solchen Datensatz mit der Hugging-Face-datasets-Bibliothek laden:

from datasets import load_dataset

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

Wenn Ihre Daten im Klartext vorliegen, können Sie eine einfache Chat-Vorlage definieren und Ihren Datensatz direkt umformatieren:

def format_chat(example):
    text = ""
    for turn in example["conversations"]:
        if turn["from"] == "human":
            text += f"<|user|>\n{turn['value']}\n"
        elif turn["from"] == "gpt":
            text += f"<|assistant|>\n{turn['value']}\n"
    return {"text": text}

dataset = dataset.map(format_chat, remove_columns=dataset.column_names)

Der SFTTrainer, den wir später verwenden, akzeptiert ein dataset_text_field-Argument und übernimmt den Rest. Wichtig ist, dass Ihr Datensatz ein Textfeld enthält, das das vollständig formatierte Gespräch einschließlich der Sondertoken zur Trennung der Rollen darstellt.

Konfigurieren von LoRA-Adaptern

Nachdem das Modell geladen und der Datensatz vorbereitet ist, besteht der nächste Schritt darin, das parameter-effiziente Feintuning-Setup zu konfigurieren. Unsloth bietet einen dünnen Wrapper um PEFT, der dies unkompliziert macht:

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

Die wichtigsten Hyperparameter sind:

• r – der Rang der LoRA-Matrizen. Ein Rang von 16 ist eine gute Voreinstellung für die meisten Aufgaben. Größere Werte erhöhen die Ausdruckskraft, verbrauchen aber auch mehr VRAM während des Trainings.
• lora_alpha – der Skalierungsfaktor für die LoRA-Gewichte. Es ist ein üblicher Ausgangspunkt, ihn gleich dem Rang zu halten.
• lora_dropout – auf 0 gesetzt, weil die Unsloth-Kernel und fusionierten Optimierer während des Trainings bereits ihre eigene Regularisierung hinzufügen; Dropout auf den Adapterschichten ist selten erforderlich.
• target_modules – die Projektionsschichten, an denen LoRA-Adapter befestigt werden. Die Abdeckung aller vier Aufmerksamkeitsprojektionen plus der MLP-Projektionen ist für Modelle der Gemma-Klasse Standard.
• use_gradient_checkpointing="unsloth" – aktiviert die speicherschonende Gradient-Checkpointing-Implementierung von Unsloth. Dies ist einer der Gründe, warum Sie größere Modelle auf kleineren GPUs trainieren können.

Training mit dem SFT-Trainer

Nachdem Datensatz und Modell bereit sind, trainieren wir. Unsloth arbeitet direkt mit trl.SFTTrainer zusammen, sodass Sie die volle Leistung des Hugging-Face-Trainingsökosystems nutzen, ohne eine neue API lernen zu müssen.

from trl import SFTTrainer
from transformers import TrainingArguments

training_args = TrainingArguments(
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    warmup_steps=5,
    max_steps=60,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=1,
    output_dir="gemma4-finetuned",
    optim="adamw_8bit",
    seed=3407,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=training_args,
)

Beachten Sie die Wahl von optim="adamw_8bit", die den Speicher des Optimierungszustands reduziert. In Kombination mit 4-Bit-Quantisierung und Gradient-Checkpointing ermöglicht dies einer bescheidenen Consumer-GPU, ein Gemma-4-Modell feinabzustimmen.

Starten Sie den Trainingslauf:

trainer.train()

Während des Trainings sehen Sie den sinkenden Verlust in den Protokollen. Wenn Sie einen CUDA-Out-of-Memory-Fehler erhalten, senken Sie per_device_train_batch_size auf 1 oder 2 und erhöhen Sie gradient_accumulation_steps entsprechend. Eine kleine Batchgröße mit Akkumulation führt zu nahezu demselben Ergebnis wie eine große Batchgröße, verbraucht aber viel weniger Speicher.

Für die meisten kleinen und mittelgroßen Datensätze sind einige hundert Schritte ausreichend. Sie müssen nicht über viele Epochen trainieren; LoRA konvergiert schnell, und es ist leicht, einen kleinen Adapter auf einem kleinen Datensatz zu übertrainieren.

Speichern und erneutes Laden Ihres Modells

Sobald das Training abgeschlossen ist, haben Sie zwei Optionen: Nur die Adaptergewichte speichern oder den Adapter in das vollständige Modell zurückführen und in einem Standardformat exportieren.

Die einfachste Option ist, nur den LoRA-Adapter zu speichern:

model.save_pretrained("gemma4-lora")
tokenizer.save_pretrained("gemma4-lora")

Dies ergibt eine kleine Reihe von Dateien, typischerweise einige zehn Megabyte, die nur die trainierten Adapter enthalten. Um das feinabgestimmte Modell wiederzuverwenden, laden Sie das Basis-Gemma-4-Modell mit Unsloth und laden dann den Adapter darauf:

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-4-...",
    max_seq_length=2048,
    load_in_4bit=True,
)

from peft import PeftModel

model = PeftModel.from_pretrained(model, "gemma4-lora")

Wenn Sie ein vollständig zusammengeführtes Modell wünschen, das ohne Unsloth oder PEFT ausgeführt werden kann, können Sie den Adapter in die Basisgewichte zurückführen:

model = model.merge_and_unload()
model.save_pretrained("gemma4-merged")
tokenizer.save_pretrained("gemma4-merged")

Das resultierende Verzeichnis enthält einen Standard-Transformers-Checkpoint, der wie jedes andere Modell geladen werden kann.

Verwendungsbeispiele

Inferenz ausführen

Nach dem Feintuning wechseln Sie mit einem einfachen Unsloth-Helfer in den Inferenzmodus:

model = FastLanguageModel.for_inference(model)

Dann übergeben Sie Ihren Prompt im selben Chat-Format, das Sie während des Trainings verwendet haben:

messages = [
    {"role": "user", "content": "Schreibe eine Support-Antwort für einen Benutzer, dessen Bestellung sich verzögert."},
]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt",
).to("cuda")

outputs = model.generate(input_ids=inputs, max_new_tokens=512)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Die Ausgabe sollte den Stil, das Format und das Wissen widerspiegeln, das Sie in das Modell trainiert haben – das ist der eigentliche Sinn der Übung.

Export nach GGUF für lokale Bereitstellung

Eine der häufigsten Aufgaben nach dem Training ist der Export des feinabgestimmten Modells nach GGUF, damit es mit Tools wie llama.cpp oder Ollama verwendet werden kann. Unsloth bietet dafür einen einzigen Befehl:

model.save_pretrained_gguf(
    "gemma4-gguf",
    tokenizer,
    quantization_method="q8_0",
)

Sie können auch andere Quantisierungsmethoden wie f16, q4_k_m oder q5_k_m wählen. Die Methode q8_0 erhält den Großteil der Modellqualität und erzeugt eine Datei angemessener Größe, die auf CPU-Hosts gut läuft.

Best Practices und Fehlerbehebung

Die beiden häufigsten Probleme während eines Feintuning-Laufs sind Out-of-Memory-Fehler und langsames Training. So geht Unsloth mit beidem um:

• Verwenden Sie 4-Bit-Quantisierung. Wenn load_in_4bit=True nicht gesetzt ist, setzen Sie es. Dies allein kann den VRAM-Verbrauch um bis zu drei Viertel reduzieren.
• Aktivieren Sie `use_gradient_checkpointing="unsloth"`. Dies tauscht eine kleine Menge Trainingszeit gegen eine große Speicherreduzierung.
• Verwenden Sie den AdamW-8-Bit-Optimierer. Der Optimierungszustand ist oft der versteckte Speicherverbraucher; 8-Bit-State reduziert ihn erheblich.
• Verkleinern Sie das Kontextfenster. Wenn Ihre Aufgabe keine langen Dokumente erfordert, halten Sie max_seq_length bescheiden.
• Erhöhen Sie die Gradientenakkumulation statt der Batchgröße. Eine Batchgröße von 1 mit hoher Akkumulationszahl ist sicherer als eine große Batchgröße, die möglicherweise nicht hineinpasst.

Auf der Geschwindigkeitsseite sollten Sie sicherstellen, dass Sie die von Unsloth gehosteten Modell-Checkpoints laden und nicht die Standard-Checkpoints von Google. Die Unsloth-Versionen verfügen über vorberechnete Optimierungen und quantisierte Gewichte, die für die schnellen Kernel der Bibliothek entwickelt wurden. Das Laden eines Vanilla-Checkpoints vom Hub funktioniert, aber Sie verpassen den Großteil des Leistungsvorteils.

Fazit

Die Unsloth-Dokumentation für Gemma 4 beschreibt einen Workflow, der kurz, wiederholbar und leicht an verschiedene Modellgrößen und Datensätze anzupassen ist. Installieren Sie die Bibliothek, laden Sie ein quantisiertes Gemma-4-Modell, befestigen Sie einen LoRA-Adapter, trainieren Sie mit dem SFT-Trainer und speichern Sie das Ergebnis – das ist der gesamte Zyklus. Was mehr zählt als der Code, ist die Disziplin darum herum: Bereiten Sie einen sauberen Datensatz mit konsistenter Formatierung vor, wählen Sie einen LoRA-Rang, der zur Komplexität Ihrer Aufgabe passt, halten Sie die Sequenzlängen ehrlich und widerstehen Sie dem Drang zu übertrainieren.

Das feinabgestimmte Modell, das Sie am Ende erhalten, wird nicht nur eine Kopie von Gemma 4 mit neuem Text sein. Es wird eine Version des Modells sein, die Ihr spezifisches Format, Ihre spezifische Domäne und Ihre spezifischen Einschränkungen kennt. Und mit der speichereffizienten Trainingsschleife von Unsloth können Sie dies auf Hardware erreichen, die die meisten Teams bereits besitzen. Ob Sie nun einen Kundensupport-Assistenten, einen Codegenerierungshelfer oder einen internen Dokumentzusammenfasser bauen – dieser Leitfaden gibt Ihnen den dokumentierten Weg vom Basismodell zum einsatzbereiten Feintuning.