Guide de fine-tuning de Gemma 4

Entraînez Gemma 4 de Google avec Unsloth.

Vous pouvez désormais entraîner les modèles de Google Gemma 4 12B, E2B, E4B, 26B-A4B et 31B avec Unsloth. Unsloth prend en charge l'affinage vision, texte, audio et RL pour Gemma 4.

• Unsloth entraîne Gemma 4 ~1,5× plus rapide avec ~60 % de VRAM en moins que les configurations FA2 (sans perte de précision)

• Nous avons corrigé de nombreux bugs pour l'entraînement de Gemma 4 (non dérivés d'Unsloth).

• Gemma 4 E2B fonctionne avec 8 Go de VRAM. E4B nécessite 10 Go de VRAM.

Démarrage rapideCorrections de bugs + Conseils

Affinez Gemma 4 via nos gratuits carnets Google Colab:

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

Vous pouvez exécuter et entraîner Gemma 4 gratuitement avec une interface dans notre Unsloth Studio✨ carnet :

Vous pouvez consulter davantage de carnets ici.

Google Colabcolab.research.google.com

• Vous pouvez aussi entraîner Gemma 4 avec l'apprentissage par renforcement (RL) sur 9 Go de VRAM.

• Gemma 4 E2B LoRA fonctionne avec 8 à 10 Go de VRAM. E4B LoRA nécessite 17 Go de VRAM.

• 31B QLoRA fonctionne avec 22 Go et 26B-A4B LoRA nécessite >40 Go

• Exportation/enregistrer les modèles en GGUF, etc. et affinage complet (FFT) fonctionne aussi.

🐛 Corrections de bugs + Conseils

Si vous voyez Gemma-4 E2B et E4B afficher une perte de 13 à 15, c'est tout à fait normal - c'est une particularité courante des modèles multimodaux. Cela s'est aussi produit sur Gemma-3N, Llama Vision, les modèles vision de Mistral et d'autres.

Gemma 26B et 31B ont une perte plus faible, de 1 à 3 ou moins. La vision sera 2 fois plus élevée, donc 3 à 5

🍇L'accumulation des gradients peut augmenter artificiellement vos pertes

Si vous voyez des pertes supérieures à 13-15 (comme 100 ou 300), il est très probable que l'accumulation des gradients ne soit pas correctement prise en compte - nous avons corrigé cela dans Unsloth et Unsloth Studio.

Pour en savoir plus sur l'accumulation des gradients, consultez notre article de correction de bug sur l'accumulation des gradients : https://unsloth.ai/blog/gradient

⁉️IndexError lors de l'inférence de Gemma-4 31B et 26B-A4B

Vous pourriez voir cette erreur lors d'une inférence avec 31B et 26B :

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

La cause est ci-dessous :

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

Or Gemma-4 31B et 26B-A4B sont fournis avec num_kv_shared_layers = 0. En Python, -0 == 0, donc layer_types[:-0] se réduit à layer_types[:0] == []. Le cache est construit avec zéro emplacement de couche et la toute première passe avant d'attention plante dans Cache.update.

⛔ use_cache = True la génération était du charabia pour E2B, E4B

Voir le problème "[Gemma 4] use_cache=False corrompt le calcul de l'attention, produisant des logits incohérents #45242"

Gemma-4 E2B et E4B partagent l'état KV entre les couches (num_kv_shared_layers = 20 et 18). Le cache est le seul endroit où les premières couches stockent le KV pour que les couches ultérieures le réutilisent. Lorsque use_cache=False (comme le définissent tous les tutoriels QLoRA, et comme gradient_checkpointing=True l'impose), Gemma4TextModel.forward saute la construction du cache, donc les couches partageant le KV passent au recalcul local de K et V à partir des états cachés actuels. Les logits deviennent incohérents et la perte d'entraînement diverge.

Avant (unsloth/gemma-4-E2B-it, invite "Combien font 1+1 ?") :

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

Après notre correction :

