Gemma 4 Fine-Tuning-Leitfaden

Trainiere Gemma 4 von Google mit Unsloth.

Du kannst jetzt Googles Gemma 4 12B, E2B, E4B, 26B-A4B und 31B mit Unsloth. Unsloth unterstützt alle Vision-, Text-, Audio- und RL-Fine-Tuning für Gemma 4.

• Unsloth trainiert Gemma 4 ~1,5x schneller mit ~60 % weniger VRAM als FA2-Setups (kein Genauigkeitsverlust)

• Wir haben viele allgemeine Fehler für das Gemma-4-Training behoben (nicht von Unsloth abgeleitet).

• Gemma 4 E2B läuft mit 8 GB VRAM. E4B benötigt 10 GB VRAM.

SchnellstartFehlerbehebungen + Tipps

Gemma 4 feinabstimmen über unsere kostenlosen Google-Colab-Notebooks:

E4B + E2B (Studio)	31B (Kaggle)	E4B (Vision + Text)	E4B (Audio)	E2B (RL GRPO)

Du kannst Gemma 4 kostenlos mit einer UI in unserem Unsloth Studio✨ Notebook:

Du kannst dir auch weitere Notebooks hier ansehen.

Google Colabcolab.research.google.com

• Du kannst Gemma 4 auch mit Reinforcement Learning (RL) auf 9 GB VRAM.

• Gemma 4 E2B LoRA funktioniert auf 8–10 GB VRAM. E4B LoRA benötigt 17 GB VRAM.

• 31B QLoRA funktioniert mit 22 GB und 26B-A4B LoRA benötigt >40 GB

• Exportieren/Modelle in GGUF usw. speichern. und vollständiges Fine-Tuning (FFT) funktioniert ebenfalls.

🐛 Fehlerbehebungen + Tipps

Wenn du bei Gemma-4 E2B und E4B einen Loss von 13–15 siehst, ist das völlig normal – das ist eine häufige Eigenart multimodaler Modelle. Das passierte auch bei Gemma-3N, Llama Vision, Mistral-Vision-Modellen und mehr.

Gemma 26B und 31B haben einen niedrigeren Loss bei 1–3 oder weniger. Vision ist 2x höher, also 3–5

🍇Gradient Accumulation könnte deine Verluste aufblähen

Wenn du Verluste höher als 13–15 siehst (wie 100 oder 300), wird Gradient Accumulation höchstwahrscheinlich nicht korrekt berücksichtigt – wir haben dies als Teil von Unsloth und Unsloth Studio behoben.

Mehr über Gradient Accumulation erfährst du in unserem Blog zur Fehlerbehebung bei Gradient Accumulation: https://unsloth.ai/blog/gradient

⁉️IndexError bei der Inferenz von Gemma-4 31B und 26B-A4B

Du könntest diesen Fehler bei der Inferenz mit 31B und 26B sehen:

File "/.../cache_utils.py", line 937, in update
    keys, values = self.layers[layer_idx].update(...)
IndexError: list index out of range

Die Ursache ist unten:

if hasattr(decoder_config, "num_kv_shared_layers"):
    layer_types = layer_types[: -decoder_config.num_kv_shared_layers]

Wobei Gemma-4 31B und 26B-A4B mit num_kv_shared_layers = 0. In Python, -0 == 0, also layer_types[:-0] wird zu layer_types[:0] == []. Der Cache wird mit null Layer-Slots aufgebaut und schon der allererste Attention-Forward crasht in Cache.update.

⛔ use_cache = True Die Generierung war Kauderwelsch für E2B, E4B

Siehe Issue "[Gemma 4] use_cache=False beschädigt die Attention-Berechnung und erzeugt unbrauchbare Logits #45242"

Gemma-4 E2B und E4B teilen KV-Zustände über die Layer hinweg (num_kv_shared_layers = 20 und 18). Der Cache ist der einzige Ort, an dem frühe Layer KV für spätere Layer ablegen, damit diese sie wiederverwenden können. Wenn use_cache=False (wie es jedes QLoRA-Tutorial setzt und wie gradient_checkpointing=True erzwingt), Gemma4TextModel.forward überspringt die Cache-Erstellung, sodass die KV-geteilten Layer darauf zurückfallen, K und V lokal aus den aktuellen Hidden States neu zu berechnen. Die Logits werden unbrauchbar und der Trainings-Loss divergiert.

