Wie man Gemma 4 mit Unsloth feinabstimmt: Schritt-für-Schritt-Leitfaden

Update 14. Juni 2026: Gemma 4 umfasst jetzt E2B, E4B, 12B, 26B A4B und 31B. 12B ergänzt den Mittelbereich mit 256K Kontext und nativer Audio-/Video-Unterstützung; prüfen Sie bei Runtime-Anleitungen die aktuelle Verfügbarkeit.

Unsloth unterstützt ab Tag null alle fünf wichtigen Gemma-4-Varianten: E2B, E4B, 12B, 26B-A4B und 31B. Es trainiert Modelle etwa doppelt so schnell und braucht bis zu 70 % weniger VRAM als Standard-Hugging-Face-Training. Genau deshalb ist es die praktische Wahl für Menschen auf Consumer-Hardware.

Dieser Leitfaden deckt alles ab, von der Modellwahl bis zum Export des fertigen Adapters für Ollama, llama.cpp oder LM Studio.

Welches Gemma-4-Modell sollten Sie feinabstimmen?

Modell	VRAM fürs Training (LoRA, bf16)	Am besten für
E4B	~8–10 GB	Laptops, RTX 3060/4060, kostenloses Colab
E2B	~6–8 GB	multimodale + Audio-Aufgaben, knappste Budgets
26B-A4B	~24+ GB (16-Bit-LoRA)	Geschwindigkeits-/Qualitäts-Balance, RTX 3090/4090
31B	~20 GB (QLoRA 4-Bit)	maximale Qualität, NVIDIA A100 / Dual-GPU

Wichtige Hinweise:

E4B ist für die meisten Menschen der richtige Startpunkt.
Vermeiden Sie QLoRA auf 26B-A4B. Für das MoE-Modell empfiehlt Unsloth 16-Bit-LoRA statt 4-Bit-QLoRA.
31B ist das gute Fine-Tuning-Ziel, wenn Qualität wichtiger ist als alles andere.

Bevor Sie starten: Unsloth installieren und aktualisieren

Es gibt zwei Wege: Unsloth Studio (No-Code-Web-UI) und Unsloth Core (Python-Bibliothek).

Option A — Unsloth Studio

macOS, Linux oder WSL:

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

Windows PowerShell:

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

Studio starten:

unsloth studio -H 0.0.0.0 -p 8888

Dann im Browser http://localhost:8888 öffnen, Gemma 4 suchen, Modellgröße und Datensatz wählen.

Option B — Unsloth Core

Bestehende Installation aktualisieren:

pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo

Neuinstallation:

pip install unsloth --torch-backend=auto

Datensatz vorbereiten

Gemma 4 nutzt das Standard-Konversationsformat mit user- und model-Rollen.

{
  "messages": [
    {
      "role": "user",
      "content": "Classify the sentiment of this review: 'Shipping was late but the product is excellent.'"
    },
    {
      "role": "model",
      "content": "Mixed — negative sentiment toward shipping, positive toward the product."
    }
  ]
}

Wichtige Formatregeln:

Nutzen Sie "role": "model" statt "assistant"
System-Prompts sind in Gemma 4 nativ unterstützt
Für Thinking Mode <|think|> an den Anfang des System-Prompts setzen
Bei Multi-Turn-Daten nur die finale sichtbare Antwort als Trainingsziel aufnehmen

Richtwerte für Datensatzgrößen:

Stil oder Tonalität: 200–1.000 hochwertige Beispiele
Domänenanpassung: 10.000–50.000 Beispiele
Instruction Following: 5.000–20.000 Beispiele
Klassifikation / Extraktion: 500–5.000 Beispiele

Halten Sie immer 10–20 % für Evaluation zurück.

Text-Fine-Tuning: vollständiger Code-Workflow

Beispiel für Gemma 4 E4B mit LoRA:

from unsloth import FastLanguageModel
import torch
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig

max_seq_length = 2048

dataset = load_dataset("json", data_files={"train": "your_dataset.jsonl"}, split="train")

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "google/gemma-4-e4b-it",
    max_seq_length = max_seq_length,
    load_in_4bit = False,
    load_in_16bit = True,
    full_finetuning = False,
)

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,
    max_seq_length = max_seq_length,
)

trainer = SFTTrainer(
    model = model,
    train_dataset = dataset,
    tokenizer = tokenizer,
    args = SFTConfig(
        max_seq_length = max_seq_length,
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        warmup_steps = 10,
        max_steps = 100,
        logging_steps = 1,
        output_dir = "outputs_gemma4",
        optim = "adamw_8bit",
        seed = 3407,
        dataset_num_proc = 1,
    ),
)