use_cache=True  -> '1 + 1 = **2**'
use_cache=False -> '1 + 1 = **2**'
max_abs_logit_diff: 0.000000     (parité bit à bit exacte, les 9 jetons sont identiques)

📻Dépassement de capacité en float16 audio

Gemma4AudioAttention utilise config.attention_invalid_logits_value = -1e9 dans un masked_fill appel. Sur fp16 (Tesla T4), -1e9 dépasse la valeur maximale fp16 de 65504, provoquant :

RuntimeError: value cannot be converted to type c10::Half without overflow

Cela était dû à self.config.attention_invalid_logits_value :

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

💡Conseils pour Gemma-4

1. Si vous souhaitez préserver la capacité de raisonnement de raisonnement, vous pouvez mélanger des exemples de type raisonnement avec des réponses directes (conservez au minimum 75 % de raisonnement). Sinon, vous pouvez l'émettre entièrement.\n\nUtilisez gemma-4 pour le modèle de chat sans réflexion et gemma-4-thinking pour la variante avec réflexion.\nUtilisez la version avec réflexion pour les modèles plus grands 26B et 31B, et la version sans réflexion pour les petits modèles.

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

2. Pour activer le mode réflexion, utilisez enable_thinking = True / False dans tokenizer.apply_chat_template

   Réflexion activée :

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

   Affichera <bos><|turn>system\n<|think|><turn|>\n<|turn>user\nCombien font 2+2 ?<turn|>\n<|turn>model\n

   Réflexion désactivée :

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

   Affichera <bos><|turn>user\nCombien font 2+2 ?<turn|>\n<|turn>model\n<|channel>thought\n<channel|>

3. Gemma 4 est puissant pour l'affinage multilingue, car il prend en charge 140 langues.

4. Il est recommandé d'entraîner E4B QLoRA plutôt que E2B LoRA car E4B est plus grand et la différence de précision de quantification est minuscule. Gemma 4 E4B LoRA est encore meilleure.

5. Après l'affinage, vous pouvez exporter vers GGUF (pour llama.cpp/Unsloth/Ollama/etc.)

⚡Démarrage rapide

🦥 Guide d'Unsloth Studio

Gemma 4 peut être exécuté et affiné dans Unsloth Studio, notre nouvelle interface web open source pour l'IA locale.

Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur MacOS, Windows, Linux et entraîner des GPU NVIDIA. La prise en charge de l'entraînement Intel, MLX et AMD arrive ce mois-ci.

1

Installer Unsloth

Exécutez dans votre terminal :

MacOS, Linux, WSL :

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

Windows PowerShell :

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

L'installation sera rapide et prendra environ 1 à 2 minutes.

2

Lancer Unsloth

MacOS, Linux, WSL et Windows :

unsloth studio -H 0.0.0.0 -p 8888

Puis ouvrez http://localhost:8888 dans votre navigateur.

3

Entraîner Gemma 4

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d'accueil pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment.

Recherchez Gemma 4 dans la barre de recherche et sélectionnez le modèle et le jeu de données souhaités. Ensuite, ajustez vos hyperparamètres et la longueur de contexte selon vos besoins.

4

Surveiller la progression de l'entraînement

Après avoir cliqué sur démarrer l'entraînement, vous pourrez surveiller et observer la progression de l'entraînement du modèle. La perte d'entraînement devrait diminuer régulièrement.\nUne fois terminé, le modèle sera automatiquement enregistré.

5

Exportez votre modèle affiné

Une fois terminé, Unsloth Studio vous permet d'exporter le modèle vers des formats GGUF, safetensor, etc.

6

Comparer le modèle affiné au modèle original

Cliquez sur Mode Comparaison pour comparer l'adaptateur LoRA et le modèle original.

🦥 Guide Unsloth Core (basé sur le code)

Nous avons créé des carnets gratuits pour Gemma 4 :

E4B (Inférence + texte)	E4B (Vision + texte)	E4B (Audio)
31B (Kaggle)	E2B (Vision + texte)	E2B (Audio)

Et pour l'apprentissage par renforcement (RL) : E2B (RL GRPO)