Vorher (unsloth/gemma-4-E2B-it, Prompt "Was ist 1+1?"):

use_cache=True  -> '1 + 1 = **2**'
use_cache=False -> 'BROAD\\肯. Specificallyboard K supposed\\_n통  \'
max_abs_logit_diff: 48.937500

Nach unserem Fix:

use_cache=True  -> '1 + 1 = **2**'
use_cache=False -> '1 + 1 = **2**'
max_abs_logit_diff: 0.000000     (bit-exakte Parität, alle 9 Tokens identisch)

📻Audio-float16-Überlauf

Gemma4AudioAttention verwendet config.attention_invalid_logits_value = -1e9 in einem masked_fill Auf fp16 (Tesla T4) überläuft -1e9 den fp16-Maximalwert von 65504 und verursacht:

RuntimeError: Wert kann ohne Überlauf nicht in den Typ c10::Half konvertiert werden

Dies lag an self.config.attention_invalid_logits_value :

attn_weights = attn_weights.masked_fill(
    attention_mask.logical_not(), self.config.attention_invalid_logits_value
)

💡Tipps für Gemma-4

1. Wenn du die Reasoning-Fähigkeit bewahren kannst du Beispiele im Reasoning-Stil mit direkten Antworten mischen (halte mindestens 75 % Reasoning ein). Andernfalls kannst du es vollständig ausgeben. Verwende gemma-4 für das Chat-Template ohne Thinking und gemma-4-thinking für die Thinking-Variante. Verwende die Thinking-Variante für die größeren 26B- und 31B-Modelle und die Variante ohne Thinking für die kleineren Modelle.

   from unsloth.chat_templates import get_chat_template
   tokenizer = get_chat_template(
       tokenizer,
       chat_template = "gemma-4-thinking", # Oder "gemma-4"
   )

2. Um den Thinking-Modus zu aktivieren, verwende enable_thinking = True / False in tokenizer.apply_chat_template

   Thinking aktiviert:

   processor.tokenizer.apply_chat_template([
       {"role" : "user", "content" : "Was ist 2+2?"},
   ], tokenize = False, enable_thinking = True, add_generation_prompt = True)

   Wird ausgeben <bos><|turn>system\n<|think|><turn|>\n<|turn>user\nWas ist 2+2?<turn|>\n<|turn>model\n

   Thinking deaktiviert:

   processor.tokenizer.apply_chat_template([
       {"role" : "user", "content" : "Was ist 2+2?"},
   ], tokenize = False, enable_thinking = False, add_generation_prompt = True)

   Wird ausgeben <bos><|turn>user\nWas ist 2+2?<turn|>\n<|turn>model\n<|channel>thought\n<channel|>

3. Gemma 4 ist leistungsstark für mehrsprachiges Fine-Tuning, da es 140 Sprachen unterstützt.

4. Es wird empfohlen, zu trainieren E4B QLoRA statt E2B LoRA da E4B größer ist und der Unterschied in der Quantisierungsgenauigkeit minimal ist. Gemma 4 E4B LoRA ist sogar noch besser.

5. Nach dem Fine-Tuning kannst du exportieren nach GGUF (für llama.cpp/Unsloth/Ollama/usw.)

⚡Schnellstart

🦥 Unsloth Studio-Leitfaden

Gemma 4 kann ausgeführt und feinabgestimmt werden in Unsloth Studio, unserer neuen Open-Source-Web-UI für lokale KI.

Mit Unsloth Studio kannst du Modelle lokal auf macOS, Windows, Linux und auf NVIDIA-GPUs trainieren. Intel-, MLX- und AMD-Trainingsunterstützung kommt noch diesen Monat.

1

Unsloth installieren

Im Terminal ausführen:

macOS, Linux, WSL:

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

Windows PowerShell:

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

Die Installation geht schnell und dauert ca. 1–2 Minuten.

2

Unsloth starten

macOS, Linux, WSL und Windows:

unsloth studio -H 0.0.0.0 -p 8888

Dann öffne http://localhost:8888 in deinem Browser.

3

Gemma 4 trainieren

Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern, und dich später erneut anmelden. Danach siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen.

Suche in der Suchleiste nach Gemma 4 und wähle dein gewünschtes Modell und deinen Datensatz aus. Passe anschließend deine Hyperparameter und die Kontextlänge nach Bedarf an.

