✨Gemma 3n : Comment exécuter & affiner

Exécutez le nouveau Gemma 3n de Google localement avec des GGUF dynamiques sur llama.cpp, Ollama, Open WebUI et affinez avec Unsloth !

Le modèle multimodal Gemma 3n de Google gère les entrées image, audio, vidéo et texte. Disponible en tailles 2B et 4B, il prend en charge 140 langues pour les tâches textuelles et multimodales. Vous pouvez maintenant exécuter et affiner Gemma-3n-E4B et E2B localement en utilisant Unsloth.

Affinez Gemma 3n avec notre notebook Colab gratuit

Gemma 3n a longueur de contexte 32K, entrée audio de 30s, OCR, reconnaissance automatique de la parole (ASR) et traduction vocale via des invites.

Tutoriel d'exécutionTutoriel de fine-tuningCorrectifs + Analyse technique

Téléversements Unsloth Gemma 3n (Instruct) avec configurations optimales :

GGUF Dynamic 2.0 (texte uniquement)	Instruct dynamique 4-bit (pour affiner)	Instruct 16-bit
2B 4B	2B 4B	2B 4B

Voir tous nos téléversements Gemma 3n incluant la base et d'autres formats dans notre collection ici.

🖥️ Exécution de Gemma 3n

Actuellement Gemma 3n est seulement pris en charge en format texte pour l'inférence.

Nous avons corrigé des problèmes avec des GGUF qui ne fonctionnaient pas correctement uniquement dans Ollama. Veuillez retélécharger si vous utilisez Ollama.

⚙️ Paramètres recommandés officiels

Selon l'équipe Gemma, les paramètres officiels recommandés pour l'inférence :

temperature = 1.0, top_k = 64, top_p = 0.95, min_p = 0.0

• Température de 1.0

• Top_K de 64

• Min_P de 0,00 (optionnel, mais 0,01 fonctionne bien, la valeur par défaut de llama.cpp est 0,1)

• Top_P de 0.95

• Pénalité de répétition de 1.0. (1.0 signifie désactivé dans llama.cpp et transformers)

• Modèle de chat :

  <bos><start_of_turn>user\nHello!<end_of_turn>\n<start_of_turn>model\nHey there!<end_of_turn>\n<start_of_turn>user\nWhat is 1+1?<end_of_turn>\n<start_of_turn>model\n

• Modèle de chat avec \nretours à la ligne rendus (sauf pour le dernier)

<bos><start_of_turn>user
Hello!<end_of_turn>
<start_of_turn>model
Hey there!<end_of_turn>
<start_of_turn>user
What is 1+1?<end_of_turn>
<start_of_turn>model\n

llama.cpp et d'autres moteurs d'inférence ajoutent automatiquement un <bos> - NE PAS ajouter DEUX jetons <bos> ! Vous devez ignorer le <bos> lors de l'envoi d'invite au modèle !

🦙 Tutoriel : Comment exécuter Gemma 3n dans Ollama

Veuillez retélécharger les quants Gemma 3N ou supprimer les anciens via Ollama car il y a des corrections de bugs. Vous pouvez faire ce qui suit pour supprimer l'ancien fichier et le rafraîchir :

ollama rm hf.co/unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL

ollama run hf.co/unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL

1. Installez ollama si vous ne l'avez pas encore fait !

apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh

1. Exécutez le modèle ! Notez que vous pouvez appeler ollama servedans un autre terminal s'il échoue ! Nous incluons toutes nos corrections et paramètres suggérés (température, etc.) dans params dans notre téléversement Hugging Face !

ollama run hf.co/unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL

📖 Tutoriel : Comment exécuter Gemma 3n dans llama.cpp

Nous tenons d'abord à remercier Xuan-Son Nguyen de Hugging Face, Georgi Gerganov de l'équipe llama.cpp pour avoir rendu Gemma 3N fonctionnel dans llama.cpp !

1. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggerganov/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=ON -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp

1. Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_XL) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). Ceci est similaire à ollama run

./llama.cpp/llama-cli -hf unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL -ngl 99 --jinja

1. OU télécharger le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir Q4_K_M, ou d'autres versions quantifiées (comme BF16 pleine précision).

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/gemma-3n-E4B-it-GGUF",
    local_dir = "unsloth/gemma-3n-E4B-it-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*", "mmproj-BF16.gguf"], # Pour Q4_K_XL
)

1. Exécutez le modèle.

2. éditer --threads 32 pour le nombre de threads CPU, --ctx-size 32768 pour la longueur de contexte (Gemma 3 prend en charge une longueur de contexte de 32K !), --n-gpu-layers 99 pour le déchargement GPU sur le nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n'avez qu'une inférence CPU.

3. Pour le mode conversation :

./llama.cpp/llama-cli \
    --model unsloth/gemma-3n-E4B-it-GGUF/gemma-3n-E4B-it-UD-Q4_K_XL.gguf \
    --ctx-size 32768 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 1.0 \
    --repeat-penalty 1.0 \
    sans réflexion
    --top-k 64 \
    --top-p 0.95