Nous avons aussi créé des carnets pour les plus grands modèles Gemma 4, mais ils nécessitent une A100 :

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

Si vous souhaitez faire GRPO, cela fonctionne dans Unsloth si vous désactivez l'inférence rapide vLLM et utilisez l'inférence Unsloth à la place. Suivez nos Vision RL exemples de carnets.

Voici ci-dessous une recette SFT texte autonome pour Gemma-4-26B-A4B-it. Il s'agit uniquement de texte — consultez aussi notre affinage vision section pour plus de détails.

from unsloth import FastModel
import torch

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/gemma-4-26B-A4B-it", # Modifiez ceci en unsloth/gemma-4-E2B-it etc
    dtype = None, # None pour détection automatique
    max_seq_length = 8192, # Choisissez n'importe quelle valeur pour un contexte long !
    load_in_4bit = True,  # Quantification en 4 bits pour réduire la mémoire
    full_finetuning = False, # [NOUVEAU !] Nous avons maintenant l'affinage complet !
    # token = "YOUR_HF_TOKEN", # Jeton HF pour les modèles protégés
)

"""# Gemma 4 peut traiter le texte, la vision et l'audio !

Découvrons d'abord comment Gemma 4 peut gérer les entrées multimodales. Nous utilisons les paramètres recommandés par Gemma 4 : `temperature = 1.0, top_p = 0.95, top_k = 64`
"""

from transformers import TextStreamer
# Fonction utilitaire pour l'inférence
def do_gemma_4_inference(messages, max_new_tokens = 128):
    _ = model.generate(
        **tokenizer.apply_chat_template(
            messages,
            add_generation_prompt = True, # Doit être ajouté pour la génération
            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 peut voir des images !

<img src="https://files.worldwildlife.org/wwfcmsprod/images/Sloth_Sitting_iStock_3_12_2014/story_full_width/8l7pbjmj29_iStock_000011145477Large_mini__1_.jpg" alt="Texte alternatif" 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" : "Quels films cet animal a-t-il tournés ?" }
    ]
}]
# Vous devrez peut-être attendre 1 minute que le compilateur automatique d'Unsloth s'exécute
do_gemma_4_inference(messages, max_new_tokens = 256)

"""Faisons un poème sur les paresseux !"""

messages = [{
    "role": "user",
    "content": [{ "type" : "text",
                  "text" : "Écris un poème sur les paresseux." }]
}]
do_gemma_4_inference(messages)

"""# Affinons Gemma 4 !

Vous pouvez pour l'instant affiner les parties vision et texte par sélection - la partie audio peut aussi être affinée - nous travaillons à la rendre sélectionnable également !

Nous ajoutons maintenant des adaptateurs LoRA afin de n'avoir à mettre à jour qu'un petit nombre de paramètres !
"""

model = FastModel.get_peft_model(
    model,
    finetune_vision_layers     = False, # Désactivez pour le texte uniquement !
    finetune_language_layers   = True,  # Doit rester activé !
    finetune_attention_modules = True,  # L'attention est utile pour GRPO
    finetune_mlp_modules       = True,  # Doit toujours rester activé !

    r = 8,           # Plus grand = précision plus élevée, mais risque de surapprentissage
    lora_alpha = 8,  # alpha recommandé = r au minimum
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
)

"""<a name="Data"></a>
### Préparation des données
Nous utilisons maintenant le format `Gemma-4` pour les affinages de type conversation. Nous utilisons le jeu de données [FineTome-100k de Maxime Labonne](https://huggingface.co/datasets/mlabonne/FineTome-100k) au format ShareGPT. Gemma-4 affiche les conversations multi-tours comme ci-dessous :

```
<bos><|turn>user
Bonjour<turn|>
<|turn>model
Salut !<turn|>
```
Nous utilisons notre fonction `get_chat_template` pour obtenir le bon modèle de chat. Nous prenons en charge `zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, phi3, llama3, phi4, qwen2.5, gemma3, gemma-4` et bien plus encore.
"""

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