4

Trainingsfortschritt überwachen

Nachdem du auf Training starten geklickt hast, kannst du den Trainingsfortschritt des Modells überwachen und beobachten. Der Trainings-Loss sollte stetig sinken. Sobald es fertig ist, wird das Modell automatisch gespeichert.

5

Exportiere dein feinabgestimmtes Modell

Sobald es fertig ist, kannst du das Modell mit Unsloth Studio in GGUF-, Safetensor- usw.-Formate exportieren.

6

Vergleiche das feinabgestimmte Modell mit dem Originalmodell

Klicke auf Vergleichsmodus um den LoRA-Adapter und das Originalmodell zu vergleichen.

🦥 Unsloth Core (codebasiert) Leitfaden

Wir haben kostenlose Notebooks für Gemma 4 erstellt:

E4B (Inferenz + Text)	E4B (Vision + Text)	E4B (Audio)
31B (Kaggle)	E2B (Vision + Text)	E2B (Audio)

Und für Reinforcement Learning (RL): E2B (RL GRPO)

Wir haben auch Notebooks für die größeren Gemma-4-Modelle erstellt, aber sie benötigen A100:

Gemma-4-26B-A4B - A100-GPU	Gemma-4-31B - A100-GPU

Wenn du GRPO, funktioniert es in Unsloth, wenn du die schnelle vLLM-Inferenz deaktivierst und stattdessen Unsloth-Inferenz verwendest. Folge unseren Vision-RL Notebook-Beispielen.

Unten findest du ein eigenständiges Gemma-4-26B-A4B-it-Text-SFT-Rezept. Dies ist nur Text – siehe auch unseren Vision-Fine-Tuning Abschnitt für weitere Details.

from unsloth import FastModel
import torch

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/gemma-4-26B-A4B-it", # Ändere dies zu unsloth/gemma-4-E2B-it usw
    dtype = None, # None für automatische Erkennung
    max_seq_length = 8192, # Wähle beliebig für langen Kontext!
    load_in_4bit = True,  # 4-Bit-Quantisierung, um Speicher zu reduzieren
    full_finetuning = False, # [NEU!] Wir haben jetzt Full Fine-Tuning!
    # token = "YOUR_HF_TOKEN", # HF-Token für geschützte Modelle
)

"""# Gemma 4 kann Text, Vision und Audio verarbeiten!

Erleben wir zuerst, wie Gemma 4 multimodale Eingaben verarbeiten kann. Wir verwenden Gemma 4s empfohlene Einstellungen `temperature = 1.0, top_p = 0.95, top_k = 64`
"""

from transformers import TextStreamer
# Hilfsfunktion für Inferenz
def do_gemma_4_inference(messages, max_new_tokens = 128):
    _ = model.generate(
        **tokenizer.apply_chat_template(
            messages,
            add_generation_prompt = True, # Muss für die Generierung hinzugefügt werden
            tokenize = True,
            return_dict = True,
            return_tensors = "pt",
        ).to("cuda"),
        max_new_tokens = max_new_tokens,
        use_cache=True,
        temperature = 1.0, top_p = 0.95, top_k = 64,
        streamer = TextStreamer(tokenizer, skip_prompt = True),
    )

"""# Gemma 4 kann Bilder sehen!

<img src="https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg" alt="Alternativtext" height="256">
"""

sloth_link = "https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg"

messages = [{
    "role" : "user",
    "content": [
        { "type": "image", "image" : sloth_link },
        { "type": "text",  "text" : "In welchen Filmen kommt dieses Tier vor?" }
    ]
}]
# Du musst möglicherweise 1 Minute auf Unsloths Auto-Compiler warten
do_gemma_4_inference(messages, max_new_tokens = 256)

"""Lass uns ein Gedicht über Faultiere schreiben!"""

messages = [{
    "role": "user",
    "content": [{ "type" : "text",
                  "text" : "Schreibe ein Gedicht über Faultiere." }]
}]
do_gemma_4_inference(messages)

"""# Lass uns Gemma 4 feinabstimmen!

Du kannst die Vision- und Textteile zunächst per Auswahl feinabstimmen - der Audioteil kann ebenfalls feinabgestimmt werden - wir arbeiten daran, dass auch er auswählbar wird!

Wir fügen jetzt LoRA-Adapter hinzu, sodass wir nur eine kleine Anzahl von Parametern aktualisieren müssen!
"""