1. Pour le mode non conversationnel pour tester Flappy Bird :

./llama.cpp/llama-cli \
    --model unsloth/gemma-3n-E4B-it-GGUF/gemma-3n-E4B-it-UD-Q4_K_XL.gguf \
    --ctx-size 32768 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 1.0 \
    --repeat-penalty 1.0 \
    sans réflexion
    --top-k 64 \
    --top-p 0.95 \
    -no-cnv \
    --prompt "<start_of_turn>user\nCreate a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<end_of_turn>\n<start_of_turn>model\n"

N'oubliez pas de supprimer <bos> car Gemma 3N ajoute automatiquement un <bos> !

🦥 Affinage de Gemma 3n avec Unsloth

Gemma 3n, comme Gemma 3, avait des problèmes de fonctionnement sur GPUs float16 tels que les Tesla T4 dans Colab. Vous rencontrerez des NaN et des infinis si vous ne corrigez pas Gemma 3n pour l'inférence ou l'affinage. Plus d'informations ci-dessous.

• Affinez Gemma 3n-E4B avec notre notebook Colab gratuit

• Audio : Affinez Gemma 3n-E4B avec notre Carnet audio uniquement

• Vision : Affinez Gemma 3n-E4B avec notre Carnet vision uniquement

Nous avons également constaté que, parce que l'architecture unique de Gemma 3n réutilise les états cachés dans l'encodeur de vision, cela pose une autre particularité intéressante avec le Gradient Checkpointing décrit ci-dessous

Unsloth est le seul framework qui fonctionne sur des machines float16 pour l'inférence et l'entraînement de Gemma 3n. Cela signifie que les notebooks Colab avec des GPUs Tesla T4 gratuits fonctionnent aussi ! Globalement, Unsloth rend l'entraînement de Gemma 3n 1,5x plus rapide, utilise 50 % de VRAM en moins et offre des longueurs de contexte 4x plus longues.

Nos notebooks Colab Gemma 3n gratuits sont par défaut configurés pour affiner les couches textuelles. Si vous souhaitez affiner également les couches vision ou audio, sachez que cela exigera beaucoup plus de VRAM - au-delà des 15 Go fournis gratuitement par Colab ou Kaggle. Vous pouvez pouvez toujours affiner toutes les couches y compris audio et vision et Unsloth vous permet aussi d'affiner seulement des zones spécifiques, comme uniquement la vision. Ajustez simplement selon vos besoins :

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = False, # False si vous n'affinez pas les couches vision
    finetune_language_layers   = True,  # False si vous n'affinez pas les couches 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
)

🏆Contenu bonus

Nous avons aussi entendu que vous vouliez un Carnet Vision pour Gemma 3 (4B) le voici donc :

• Affinez Gemma 3 (4B) avec prise en charge Vision en utilisant notre notebook Colab gratuit

Si vous aimez Kaggle, Google organise une compétition où le meilleur modèle affiné avec Gemma 3n et Unsloth remportera un prix de 10 000 $ ! Voir plus ici.

🐛 Correctifs pour Gemma 3n

✨Problèmes et correctifs GGUF

Grâce aux discussions de Michael de l'équipe Ollama et aussi Xuan de Hugging Face, il y avait 2 problèmes que nous avons dû corriger spécifiquement pour les GGUF :

1. Le add_shared_kv_layers le paramètre a été accidentellement encodé en float32 ce qui est acceptable, mais devient légèrement compliqué à décoder du côté d'Ollama - un simple changement en uint32 résout le problème. Pull request traitant ce problème.

2. Le per_layer_token_embd la couche devrait être en Q8_0 en précision. Tout ce qui est inférieur ne fonctionne pas correctement et génère des erreurs dans le moteur Ollama - pour réduire les problèmes pour notre communauté, nous avons mis tout cela en Q8_0 dans tous les quants - malheureusement cela utilise plus d'espace.

   1. En tant que mise à jour, Matt a mentionné que nous pouvons aussi utiliser Q4_0, Q4_1, Q5_0, Q5_1 pour les embeddings - et nous avons confirmé que cela fonctionne aussi dans Ollama ! Cela signifie encore une fois que les quants plus petits en 2, 3 et 4 bits sont de taille réduite, et n'ont pas besoin de Q8_0 !

♾️Infinis et gradients/activations NaN

Gemma 3n, tout comme Gemma 3, a des problèmes sur les GPUs FP16 (par ex., Tesla T4s dans Colab).

Nos correctifs précédents pour Gemma 3 sont discutés ici. Pour Gemma 3, nous avons constaté que les activations dépassent la plage maximale du float16 de 65504.

Gemma 3N n'a pas ce problème d'activation, mais nous avons quand même rencontré des infinis !

Pour comprendre ces infinis, nous avons tracé les valeurs absolues maximales des poids pour Gemma 3N, et nous voyons ci-dessous :

Nous constatons que les croix vertes sont les poids de convolution Conv2D. On voit que la magnitude des couches Conv2D est en moyenne beaucoup plus grande.