"""Nous récupérons les 3000 premières lignes du jeu de données"""

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

"""Nous utilisons maintenant `standardize_data_formats` pour essayer de convertir les jeux de données au bon format en vue de l'affinage !"""

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

"""Voyons à quoi ressemble la ligne 100 !"""

dataset[100]

"""Nous devons maintenant appliquer le modèle de chat `Gemma-3` aux conversations, et l'enregistrer dans `text`. Nous supprimons le jeton `<bos>` à l'aide de removeprefix(`'<bos>'`) puisque nous affinons le modèle. Le processeur ajoutera ce jeton avant l'entraînement et le modèle n'en attend qu'un seul."""

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)

"""Voyons le résultat du modèle de chat ! Notez qu'il n'y a pas de jeton `<bos>` puisque le tokenizer du processeur en ajoutera un."""

dataset[100]["text"]

"""<a name="Train"></a>
### Entraîner le modèle
Maintenant, entraînons notre modèle. Nous effectuons 60 étapes pour accélérer les choses, mais vous pouvez définir `num_train_epochs=1` pour une exécution complète d'entraînement, et désactiver `max_steps=None`.
"""

from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    eval_dataset = None, # Peut configurer l'évaluation !
    args = SFTConfig(
        dataset_text_field = "text",
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4, # Utilisez l'AG pour simuler la taille de lot !
        warmup_steps = 5,
        # num_train_epochs = 1, # Définissez ceci pour une exécution complète d'entraînement.
        max_steps = 60,
        learning_rate = 2e-4, # Réduisez à 2e-5 pour les longues exécutions d'entraînement
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.001,
        lr_scheduler_type = "linear",
        seed = 3407,
        report_to = "none", # Utilisez TrackIO/WandB, etc.
    ),
)

"""Nous utilisons aussi la méthode `train_on_completions` d'Unsloth pour n'entraîner que sur les sorties de l'assistant et ignorer la perte sur les entrées de l'utilisateur. Cela aide à améliorer la précision des affinages !"""

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",
)

"""Vérifions que le masquage de la partie instruction est bien fait ! Imprimons à nouveau la 100e ligne.  Remarquez que l'exemple n'a qu'un seul `<bos>` comme prévu !"""

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

"""Imprimons maintenant l'exemple masqué - vous devriez voir que seule la réponse est présente :"""

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

"""# Entraînons maintenant le modèle !

Pour reprendre un entraînement, définissez `trainer.train(resume_from_checkpoint = True)`
"""

trainer_stats = trainer.train()

Si vous êtes en OOM :

• Réduisez per_device_train_batch_size à 1 et/ou réduisez max_seq_length.

• Conservez use_gradient_checkpointing="unsloth" activé (c’est conçu pour réduire l’utilisation de la VRAM et augmenter la longueur du contexte).

Exemple de chargeur pour MoE (LoRA bf16) :

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,     # La QLoRA MoE n’est pas recommandée, le dense 31B convient
    load_in_16bit = True,     # LoRA bf16/16 bits
    full_finetuning = False,
)

Une fois chargé, vous attacherez des adaptateurs LoRA et entraînerez de manière similaire à l’exemple SFT ci-dessus.

Apprentissage par renforcement (RL)

Vous pouvez maintenant entraîner Gemma 4 avec RL, GSPO, GRPO, etc. avec notre notebook gratuit.

Gemma 4 E2B RL fonctionne sur 9 Go.

Google Colabcolab.research.google.com

Le but du notebook est de faire apprendre à Gemma 4 à résoudre des grilles de Sudoku en utilisant GRPO.

Le modèle élaborera une stratégie pour remplir les cases vides, et nous le récompenserons pour les placements corrects et la résolution de puzzles valides.

Vous pouvez exécuter Gemma 4 RL avec Unsloth même s’il n’est pas pris en charge par vLLM, en définissant fast_inference=False lors du chargement du modèle :

from unsloth import FastLanguageModel

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

Affinage MoE (26B-A4B)