model = FastModel.get_peft_model(
    model,
    finetune_vision_layers     = False, # Für reinen Text ausschalten!
    finetune_language_layers   = True,  # Sollte eingeschaltet bleiben!
    finetune_attention_modules = True,  # Attention gut für GRPO
    finetune_mlp_modules       = True,  # Sollte immer eingeschaltet bleiben!

    r = 8,           # Größer = höhere Genauigkeit, aber könnte überfitten
    lora_alpha = 8,  # Empfohlen: alpha mindestens gleich r
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
)

"""<a name="Data"></a>
### Datenvorbereitung
Wir verwenden jetzt das `Gemma-4`-Format für Fine-Tunes im Gesprächsstil. Wir nutzen den Datensatz [FineTome-100k von Maxime Labonne](https://huggingface.co/datasets/mlabonne/FineTome-100k) im ShareGPT-Stil. Gemma 4 stellt mehrteilige Gespräche wie unten dar:

```
<bos><|turn>user
Hallo<turn|>
<|turn>model
Hallo!<turn|>
```
Wir verwenden unsere Funktion `get_chat_template`, um die richtige Chat-Template zu erhalten. Wir unterstützen `zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, phi3, llama3, phi4, qwen2.5, gemma3, gemma-4` und mehr.
"""

from unsloth.chat_templates import get_chat_template
tokenizer = get_chat_template(
    tokenizer,
    chat_template = "gemma-4-thinking",
)

"""Wir nehmen die ersten 3000 Zeilen des Datensatzes"""

from datasets import load_dataset
dataset = load_dataset("mlabonne/FineTome-100k", split = "train[:3000]")

"""Wir verwenden jetzt `standardize_data_formats`, um zu versuchen, Datensätze für Fine-Tuning-Zwecke in das richtige Format zu konvertieren!"""

from unsloth.chat_templates import standardize_data_formats
dataset = standardize_data_formats(dataset)

"""Schauen wir uns an, wie Zeile 100 aussieht!"""

dataset[100]

"""Wir müssen jetzt das Chat-Template für `Gemma-3` auf die Unterhaltungen anwenden und es in `text` speichern. Wir entfernen das `<bos>`-Token mit removeprefix(`'<bos>'`), da wir ein Fine-Tuning durchführen. Der Processor fügt dieses Token vor dem Training hinzu und das Modell erwartet nur eines."""

def formatting_prompts_func(examples):
   convos = examples["conversations"]
   texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False).removeprefix('<bos>') for convo in convos]
   return { "text" : texts, }

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

"""Schauen wir uns an, wie das Chat-Template funktioniert hat! Beachte, dass es kein `<bos>`-Token gibt, da der Processor-Tokenizer eines hinzufügen wird."""

dataset[100]["text"]

"""<a name="Train"></a>
### Modell trainieren
Jetzt trainieren wir unser Modell. Wir machen 60 Schritte, um es zu beschleunigen, aber du kannst `num_train_epochs=1` für einen vollständigen Durchlauf setzen und `max_steps=None` ausschalten.
"""

from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    eval_dataset = None, # Evaluation kann eingerichtet werden!
    args = SFTConfig(
        dataset_text_field = "text",
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4, # GA verwenden, um die Batchgröße zu simulieren!
        warmup_steps = 5,
        # num_train_epochs = 1, # Für einen vollständigen Trainingsdurchlauf setzen.
        max_steps = 60,
        learning_rate = 2e-4, # Für lange Trainingsläufe auf 2e-5 reduzieren
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.001,
        lr_scheduler_type = "linear",
        seed = 3407,
        report_to = "none", # TrackIO/WandB usw. verwenden
    ),
)

"""Wir verwenden auch Unsloths `train_on_completions`-Methode, um nur auf den Ausgaben des Assistenten zu trainieren und den Loss auf die Eingaben des Benutzers zu ignorieren. Das hilft, die Genauigkeit von Fine-Tunes zu verbessern!"""

from unsloth.chat_templates import train_on_responses_only
trainer = train_on_responses_only(
    trainer,
    instruction_part = "<|turn>user\n",
    response_part = "<|turn>model\n",
)

"""Lassen Sie uns überprüfen, dass das Maskieren des Instruktionsteils erledigt ist! Lassen Sie uns die 100. Zeile noch einmal ausgeben. Beachten Sie, dass das Sample wie erwartet nur ein einzelnes `<bos>` hat!"""