Ci-dessous se trouve un tableau des poids Conv2D qui ont de grandes magnitudes. Notre hypothèse est que lors d'une opération Conv2D, de grands poids se multiplient et se somment ensemble, et malheureusement dépassent par hasard la plage maximale du float16 de 65504. Bfloat16 est acceptable, car sa plage maximale est de 10^38.

Nom	Max
msfa.ffn.pw_proj.conv.weight	98.000000
blocks.2.21.attn.key.down_conv.weight	37.000000
blocks.2.32.pw_exp.conv.weight	34.750000
blocks.2.30.pw_exp.conv.weight	33.750000
blocks.2.34.pw_exp.conv.weight	33.750000

🎇Solution aux infinis

La solution naïve est de remonter en type (upcast) tous les poids Conv2D en float32 (si bfloat16 n'est pas disponible). Mais cela augmenterait l'utilisation de la VRAM. Pour y remédier, nous utilisons plutôt autocast à la volée pour remonter les poids et les entrées en float32, et ainsi effectuer l'accumulation en float32 dans le cadre de la multiplication de matrices elle-même, sans avoir à remonter les poids.

Unsloth est le seul framework qui permet l'inférence et l'entraînement de Gemma 3n sur des GPUs float16, donc les notebooks Colab avec Tesla T4 gratuits fonctionnent !

🏁Problèmes de Gradient Checkpointing

Nous avons trouvé que l'encodeur vision de Gemma 3N est également assez unique car il réutilise les états cachés. Cela limite malheureusement l'utilisation de le gradient checkpointing d'Unsloth, qui aurait pu réduire significativement l'utilisation de la VRAM puisqu'il ne peut pas être appliqué à l'encodeur vision.

Cependant, nous avons quand même réussi à tirer parti de le compilateur automatique d'Unsloth pour optimiser Gemma 3N !

🌵Pertes importantes pendant l'affinage

Nous avons aussi constaté que les pertes sont étonnamment très élevées au début de l'affinage - de l'ordre de 6 à 7, mais elles diminuent rapidement avec le temps. Nous émettons l'hypothèse que cela peut venir de 2 possibilités :

1. Il pourrait y avoir un problème d'implémentation, mais cela est peu probable puisque l'inférence semble fonctionner.

2. Les modèles multimodaux semblent toujours présenter ce comportement - nous avons constaté que la perte de Llama 3.2 Vision commence à 3 ou 4, Pixtral à environ 8, et Qwen 2.5 VL aussi autour de 4. Comme Gemma 3N inclut aussi l'audio, cela pourrait amplifier la perte initiale. Mais ce n'est qu'une hypothèse. Nous avons aussi trouvé que la quantification de Qwen 2.5 VL 72B Instruct donnait des scores de perplexité extrêmement élevés d'environ 30, mais le modèle fonctionne néanmoins correctement.

Affinez Gemma 3n avec notre notebook Colab gratuit

🛠️ Analyse technique

Gemma 3n : MatFormer

Qu'y a-t-il donc de si spécial chez Gemma 3n, demandez-vous ? Il est basé sur Matryoshka Transformer ou MatFormer l'architecture, ce qui signifie que chaque couche/bloc transformer intègre/niche des FFN de tailles progressivement plus petites. Pensez-y comme des tasses de tailles décroissantes imbriquées les unes dans les autres. L'entraînement est fait de sorte qu'au moment de l'inférence vous pouvez choisir la taille souhaitée et tirer le meilleur parti des performances des modèles plus grands.

Il existe également un Per Layer Embedding qui peut être mis en cache pour réduire l'utilisation de la mémoire lors de l'inférence. Ainsi, le modèle 2B (E2B) est un sous-réseau à l'intérieur du modèle 4B (aussi appelé 5.44B) qui est obtenu à la fois par la mise en cache du Per Layer Embedding et en ignorant les composants audio et vision en se concentrant uniquement sur le texte.

L'architecture MatFormer est typiquement entraînée avec des sous-modèles espacés de manière exponentielle, c.-à-d. de tailles S, S/2, S/4, S/8 etc. dans chacune des couches. Ainsi, au moment de l'entraînement, les entrées sont transmises aléatoirement à travers l'un des sous-blocs mentionnés, donnant à chaque sous-bloc la même chance d'apprendre. Maintenant l'avantage est que, au moment de l'inférence, si vous voulez que le modèle fasse 1/4 de la taille originale, vous pouvez choisir S/4 de taille pour les sous-blocs dans chaque couche.

Vous pouvez aussi choisir de mélanger et assortir où vous choisissez par exemple, S/4 un sous-bloc de taille S/2 d'une autre couche et S/8 de taille pour une autre couche. En fait, vous pouvez changer les sous-modèles que vous choisissez en fonction de l'entrée elle-même si vous le souhaitez. En gros c'est comme choisir votre propre structure à chaque couche. Ainsi, en entraînant un modèle d'une taille particulière, vous créez exponentiellement de nombreux modèles de tailles plus petites. Rien n'est perdu dans l'apprentissage. Plutôt ingénieux, non.

Image de Aperçu du modèle Gemma 3n

Affinez et essayez l'inférence multimodale Gemma 3n avec notre notebook Colab gratuit