> 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 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](#bug-fixes--tips) (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)](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 [Unsloth Studio](/docs/de/neu/studio.md)✨ Notebook: Du kannst dir auch [weitere Notebooks hier ansehen](#unsloth-core-code-based-guide). {% endcolumn %} {% column %} {% embed url="" %} {% endcolumn %} {% endcolumns %} * Du kannst Gemma 4 auch mit [Reinforcement Learning](#reinforcement-learning-rl) (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. ### :bug: Fehlerbehebungen + Tipps {% hint style="success" %} 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** {% endhint %} #### :grapes:Gradient Accumulation könnte deine Verluste aufblähen {% columns %} {% column %}
{% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} 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: #### :interrobang:IndexError bei der Inferenz von Gemma-4 31B und 26B-A4B Du könntest diesen Fehler bei der Inferenz mit 31B und 26B sehen: ```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] ``` 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`. #### :no\_entry: `use_cache = True` Die Generierung war Kauderwelsch für E2B, E4B [Siehe Issue](https://github.com/huggingface/transformers/issues/45242) "\[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) ``` #### :radio: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: ```python RuntimeError: Wert kann ohne Überlauf nicht in den Typ c10::Half konvertiert werden ``` Dies 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 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.
```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" : "Was ist 2+2?"},
   ], tokenize = False, enable_thinking = True, add_generation_prompt = True)
Wird ausgeben `<|turn>system\n<|think|>\n<|turn>user\nWas ist 2+2?\n<|turn>model\n`
Thinking deaktiviert: ```python processor.tokenizer.apply_chat_template([ {"role" : "user", "content" : "Was ist 2+2?"}, ], tokenize = False, enable_thinking = False, add_generation_prompt = True) ``` Wird ausgeben `<|turn>user\nWas ist 2+2?\n<|turn>model\n<|channel>thought\n` 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](#saving-export-your-fine-tuned-model) (für llama.cpp/Unsloth/Ollama/usw.) ### ⚡Schnellstart #### 🦥 Unsloth Studio-Leitfaden {% 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 und auf NVIDIA-GPUs trainieren. Intel-, MLX- und AMD-Trainingsunterstützung kommt noch diesen Monat. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Unsloth installieren Im Terminal ausführen: **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 geht 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 %} #### 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.
{% endstep %} {% step %} #### 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.
{% endstep %} {% step %} #### Exportiere dein feinabgestimmtes Modell Sobald es fertig ist, kannst du das Modell mit Unsloth Studio in GGUF-, Safetensor- usw\.-Formate exportieren.
{% endstep %} {% step %} #### Vergleiche das feinabgestimmte Modell mit dem Originalmodell Klicke auf `Vergleichsmodus` um den LoRA-Adapter und das Originalmodell zu vergleichen.
{% endstep %} {% endstepper %} #### 🦥 Unsloth Core (codebasiert) Leitfaden 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 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)**, funktioniert es in Unsloth, wenn du die schnelle vLLM-Inferenz deaktivierst und stattdessen 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 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! Alternativtext """ 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, ) """ ### 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: ``` <|turn>user Hallo <|turn>model Hallo! ``` 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 ``-Token mit removeprefix(`''`), 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('') 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 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 `` 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() ```` {% endcode %} {% hint style="info" %} 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`](/docs/de/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)`="unsloth"` aktiviert (es ist darauf ausgelegt, den VRAM-Verbrauch zu senken und die Kontextlänge zu erhöhen). {% 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, 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](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 mit [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 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: {% 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) 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: {% 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, # 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 ) """ ### 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 ### 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() ```` {% endcode %} #### Bildbeispielformat Denken Sie daran: Bei multimodalen Gemma-4-Prompts das Bild **vor** die Textanweisung setzen. {% 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\": \"Beispielgeschäft\", \"total\": \"19.99\"}"} ] } ] } ``` {% endcode %} #### Audio-Beispielformat Audio ist für **E2B / E4B** nur gedacht. Halten Sie 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 in 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 Sie können 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 in 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, 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: {% 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 %} ### 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. --- # 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.