tokenizer.decode(trainer.train_dataset[100]["input_ids"] )

"""Geben wir jetzt das maskierte Beispiel aus – Sie sollten sehen, dass nur die Antwort vorhanden ist:"""

tokenizer.decode([tokenizer.pad_token_id if x == -100 else x for x in trainer.train_dataset[100]["labels"]]).replace(tokenizer.pad_token, " ")

"""# Lassen Sie uns das Modell trainieren!

Um einen Trainingslauf fortzusetzen, setzen Sie `trainer.train(resume_from_checkpoint = True)`
"""

trainer_stats = trainer.train()

Wenn Ihnen der Speicher ausgeht:

• Reduzieren Sie per_device_train_batch_size auf 1 und/oder reduzieren Sie max_seq_length.

• Behalten Sie use_gradient_checkpointing="unsloth" aktiviert (es ist darauf ausgelegt, den VRAM-Verbrauch zu senken und die Kontextlänge zu erhöhen).

Ladebeispiel für MoE (bf16 LoRA):

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,     # MoE QLoRA nicht empfohlen, dense 31B ist in Ordnung
    load_in_16bit = True,     # bf16/16-Bit-LoRA
    full_finetuning = False,
)

Sobald es geladen ist, fügen Sie LoRA-Adapter hinzu und trainieren ähnlich wie im SFT-Beispiel oben.

Verstärkendes Lernen (RL)

Sie können Gemma 4 jetzt mit RL, GSPO, GRPO usw. mit unserem kostenlosen Notebook.

Gemma 4 E2B RL funktioniert mit 9 GB.

Google Colabcolab.research.google.com

Das Ziel des Notebooks ist es, Gemma 4 beizubringen, Sudoku-Rätsel mit GRPO.

Das Modell wird eine Strategie entwickeln, um leere Felder auszufüllen, und wir belohnen es für korrekte Platzierungen und das Lösen gültiger Rätsel.

Sie können Gemma 4 RL mit Unsloth ausführen, auch wenn es von vLLM nicht unterstützt wird, indem Sie fast_inference=False beim Laden des Modells setzen:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-4-E2B-it",
    fast_inference=False,
)

MoE-Finetuning (26B-A4B)

Das 26B-A4B Modell ist der Mittelweg zwischen Geschwindigkeit und Qualität im Gemma-4-Portfolio. Da es ein MoE Modell ist, bei dem pro Token nur ein Teil der Parameter aktiv ist, ist ein konservativer Finetuning-Ansatz:

• verwenden Sie LoRA anstatt vollständigem Finetuning

• bevorzugen Sie 16-Bit- / bf16-LoRA wenn der Speicher es zulässt

• beginnen Sie zuerst mit kürzeren Kontexten und kleineren Rängen

• skalieren Sie erst hoch, wenn die Pipeline stabil ist

Wenn Ihr Ziel die höchste Qualität ist und Sie mehr Speicher haben, verwenden Sie 31B stattdessen.

Multimodales Finetuning (E2B / E4B)

Da E2B und E4B unterstützen Bild und Audio, sind sie die wichtigsten Gemma-4-Varianten für multimodales Finetuning.

• laden Sie das multimodale Modell mit FastVisionModel

• behalten Sie finetune_vision_layers = False zuerst

• finetunen Sie zunächst nur die Sprach-, Attention- und MLP-Schichten

• aktivieren Sie Bild- oder Audioschichten später, wenn Ihre Aufgabe dies erfordert

Gemma-4-Multimodal-LoRA-Beispiel:

from unsloth import FastVisionModel # FastLanguageModel für LLMs
import torch

model, processor = FastVisionModel.from_pretrained(
    "unsloth/gemma-4-26B-A4B-it",
    load_in_4bit = True, # Verwenden Sie 4-Bit, um den Speicherverbrauch zu senken. False für 16-Bit-LoRA.
    use_gradient_checkpointing = "unsloth", # True oder "unsloth" für langen Kontext
)