trainer.train()

Wenn Ihnen der Speicher ausgeht, senken Sie zuerst per_device_train_batch_size und max_seq_length.

Fine-Tuning des 26B-A4B-MoE-Modells

Das MoE-Modell braucht einen leicht anderen Loader:

import os
import torch
from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/Gemma-4-26B-A4B-it",
    max_seq_length = 2048,
    load_in_4bit = False,
    load_in_16bit = True,
    full_finetuning = False,
)

Danach LoRA-Adapter anhängen und wie oben trainieren. Für MoE empfiehlt Unsloth, mit Rank 16 und kürzeren Kontextlängen zu starten.

Multimodales Fine-Tuning (E2B und E4B)

Für bildbasierte Aufgaben nutzen Sie FastVisionModel:

from unsloth import FastVisionModel
from unsloth.trainer import UnslothVisionDataCollator
from trl import SFTTrainer, SFTConfig

model, tokenizer = FastVisionModel.from_pretrained(
    model_name = "google/gemma-4-e4b-it",
    max_seq_length = 2048,
    load_in_4bit = False,
    use_gradient_checkpointing = "unsloth",
)

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = False,
    finetune_language_layers   = True,
    finetune_attention_modules = True,
    finetune_mlp_modules       = True,
    r = 16,
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    target_modules = "all-linear",
)

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    data_collator = UnslothVisionDataCollator(model, tokenizer),
    train_dataset = dataset,
    args = SFTConfig(
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        learning_rate = 2e-4,
        output_dir = "outputs_gemma4_vision",
    ),
)

trainer.train()

Wichtig: In Gemma-4-Multimodal-Prompts muss das Bild vor der Textanweisung stehen:

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "image", "image": "path/to/image.jpg"},
        {"type": "text",  "text": "Describe what is happening in this image."}
      ]
    },
    {
      "role": "model",
      "content": "..."
    }
  ]
}

Für Audio-Fine-Tuning mit E2B oder E4B sollten Audioclips kurz und aufgabenspezifisch bleiben.

Speichern und Exportieren des feinabgestimmten Modells

Als LoRA-Adapter speichern

model.save_pretrained("gemma4_e4b_adapter")
tokenizer.save_pretrained("gemma4_e4b_adapter")

Mergen und als GGUF exportieren

model.save_pretrained_gguf(
    "gemma4_e4b_finetuned",
    tokenizer,
    quantization_method = "q4_k_m"
)

Die resultierende .gguf-Datei kann direkt in llama.cpp geladen, mit eigenem Modelfile in Ollama importiert oder in LM Studio geladen werden.

Export aus Unsloth Studio

Im Studio nach dem Training auf den Export-Tab gehen und GGUF, Safetensors oder beides auswählen.

Ein häufiger Stolperstein: Wenn sich das exportierte Modell in Ollama oder llama.cpp seltsam verhält, liegt das meist an einem Chat-Template- oder EOS-Mismatch.

Kostenlose Colab-Notebooks

Unsloth stellt kostenlose Google-Colab-Notebooks für alle Gemma-4-Größen bereit. E2B- und E4B-Notebooks laufen auf einer kostenlosen T4-GPU, 26B-A4B und 31B benötigen A100.

Modell	Aufgabe	Link
E2B	Text	In Colab öffnen
E2B	Vision	In Colab öffnen
E2B	Audio	In Colab öffnen
26B-A4B	Vision (A100)	In Colab öffnen
31B	Vision (A100)	In Colab öffnen

Häufige Probleme

Out of memory beim Training

max_seq_length reduzieren, dann per_device_train_batch_size auf 1 setzen. use_gradient_checkpointing="unsloth" aktiviert lassen.

QLoRA auf 26B-A4B

Nicht empfohlen. Für das MoE-Modell bei 16-Bit-LoRA bleiben.

Chat-Template-Mismatch nach dem Export

Wenn sich das exportierte Modell in Ollama oder llama.cpp verschlechtert, prüfen Sie, dass zur Inferenz dasselbe Gemma-4-Chat-Template genutzt wird.

Reasoning-Fähigkeit nach dem Fine-Tuning schwächer

Wenn Sie die eingebaute Reasoning-Fähigkeit erhalten möchten, mischen Sie ausreichend Reasoning-Beispiele in die Trainingsdaten. Unsloth empfiehlt mindestens 75 %.

Die offizielle Trainingsreferenz finden Sie in der Unsloth-Dokumentation.