> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/gemma-4/train.md). # Gemma 4 Fine-Tuning-Leitfaden Du kannst jetzt Googles [Gemma 4](https://unsloth.ai/docs/models/gemma-4) 12B, E2B, E4B, 26B-A4B und 31B mit [**Unsloth**](https://github.com/unslothai/unsloth). Unsloth unterstützt das Fine-Tuning für Vision, Text, Audio und RL für Gemma 4. * Unsloth trainiert Gemma 4 **ca. 1,5x schneller** mit **ca. 60 % weniger VRAM** als FA2-Setups (kein Genauigkeitsverlust) * Wir haben viele allgemeine [Fehler beim Training von Gemma 4 behoben](#bug-fixes--tips) (nicht von Unsloth abgeleitet). * Gemma 4 E2B trainiert auf **8 GB VRAM**. E4B benötigt 10 GB VRAM. SchnellstartFehlerbehebungen + Tipps Gemma 4 feinabstimmen über unsere **kostenlosen** **Google-Colab-Notebooks**: | [ (Unsloth)](https://colab.research.google.com/github/unslothai/unsloth/blob/main/studio/Unsloth_Studio_Colab.ipynb) | [**31B** (Kaggle)](https://www.kaggle.com/code/danielhanchen/gemma4-31b-unsloth) | [E4B **(Vision + Text)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E4B\)-Vision.ipynb) | [E4B **(Audio)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E4B\)-Audio.ipynb) | [E2B **(RL GRPO)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E2B\)_Reinforcement_Learning_Sudoku_Game.ipynb) | | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | {% columns %} {% column %} Du kannst Gemma 4 kostenlos mit einer UI in unserem ausführen und trainieren [Unsloth Studio](/docs/de/neu/studio.md)✨ Notizbuch: Du kannst weitere [Notebooks hier ansehen](#unsloth-core-code-based-guide). {% endcolumn %} {% column %} {% embed url="" %} {% endcolumn %} {% endcolumns %} * Du kannst Gemma 4 auch mit [bestärkendem Lernen](#reinforcement-learning-rl) (RL) auf 9 GB VRAM trainieren. * Gemma 4 E2B LoRA läuft 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**/Speichern von Modellen als GGUF usw. und vollständiges Fine-Tuning **(FFT)** funktioniert ebenfalls. ### :bug: Fehlerbehebungen + Tipps {% hint style="success" %} Wenn du **siehst, dass Gemma-4 E2B und E4B einen Loss von 13–15 haben, 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 darunter. Vision ist 2x höher, also 3–5** {% endhint %} #### :grapes:Gradient Accumulation könnte deine Verluste aufblähen {% columns %} {% column %}
{% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} Wenn du Verluste über 13–15 siehst (z. B. 100 oder 300), wird die Gradient Accumulation höchstwahrscheinlich nicht korrekt berücksichtigt - wir haben **das als Teil von Unsloth und Unsloth Studio behoben.** Mehr über Gradient Accumulation erfährst du in unserem Blog zur Fehlerbehebung bei Gradient Accumulation: #### :interrobang:IndexError bei der Inferenz von Gemma-4 31B und 26B-A4B Dieser Fehler kann bei der Inferenz mit 31B und 26B auftreten: ```python 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: ```python if hasattr(decoder_config, "num_kv_shared_layers"): layer_types = layer_types[: -decoder_config.num_kv_shared_layers] ``` Dabei werden Gemma-4 31B und 26B-A4B mit `num_kv_shared_layers = 0`. In Python, `-0 == 0`, daher `layer_types[:-0]` wird zu `layer_types[:0] == []`. Der Cache wird mit null Layer-Slots aufgebaut, und der allererste Attention-Forward-Lauf crasht in `Cache.update`. #### :no\_entry: `use_cache = True` die Generierung für E2B, E4B war Kauderwelsch [Siehe Issue](https://github.com/huggingface/transformers/issues/45242) "\[Gemma 4] `use_cache=False` verfälscht die Attention-Berechnung und erzeugt Müll-Logits #45242" Gemma-4 E2B und E4B teilen den KV-Zustand ü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 zum Wiederverwenden ablegen. Wenn `use_cache=False` (wie es jedes QLoRA-Tutorial setzt und wie `gradient_checkpointing=True` erzwingt), `Gemma4TextModel.forward` überspringt den Cache-Aufbau, sodass die KV-geteilten Layer dazu übergehen, 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 unserer Behebung:** ``` use_cache=True -> '1 + 1 = **2**' use_cache=False -> '1 + 1 = **2**' max_abs_logit_diff: 0.000000 (bitgenaue Übereinstimmung, alle 9 Tokens identisch) ``` #### :radio:Audio-float16-Überlauf `Gemma4AudioAttention` verwendet `config.attention_invalid_logits_value = -1e9` in einem `masked_fill` Auf fp16 (Tesla T4) führt -1e9 zu einem Überlauf des fp16-Maximums von 65504, was Folgendes verursacht: ```python RuntimeError: value cannot be converted to type c10::Half without overflow ``` Das lag an `self.config.attention_invalid_logits_value` : ```python 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 Denkfähigkeit beibehalten** möchtest, kannst du Beispiele im Denkstil mit direkten Antworten mischen (halte mindestens 75 % Denkanteil ein). Andernfalls kannst du es vollständig ausgeben.\n\nVerwende `gemma-4` für das Chat-Template ohne Thinking und `gemma-4-thinking` für die Thinking-Variante.\nVerwende die Thinking-Variante für die größeren 26B- und 31B-Modelle und die Nicht-Thinking-Variante für die kleinen.
```python 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" : "What is 2+2?"},
   ], tokenize = False, enable_thinking = True, add_generation_prompt = True)
Wird ausgeben `<|turn>system\n<|think|>\n<|turn>user\nWhat is 2+2?\n<|turn>model\n`
Thinking deaktiviert: ```python processor.tokenizer.apply_chat_template([ {"role" : "user", "content" : "What is 2+2?"}, ], tokenize = False, enable_thinking = False, add_generation_prompt = True) ``` Wird ausgeben `<|turn>user\nWhat is 2+2?\n<|turn>model\n<|channel>thought\n` 3. Gemma 4 ist leistungsstark für multilinguales Fine-Tuning, da es 140 Sprachen unterstützt. 4. Es wird empfohlen, zu trainieren **E4B QLoRA** anstatt **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](#saving-export-your-fine-tuned-model) (für llama.cpp/Unsloth/Ollama usw.) ### ⚡Schnellstart #### 🦥 Unsloth Studio-Anleitung {% columns %} {% column %} Gemma 4 kann ausgeführt und feinabgestimmt werden in [Unsloth Studio](/docs/de/neu/studio.md), unserer neuen Open-Source-Web-UI für lokale KI. Mit Unsloth Studio kannst du Modelle lokal auf **MacOS, Windows**, Linux ausführen und auf NVIDIA-GPUs trainieren. Intel-, MLX- und AMD-Trainingssupport kommt diesen Monat. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Unsloth installieren Führe in deinem Terminal aus: **MacOS, Linux, WSL:** ```bash curl -fsSL https://unsloth.ai/install.sh | sh ``` **Windows PowerShell:** ```bash irm https://unsloth.ai/install.ps1 | iex ``` {% hint style="success" %} **Die Installation ist schnell und dauert ca. 1–2 Minuten.** {% endhint %} {% endstep %} {% step %} #### Unsloth starten **MacOS, Linux, WSL und Windows:** ```bash unsloth studio -H 0.0.0.0 -p 8888 ``` **Dann öffne `http://localhost:8888` in deinem Browser.** {% endstep %} {% step %} #### Trainiere Gemma 4 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 das gewünschte Modell und den gewünschten Datensatz aus. Passe anschließend deine Hyperparameter und die Kontextlänge nach Bedarf an.
{% endstep %} {% step %} #### Trainingsfortschritt überwachen Nachdem du auf das Starten des Trainings geklickt hast, kannst du den Trainingsfortschritt des Modells überwachen und beobachten. Der Trainings-Loss sollte stetig sinken.\nSobald es fertig ist, wird das Modell automatisch gespeichert.
{% endstep %} {% step %} #### Dein feinabgestimmtes Modell exportieren Sobald es fertig ist, ermöglicht dir Unsloth Studio, das Modell in GGUF-, safetensor- usw. Formate zu exportieren.
{% endstep %} {% step %} #### Feinabgestimmtes Modell mit Originalmodell vergleichen Klicke auf `Vergleichsmodus` um den LoRA-Adapter und das Originalmodell zu vergleichen.
{% endstep %} {% endstepper %} #### 🦥 Unsloth Core (codebasiert) Anleitung Wir haben kostenlose Notebooks für Gemma 4 erstellt: | [E4B **(Inferenz + Text)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E4B\)-Text.ipynb) | [E4B **(Vision + Text)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E4B\)-Vision.ipynb) | [E4B **(Audio)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E4B\)-Audio.ipynb) | | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | | [**31B** (Kaggle)](https://www.kaggle.com/code/danielhanchen/gemma4-31b-unsloth) | [E2B **(Vision + Text)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E2B\)-Vision.ipynb) | [E2B **(Audio)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E2B\)-Audio.ipynb) | Und für Reinforcement Learning (RL): [E2B **(RL GRPO)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E2B\)_Reinforcement_Learning_Sudoku_Game.ipynb) Wir haben auch Notebooks für die größeren Gemma-4-Modelle erstellt, aber sie benötigen eine A100: | [Gemma-4-26B-A4B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(26B_A4B\)-Vision.ipynb) - A100-GPU | [Gemma-4-31B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(31B\)-Vision.ipynb) - A100-GPU | | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | {% hint style="info" %} **Wenn du** [**GRPO**](/docs/de/loslegen/reinforcement-learning-rl-guide.md)**machen möchtest, funktioniert es in Unsloth, wenn du die schnelle vLLM-Inferenz deaktivierst und stattdessen die Unsloth-Inferenz verwendest. Folge unseren** [**Vision-RL**](/docs/de/loslegen/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md) **Notebook-Beispielen.** {% endhint %} Unten findest du ein eigenständiges Gemma-4-26B-A4B-it-Text-SFT-Rezept. Dies ist nur Text – siehe auch unseren [Vision-Fine-Tuning](/docs/de/grundlagen/vision-fine-tuning.md) Abschnitt für weitere Details. {% code expandable="true" %} ````python 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 einen Wert für langen Kontext! load_in_4bit = True, # 4-Bit-Quantisierung zur Reduzierung des Speichers full_finetuning = False, # [NEU!] Wir haben jetzt vollständiges Fine-Tuning! # token = "YOUR_HF_TOKEN", # HF-Token für gesperrte Modelle ) """# Gemma 4 kann Text, Vision und Audio verarbeiten! Lass uns zuerst erleben, wie Gemma 4 multimodale Eingaben verarbeiten kann. Wir verwenden die empfohlenen Einstellungen von Gemma 4: `temperature = 1.0, top_p = 0.95, top_k = 64` """ from transformers import TextStreamer # Hilfsfunktion für die 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! Alt text """ 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) """Lasst uns ein Gedicht über Faultiere machen!""" 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 vorerst per Auswahl feinabstimmen - der Audio-Teil kann ebenfalls feinabgestimmt werden - wir arbeiten daran, ihn ebenfalls auswählbar zu machen! 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 nur Text ausschalten! finetune_language_layers = True, # Sollte aktiviert bleiben! finetune_attention_modules = True, # Attention gut für GRPO finetune_mlp_modules = True, # Sollte immer aktiviert bleiben! r = 8, # Größer = höhere Genauigkeit, könnte aber überfitten lora_alpha = 8, # Empfohlen ist mindestens alpha == r lora_dropout = 0, bias = "none", random_state = 3407, ) """ ### Datenvorbereitung Wir verwenden jetzt das `Gemma-4`-Format für Conversation-Style-Finetunes. Wir verwenden den Datensatz [FineTome-100k von Maxime Labonne](https://huggingface.co/datasets/mlabonne/FineTome-100k) im ShareGPT-Stil. Gemma-4 stellt mehrstufige Unterhaltungen wie unten dar: ``` <|turn>user Hallo <|turn>model Hallo! ``` Wir verwenden unsere `get_chat_template`-Funktion, um das 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 nun das Chat-Template für `Gemma-3` auf die Unterhaltungen anwenden und es in `text` speichern. Wir entfernen das ``-Token mit removeprefix(`''`), da wir 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('') 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 ``-Token gibt, da der Processor-Tokenizer eines hinzufügen wird.""" dataset[100]["text"] """ ### Modell trainieren Jetzt trainieren wir unser Modell. Wir machen 60 Schritte, um die Sache zu beschleunigen, aber du kannst `num_train_epochs=1` für einen vollständigen Durchlauf setzen und `max_steps=None` deaktivieren. """ from trl import SFTTrainer, SFTConfig trainer = SFTTrainer( model = model, tokenizer = tokenizer, train_dataset = dataset, eval_dataset = None, # Kann Evaluation einrichten! args = SFTConfig( dataset_text_field = "text", per_device_train_batch_size = 1, gradient_accumulation_steps = 4, # Verwende GA, um die Batch-Größe zu simulieren! warmup_steps = 5, # num_train_epochs = 1, # Dafür auf 1 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", # Verwende TrackIO/WandB usw. ), ) """Wir verwenden auch Unsloths `train_on_completions`-Methode, um nur auf den Ausgaben des Assistenten zu trainieren und den Loss auf die Eingaben des Nutzers zu ignorieren. Das hilft, die Genauigkeit von Fine-Tunes zu erhöhen!""" 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", ) """Lass uns überprüfen, ob das Maskieren des Instruktionsteils funktioniert hat! Lass uns die 100. Zeile noch einmal ausgeben. Beachte, dass das Beispiel wie erwartet nur ein einziges `` enthält!""" tokenizer.decode(trainer.train_dataset[100]["input_ids"]) """Jetzt drucken wir das maskierte Beispiel aus - du solltest 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, " ") """# Lass uns das Modell trainieren! Um einen Trainingslauf fortzusetzen, setze `trainer.train(resume_from_checkpoint = True)` """ trainer_stats = trainer.train() ```` {% endcode %} {% hint style="info" %} Wenn dir der Speicher ausgeht: * Reduziere `per_device_train_batch_size` zu **1** und/oder reduziere `max_seq_length`. * Behalte `use_`[`gradient_checkpointing`](/docs/de/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)`="unsloth"` an (es ist dafür ausgelegt, den VRAM-Verbrauch zu reduzieren und die Kontextlänge zu verlängern). {% endhint %} **Ladebeispiel für MoE (bf16 LoRA):** ```python 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, dichter 31B ist in Ordnung load_in_16bit = True, # bf16/16-bit LoRA full_finetuning = False, ) ``` Sobald es geladen ist, fügst du LoRA-Adapter hinzu und trainierst ähnlich wie im obigen SFT-Beispiel. ### Verstärkendes Lernen (RL) Du kannst Gemma 4 jetzt mit RL, GSPO, GRPO usw. mit [unserem kostenlosen Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)_Vision_GRPO.ipynb). {% columns %} {% column %} Gemma 4 E2B RL funktioniert mit 9 GB. {% embed url="" %} Das Ziel des Notebooks ist es, Gemma 4 beizubringen, Sudoku-Rätsel mithilfe von [GRPO](/docs/de/loslegen/reinforcement-learning-rl-guide.md#from-rlhf-ppo-to-grpo-and-rlvr). Das Modell wird eine Strategie entwickeln, um leere Felder auszufüllen, und wir belohnen es für korrekte Platzierungen und das Vervollständigen gültiger Rätsel. Du kannst Gemma 4 RL mit Unsloth ausführen, obwohl es von vLLM nicht unterstützt wird, indem du `fast_inference=False` beim Laden des Modells festlegst: {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} ```python from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name="unsloth/gemma-4-E2B-it", fast_inference=False, ) ``` ### MoE-Finetuning (26B-A4B) Der **26B-A4B** ist in der Gemma-4-Reihe der Mittelweg zwischen Geschwindigkeit und Qualität. Da es ein **MoE** Modell ist, bei dem pro Token nur ein Teil der Parameter aktiv ist, ist ein konservativer Ansatz fürs Finetuning: * verwende **LoRA** statt eines vollständigen Fine-Tunings * bevorzuge **16-Bit- / bf16-LoRA** wenn der Speicher es zulässt * beginne zuerst mit kürzeren Kontexten und kleineren Rängen * skaliere erst hoch, wenn die Pipeline stabil ist Wenn dein Ziel die höchste Qualität ist und du mehr Speicher hast, verwende stattdessen **31B** . ### Multimodales Finetuning (E2B / E4B) Da **E2B** und **E4B** Unterstützung für **Bilder** und **Audio**, sind sie die wichtigsten Gemma-4-Varianten für multimodales Finetuning. * lade das multimodale Modell mit `FastVisionModel` * behalte `finetune_vision_layers = False` zuerst * fine-tune nur die Sprach-, Attention- und MLP-Schichten * aktiviere Vision- oder Audioschichten später, falls deine Aufgabe es erfordert #### Gemma 4 Multimodal-LoRA-Beispiel: {% code expandable="true" %} ````python 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, # Verwende 4-Bit, um den Speicherverbrauch zu reduzieren. False für 16-Bit-LoRA. use_gradient_checkpointing = "unsloth", # True oder "unsloth" für langen Kontext ) """Wir fügen nun LoRA-Adapter für parameter-effizientes Fine-Tuning hinzu, wodurch wir nur 1 % aller Modellparameter effizient trainieren können. **[NEU]** Wir unterstützen außerdem das Fine-Tuning nur der Vision-Komponente, nur der Sprach-Komponente oder beider. Zusätzlich kannst du wählen, ob du die Attention-Module, die MLP-Schichten oder beides feinabstimmen möchtest! """ model = FastVisionModel.get_peft_model( model, finetune_vision_layers = True, # False, wenn die Vision-Schichten nicht feinabgestimmt werden finetune_language_layers = True, # False, wenn die Sprachschichten nicht feinabgestimmt werden finetune_attention_modules = True, # False, wenn die Attention-Schichten nicht feinabgestimmt werden finetune_mlp_modules = True, # False, wenn die MLP-Schichten nicht feinabgestimmt werden r = 32, # Je größer, desto höher die Genauigkeit, aber es kann zu Overfitting kommen lora_alpha = 32, # Empfohlen: alpha == r mindestens lora_dropout = 0, bias = "none", random_state = 3407, use_rslora = False, # Wir unterstützen rankstabilisiertes LoRA loftq_config = None, # Und LoftQ target_modules = "all-linear", # Jetzt optional! Kann bei Bedarf eine Liste angegeben werden ) """ ### Datenvorbereitung Wir verwenden einen Stichprobensatz handgeschriebener mathematischer Formeln. Das Ziel ist es, diese Bilder in ein vom Computer lesbares Format zu überführen – genauer gesagt in LaTeX –, damit sie gerendert werden können. Das ist besonders nützlich für komplexe Ausdrücke. Du kannst 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") """Lass uns einen Überblick über den Datensatz gewinnen. Wir betrachten das zweite Bild und seine entsprechende 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-Fine-Tuning-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 """Lass uns den Datensatz in das "korrekte" Format fürs Finetuning umwandeln:""" converted_dataset = [convert_to_conversation(sample) for sample in dataset] """Das erste Beispiel ist nun wie unten strukturiert:""" converted_dataset[0] """Lass uns die Gemma-4-Instruction-Chat-Vorlage nehmen und sie in unserem Basismodell verwenden""" from unsloth import get_chat_template processor = get_chat_template( processor, "gemma-4-thinking" ) """Bevor wir das Fine-Tuning durchführen, lassen wir uns die Leistung des Basismodells bewerten. Wir erwarten keine starken Ergebnisse, da es diese Chat-Vorlage 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 ### Modell trainieren Jetzt trainieren wir unser Modell. Wir machen 60 Schritte, um die Sache zu beschleunigen, aber du kannst `num_train_epochs=1` für einen vollständigen Durchlauf setzen und `max_steps=None` deaktivieren. Wir unterstützen außerdem `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, # Setze dies anstelle von 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 # Diese folgenden Punkte MUSST du fürs Vision-Finetuning angeben: remove_unused_columns = False, dataset_text_field = "", dataset_kwargs = {"skip_prepare_dataset": True}, max_length = 2048, ) ) trainer_stats = trainer.train() ```` {% endcode %} #### Bildbeispielformat Denk daran: Bei Gemma-4-Multimodal-Prompts platziere das Bild **vor** der Textanweisung. {% code expandable="true" %} ```json { "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\": \"Example Store\", \"total\": \"19.99\"}"} ] } ] } ``` {% endcode %} #### Audio-Beispielformat Audio ist nur für **E2B / E4B** gedacht. Halte die Clips kurz und auf die Aufgabe zugeschnitten. {% code expandable="true" %} ```json { "messages": [ { "role": "user", "content": [ {"type": "audio", "audio": "/path/to/audio OR object"}, {"type": "text", "text": "Transkribiere den folgenden Sprachabschnitt auf Englisch als englischen Text. Gib nur die Transkription aus."} ] }, { "role": "assistant", "content": [ {"type": "text", "text": "Hallo zusammen und willkommen zurück."} ] } ] } ``` {% endcode %} ### Speichern / Export des feinabgestimmten Modells Du kannst unsere speziellen Inferenz-/Bereitstellungsanleitungen für [Unsloth Studio](/docs/de/neu/studio/export.md), [llama.cpp](/docs/de/grundlagen/inference-and-deployment/saving-to-gguf.md), [vLLM](/docs/de/grundlagen/inference-and-deployment/vllm-guide.md), [llama-server](/docs/de/grundlagen/inference-and-deployment/llama-server-and-openai-endpoint.md), [Ollama](/docs/de/grundlagen/inference-and-deployment/saving-to-ollama.md) oder [SGLang](/docs/de/grundlagen/inference-and-deployment/sglang-guide.md). #### Als GGUF speichern Unsloth unterstützt das direkte Speichern als GGUF: ```python 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: ```python 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, markiert Unsloth die häufigste Ursache: **falsche Chat-Vorlage / EOS-Token zur Inferenzzeit** (du musst dieselbe Chat-Vorlage verwenden, mit der du trainiert hast). Für weitere Details lies unsere Inferenzanleitungen: {% columns %} {% column width="50%" %} {% content-ref url="/pages/03532de69dfe0230fe5114e809721d8b7dd74ca6" %} [Inferenz & Bereitstellung](/docs/de/grundlagen/inference-and-deployment.md) {% endcontent-ref %} {% content-ref url="/pages/9cfeafb2cc359999e3a7f6ba6ffa5468e4752653" %} [GGUF & llama.cpp](/docs/de/grundlagen/inference-and-deployment/saving-to-gguf.md) {% endcontent-ref %} {% endcolumn %} {% column width="50%" %} {% content-ref url="/pages/13c9d0063a9732a68734b74792f3e30153873bf4" %} [Model Export](/docs/de/neu/studio/export.md) {% endcontent-ref %} {% content-ref url="/pages/af094159d1c157db0d9afc00bd98b849fcdb8f0c" %} [vLLM](/docs/de/grundlagen/inference-and-deployment/vllm-guide.md) {% endcontent-ref %} {% endcolumn %} {% endcolumns %} ### Gemma 4 Best Practices für Daten Gemma 4 hat einige Formatierungsdetails, die du beachten musst. #### 1. Verwende standardmäßige Chat-Rollen Gemma 4 verwendet die Standardrollen: * `system` * `user` * `assistant` Das bedeutet, dass dein SFT-Datensatz im normalen Chat-Format statt in älteren Gemma-spezifischen Rollenformaten geschrieben sein sollte. #### 2. Der Denkmodus ist explizit Wenn du das Denkstil-Verhalten während SFT beibehalten möchtest: * halte das Format konsistent * entscheide, ob du auf **sichtbare Denkblöcke** oder auf **nur endgültige Antworten** * ja **nicht** mehrere inkompatible Denkformate im selben Datensatz mischen Für die meisten produktiven Assistenten ist die einfachste Einrichtung, nur auf die **endgültige sichtbare Antwort**. #### 3. Die Regel für mehrere Gesprächsrunden Bei Gesprächen über mehrere Runden hinweg behalte nur die **endgültige sichtbare Antwort** im Gesprächsverlauf. Gib **nicht** frühere Denkblöcke nicht in spätere Runden zurück. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://unsloth.ai/docs/de/modelle/gemma-4/train.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.