Le 26B-A4B modèle constitue le juste milieu entre vitesse et qualité dans la gamme Gemma 4. Comme il s’agit d’un MoE modèle avec seulement un sous-ensemble de paramètres actifs par jeton, une approche d’affinage prudente consiste à :

• utiliser LoRA plutôt qu’un affinage complet

• privilégier LoRA 16 bits / bf16 si la mémoire le permet

• commencer d’abord avec des contextes plus courts et des rangs plus faibles

• ne monter en échelle qu’une fois le pipeline stabilisé

Si votre objectif est la meilleure qualité possible et que vous disposez de plus de mémoire, utilisez 31B à la place.

Affinage multimodal (E2B / E4B)

Parce que E2B et E4B prennent en charge image et audio, ils constituent les principales variantes de Gemma 4 pour l’affinage multimodal.

• chargez le modèle multimodal avec FastVisionModel

• conservez finetune_vision_layers = False d’abord

• affinez uniquement les couches de langage, d’attention et MLP

• activez ensuite les couches de vision ou d’audio si votre tâche l’exige

Exemple de LoRA multimodale Gemma 4 :

from unsloth import FastVisionModel # FastLanguageModel pour les LLM
import torch

model, processor = FastVisionModel.from_pretrained(
    "unsloth/gemma-4-26B-A4B-it",
    load_in_4bit = True, # Utilisez le 4 bits pour réduire l’utilisation de la mémoire. False pour LoRA 16 bits.
    use_gradient_checkpointing = "unsloth", # True ou "unsloth" pour un long contexte
)

"""Nous ajoutons maintenant des adaptateurs LoRA pour un affinage efficace en paramètres, ce qui nous permet d’entraîner efficacement seulement 1 % de tous les paramètres du modèle.

**[NOUVEAU]** Nous prenons également en charge l’affinage uniquement du composant de vision, uniquement du composant de langage, ou des deux. De plus, vous pouvez choisir d’affiner les modules d’attention, les couches MLP, ou les deux !
"""

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False si vous n’affinez pas les couches de vision
    finetune_language_layers   = True, # False si vous n’affinez pas les couches de langage
    finetune_attention_modules = True, # False si vous n’affinez pas les couches d’attention
    finetune_mlp_modules       = True, # False si vous n’affinez pas les couches MLP

    r = 32,                           # Plus la valeur est grande, plus la précision est élevée, mais cela peut surapprendre
    lora_alpha = 32,                  # L’alpha recommandé est au moins égal à r
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Nous prenons en charge LoRA à rang stabilisé
    loftq_config = None,               # Et LoftQ
    target_modules = "all-linear",    # Facultatif désormais ! Peut spécifier une liste si nécessaire
)

"""<a name="Data"></a>
### Préparation des données
Nous utiliserons un ensemble de données échantillonné de formules mathématiques manuscrites. L’objectif est de convertir ces images dans un format lisible par ordinateur — en particulier LaTeX — afin qu’elles puissent être rendues. C’est particulièrement utile pour les expressions complexes.

Vous pouvez accéder au jeu de données [ici](https://huggingface.co/datasets/unsloth/LaTeX_OCR). Le jeu de données complet est [ici](https://huggingface.co/datasets/linxy/LaTeX_OCR).
"""

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

"""Prenons un aperçu du jeu de données. Nous examinerons la deuxième image et sa légende correspondante."""

dataset

dataset[2]["image"]

dataset[2]["text"]

"""Nous pouvons aussi rendre le LaTeX directement dans le navigateur !"""

from IPython.display import display, Math, Latex

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

"""Pour mettre en forme le jeu de données, toutes les tâches d’affinage vision devraient suivre ce format :

```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 = "Écrivez la représentation LaTeX pour cette image."

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

"""Convertissons le jeu de données dans le format « correct » pour l’affinage :"""

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

"""Le premier exemple est maintenant structuré comme ci-dessous :"""

converted_dataset[0]

"""Prenons le modèle de chat Gemma 4 avec le template d’instructions et utilisons-le dans notre modèle de base"""

from unsloth import get_chat_template

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

"""Avant l’affinage, évaluons les performances du modèle de base. Nous ne nous attendons pas à de très bons résultats, car il n’a encore jamais rencontré ce modèle de chat."""

image = dataset[2]["image"]
instruction = "Écrivez la représentation LaTeX pour cette image."

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)

"""Vous pouvez voir que c’est absolument terrible ! Cela ne suit pas du tout les instructions