"""Wir fügen jetzt LoRA-Adapter für parameter-effizientes Finetuning hinzu, wodurch wir nur 1 % aller Modellparameter effizient trainieren können.

**[NEU]** Wir unterstützen außerdem das Finetuning nur der Bildkomponente, nur der Sprachkomponente oder beider. Zusätzlich können Sie wählen, ob Sie die Attention-Module, die MLP-Schichten oder beides finetunen möchten!
"""

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False, wenn Bildschichten nicht finetuned werden
    finetune_language_layers   = True, # False, wenn Sprachschichten nicht finetuned werden
    finetune_attention_modules = True, # False, wenn Attention-Schichten nicht finetuned werden
    finetune_mlp_modules       = True, # False, wenn MLP-Schichten nicht finetuned werden

    r = 32,                           # Je größer, desto höher die Genauigkeit, aber möglicherweise Overfitting
    lora_alpha = 32,                  # Empfohlen: alpha == r, mindestens
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Wir unterstützen rank-stabilisiertes LoRA
    loftq_config = None,               # Und LoftQ
    target_modules = "all-linear",    # Jetzt optional! Bei Bedarf kann eine Liste angegeben werden
)

"""<a name="Data"></a>
### Datenvorbereitung
Wir verwenden einen Stichprobensatz handschriftlicher mathematischer Formeln. Das Ziel ist es, diese Bilder in ein maschinenlesbares Format – genauer gesagt LaTeX – umzuwandeln, damit sie gerendert werden können. Das ist besonders nützlich für komplexe Ausdrücke.

Sie können auf den Datensatz [hier](https://huggingface.co/datasets/unsloth/LaTeX_OCR) zugreifen. Der vollständige Datensatz ist [hier](https://huggingface.co/datasets/linxy/LaTeX_OCR).
"""

from datasets import load_dataset
dataset = load_dataset("unsloth/LaTeX_OCR", split = "train")

"""Verschaffen wir uns einen Überblick über den Datensatz. Wir betrachten das zweite Bild und die dazugehörige Beschriftung."""

dataset

dataset[2]["image"]

dataset[2]["text"]

"""Wir können LaTeX auch direkt im Browser rendern!"""

from IPython.display import display, Math, Latex

latex = dataset[3]["text"]
display(Math(latex))

"""Um den Datensatz zu formatieren, sollten alle Vision-Finetuning-Aufgaben diesem Format folgen:

```python
[
    {
        "role": "user",
        "content": [
            {"type": "text", "text": instruction},
            {"type": "image", "image": sample["image"]},
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": instruction},
            {"type": "image", "image": sample["image"]},
        ],
    },
]
```
"""

instruction = "Schreibe die LaTeX-Darstellung für dieses Bild."

def convert_to_conversation(sample):
    conversation = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": instruction},
                {"type": "image", "image": sample["image"]},
            ],
        },
        {"role": "assistant", "content": [{"type": "text", "text": sample["text"]}]},
    ]
    return {"messages": conversation}
pass

"""Lassen Sie uns den Datensatz in das „korrekte“ Format für das Finetuning umwandeln:"""

converted_dataset = [convert_to_conversation(sample) for sample in dataset]

"""Das erste Beispiel ist nun wie unten strukturiert:"""

converted_dataset[0]

"""Nehmen wir die Gemma-4-Instruktions-Chatvorlage und verwenden sie in unserem Basismodell"""

from unsloth import get_chat_template

processor = get_chat_template(
    processor,
    "gemma-4-thinking"
)

"""Vor dem Finetuning bewerten wir die Leistung des Basismodells. Wir erwarten keine starken Ergebnisse, da es diese Chatvorlage bisher noch nicht gesehen hat."""

image = dataset[2]["image"]
instruction = "Schreibe die LaTeX-Darstellung für dieses Bild."

messages = [
    {
        "role": "user",
        "content": [{"type": "image"}, {"type": "text", "text": instruction}],
    }
]
input_text = processor.apply_chat_template(messages, add_generation_prompt = True)
inputs = processor(
    image,
    input_text,
    add_special_tokens = False,
    return_tensors = "pt",
).to("cuda")

from transformers import TextStreamer

text_streamer = TextStreamer(processor, skip_prompt = True)
result = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 128,
                        use_cache = True, temperature = 1.0, top_p = 0.95, top_k = 64)

"""Man sieht, dass es absolut schrecklich ist! Es befolgt überhaupt keine Anweisungen

<a name="Train"></a>
### Modell trainieren
Jetzt trainieren wir unser Modell. Wir machen 60 Schritte, um die Dinge zu beschleunigen, aber Sie können `num_train_epochs=1` für einen vollständigen Lauf setzen und `max_steps=None` deaktivieren. Wir unterstützen auch `DPOTrainer` und `GRPOTrainer` für verstärkendes Lernen!!

Wir verwenden unseren neuen `UnslothVisionDataCollator`, der uns bei unserem Vision-Finetuning-Setup hilft.
"""

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

trainer = SFTTrainer(
    model = model,
    train_dataset = converted_dataset,
    processing_class = processor.tokenizer,
    data_collator = UnslothVisionDataCollator(model, processor),
    args = SFTConfig(
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        max_grad_norm = 0.3,
        warmup_ratio = 0.03,
        max_steps = 60,
        # num_train_epochs = 2, # Setzen Sie dies statt max_steps für vollständige Trainingsläufe
        learning_rate = 2e-4,
        logging_steps = 1,
        save_strategy = "steps",
        optim = "adamw_8bit",
        weight_decay = 0.001,
        lr_scheduler_type = "cosine",
        seed = 3407,
        output_dir = "outputs",
        report_to = "none", # Für Weights and Biases oder andere

        # Sie MÜSSEN die folgenden Punkte für Vision-Finetuning angeben:
        remove_unused_columns = False,
        dataset_text_field = "",
        dataset_kwargs = {"skip_prepare_dataset": True},
        max_length = 2048,
    )
)

trainer_stats = trainer.train()

Bildbeispielformat

Denken Sie daran: Bei multimodalen Gemma-4-Prompts das Bild vor die Textanweisung setzen.

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "image", "image": "/path/to/image OR object"},
        {"type": "text", "text": "Extrahiere den gesamten Text aus diesem Beleg. Gib Positionen, Gesamtsumme, Händler und Datum als JSON zurück."}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "{\"merchant\": \"Beispielgeschäft\", \"total\": \"19.99\"}"}
      ]
    }
  ]
}

Audio-Beispielformat

Audio ist für E2B / E4B nur gedacht. Halten Sie Clips kurz und auf die Aufgabe zugeschnitten.

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "audio", "audio": "/path/to/audio OR object"},
        {"type": "text", "text": "Transkribiere den folgenden Sprachabschnitt auf Englisch in englischen Text. Gib nur die Transkription aus."}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "Hallo zusammen und willkommen zurück."}
      ]
    }
  ]
}

Speichern / Export des feinabgestimmten Modells

Sie können unsere speziellen Inferenz- / Bereitstellungsanleitungen für Unsloth Studio, llama.cpp, vLLM, llama-server, Ollama oder SGLang.

Als GGUF speichern

Unsloth unterstützt das direkte Speichern in GGUF:

model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")

Oder GGUFs zu Hugging Face pushen:

model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")

Wenn sich das exportierte Modell in einer anderen Laufzeitumgebung schlechter verhält, kennzeichnet Unsloth die häufigste Ursache: falsche Chatvorlage / EOS-Token zur Inferenzzeit (Sie müssen dieselbe Chatvorlage verwenden, mit der Sie trainiert haben).

Für weitere Details lesen Sie unsere Inferenzanleitungen:

🖥️Inferenz & BereitstellungGGUF & llama.cpp

Model ExportvLLM

Best Practices für Gemma-4-Daten

Gemma 4 hat einige Formatierungsdetails, die Sie beachten müssen.

1. Verwenden Sie standardmäßige Chat-Rollen

Gemma 4 verwendet die Standardrollen:

• system

• user

• assistant

Das bedeutet, dass Ihr SFT-Datensatz im normalen Chatformat und nicht in älteren Gemma-spezifischen Rollenformaten geschrieben sein sollte.

2. Der Denkmodus ist explizit

Wenn Sie das Denkstil-Verhalten während des SFT beibehalten möchten:

• halten Sie das Format konsistent

• entscheiden Sie, ob Sie trainieren möchten auf sichtbaren Denkschritten oder auf nur Endantworten

• tun Sie nicht mehrere inkompatible Denkformate im selben Datensatz mischen

Für die meisten produktiven Assistenten ist die einfachste Einrichtung, auf dem nur auf die endgültige sichtbare Antwort.

3. Regel für mehrere Gesprächsrunden

Behalten Sie bei Gesprächen mit mehreren Runden nur die endgültige sichtbare Antwort im Gesprächsverlauf. Tun Sie nicht frühere Denkschritte nicht in spätere Runden zurück.