<a name="Train"></a>
### Entraîner le modèle
Maintenant, entraînons notre modèle. Nous effectuons 60 étapes pour aller plus vite, mais vous pouvez définir `num_train_epochs=1` pour une exécution complète, et définir `max_steps=None`. Nous prenons également en charge `DPOTrainer` et `GRPOTrainer` pour l’apprentissage par renforcement !!

Nous utilisons notre nouveau `UnslothVisionDataCollator` qui nous aidera dans notre configuration d’affinage vision.
"""

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, # Définissez ceci à la place de max_steps pour des exécutions complètes
        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", # Pour Weights and Biases ou autres

        # Vous DEVEZ mettre les éléments ci-dessous pour l’affinage vision :
        remove_unused_columns = False,
        dataset_text_field = "",
        dataset_kwargs = {"skip_prepare_dataset": True},
        max_length = 2048,
    )
)

trainer_stats = trainer.train()

Format d’exemple d’image

Rappelez-vous : pour les invites multimodales Gemma 4, placez l’image avant l’instruction textuelle.

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "image", "image": "/path/to/image OR object"},
        {"type": "text", "text": "Extrayez tout le texte de ce reçu. Retournez les lignes d’articles, le total, le commerçant et la date sous forme de JSON."}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "{\"merchant\": \"Example Store\", \"total\": \"19.99\"}"}
      ]
    }
  ]
}

Format d’exemple audio

L’audio est pour E2B / E4B uniquement. Gardez les clips courts et spécifiques à la tâche.

{
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "audio", "audio": "/path/to/audio OR object"},
        {"type": "text", "text": "Transcrivez le segment vocal suivant en anglais en texte anglais. Ne renvoyez que la transcription."}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "Bonjour à tous et bon retour."}
      ]
    }
  ]
}

Enregistrement / exportation du modèle affiné

Vous pouvez consulter nos guides spécifiques d’inférence / déploiement pour Unsloth Studio, llama.cpp, vLLM, llama-server, Ollama ou SGLang.

Enregistrer en GGUF

Unsloth prend en charge l’enregistrement direct en 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")

Ou pousser des GGUF vers Hugging Face :

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")

Si le modèle exporté se comporte moins bien dans un autre environnement d’exécution, Unsloth indique la cause la plus fréquente : template de chat incorrect / jeton EOS au moment de l’inférence (vous devez utiliser le même template de chat que celui avec lequel vous avez entraîné).

Pour plus de détails, lisez nos guides d’inférence :

🖥️Inférence et déploiementGGUF & llama.cpp

Model ExportvLLM

Bonnes pratiques pour les données Gemma 4

Gemma 4 comporte quelques détails de formatage à garder à l’esprit.

1. Utilisez les rôles de chat standards

Gemma 4 utilise les rôles standard :

• system

• user

• assistant

Cela signifie que votre jeu de données SFT doit être rédigé dans un format de chat classique plutôt que dans les anciens formats de rôles spécifiques à Gemma.

2. Le mode réflexion est explicite

Si vous souhaitez conserver un comportement de type réflexion pendant le SFT :

• gardez le format cohérent

• décidez si vous voulez entraîner sur des blocs de pensée visibles ou sur les réponses finales uniquement

• faites pas mélanger plusieurs formats de pensée incompatibles dans le même jeu de données

Pour la plupart des assistants de production, la configuration la plus simple consiste à affiner sur la réponse finale visible uniquement.

3. Règle des conversations multi-tours

Pour les conversations multi-tours, ne conservez que la réponse finale visible dans l’historique de conversation. Ne pas réinjectez pas les blocs de pensée précédents dans les tours suivants.