Gemma 3n : Comment exécuter et affiner

Exécutez le nouveau Gemma 3n de Google localement avec des GGUFs 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 désormais exécuter et affiner Gemma-3n-E4B et E2B localement en utilisant Unsloth.

Affinez Gemma 3n avec notre notebook Colab gratuit

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

Tutoriel d’exécutionTutoriel d’affinageCorrections + Analyse technique

Uploads Unsloth Gemma 3n (Instruct) avec configurations optimales :

GGUF dynamique 2.0 (texte uniquement)	Instruct dynamique 4 bits (pour affiner)	Instruct 16 bits
2B 4B	2B 4B	2B 4B

Voir tous nos uploads Gemma 3n incluant la base et d'autres formats dans notre collection ici.

🖥️ Exécution de Gemma 3n

Actuellement Gemma 3n est uniquement pris en charge au 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 officiels recommandés

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 discussion avec \nsauts de 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 quelques correctifs 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. Installer 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 upload 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 la dernière llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement de l'inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d'habitude - le support Metal est activé par défaut.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/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). C’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échargez 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 la précision complète BF16).

# !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. Modifier --threads 32 pour le nombre de threads CPU, --ctx-size 32768 pour la longueur du contexte (Gemma 3 prend en charge une longueur de contexte de 32K !), --n-gpu-layers 99 pour le déchargement sur GPU du nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous avez uniquement 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 \
    --min-p 0.00 \
    --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 \
    --min-p 0.00 \
    --top-k 64 \
    --top-p 0.95 \
    -no-cnv \
    --prompt "<start_of_turn>user\nCréez un jeu Flappy Bird en Python. Vous devez inclure ces éléments :\n1. Vous devez utiliser pygame.\n2. La couleur d'arrière-plan doit être choisie aléatoirement et être une teinte claire. Commencez par une couleur bleu clair.\n3. Appuyer plusieurs fois sur SPACE accélérera l'oiseau.\n4. La forme de l'oiseau doit être choisie aléatoirement comme un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement comme une couleur foncée.\n5. Placez en bas une terre colorée en brun foncé ou jaune choisie aléatoirement.\n6. Affichez un score en haut à droite. Incrémentez si vous passez les tuyaux et ne les heurtez pas.\n7. Faites des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé ou brun clair ou une teinte de gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Placez le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant à nouveau sur SPACE.\nLe jeu final doit être dans une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<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 pour fonctionner sur GPU 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 Notebook audio uniquement

• Vision : Affinez Gemma 3n-E4B avec notre Notebook 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 cadre 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 Tesla T4 gratuites fonctionnent aussi ! Globalement, Unsloth rend l'entraînement de Gemma 3n 1,5x plus rapide, consomme 50 % de VRAM en moins et permet des longueurs de contexte 4x plus longues.

Nos notebooks Colab gratuits Gemma 3n par défaut affinent les couches textuelles. Si vous souhaitez affiner également les couches vision ou audio, sachez que cela nécessitera beaucoup plus de VRAM - au-delà des 15 Go que Colab ou Kaggle fournissent gratuitement. Vous pouvez pouvez toujours affiner toutes les couches incluant audio et vision et Unsloth vous permet aussi d'affiner uniquement des zones spécifiques, comme seulement 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 linguistiques
    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 Notebook Vision pour Gemma 3 (4B) donc le voici :

• Affinez Gemma 3 (4B) avec support 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.

🐛 Corrections pour Gemma 3n

✨Problèmes & corrections GGUF

Merci 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. La 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. La per_layer_token_embd la couche devrait être Q8_0 en précision. Toute précision inférieure ne fonctionne pas correctement et provoque 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 également utiliser Q4_0, Q4_1, Q5_0, Q5_1 pour les embeddings - et nous avons confirmé que cela fonctionne également dans Ollama ! Cela signifie qu'encore une fois 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 GPU FP16 (par ex., Tesla T4 dans Colab).

Nos corrections précédentes pour Gemma 3 sont discutées 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 tout de même rencontré des infinis !

Pour comprendre l'origine de ces infinis, nous avons tracé les valeurs absolues maximales des entrées de poids pour Gemma 3N, et nous constatons ce qui suit :

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

Ci-dessous se trouve un tableau des poids Conv2D ayant de grandes magnitudes. Notre hypothèse est que pendant une opération Conv2D, de grands poids se multiplient et s'additionnent, et malheureusement dépassent par hasard la plage maximale du float16 de 65504. Bfloat16 convient, 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 le 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 l'autocast à la volée pour remonter les poids et les entrées en float32, et ainsi nous effectuons l'accumulation en float32 dans le cadre même de la multiplication de matrices, sans avoir à remonter les poids.

Unsloth est le seul cadre qui permet l'inférence et l'entraînement de Gemma 3n sur des GPU float16, donc les notebooks Colab avec Tesla T4 gratuites 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, ce qui aurait pu réduire significativement l'utilisation de la VRAM, puisqu'il ne peut pas être appliqué à l'encodeur Vision.

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

🌵Pertes élevées lors de l'affinage

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

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

2. Les modèles multimodaux semblent toujours exhiber ce comportement - nous avons constaté que la perte de Llama 3.2 Vision commence à 3 ou 4, Pixtral autour de 8, et Qwen 2.5 VL aussi autour de 4. Comme Gemma 3N inclut aussi l'audio, cela peut amplifier la perte de départ. Mais ce n'est qu'une hypothèse. Nous avons également constaté que la quantification de Qwen 2.5 VL 72B Instruct donne 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 de si spécial avec Gemma 3n, demandez-vous ? Il est basé sur Matryoshka Transformer ou MatFormer architecture signifiant que chaque couche/bloc transformer intègre/imbrique des FFN de tailles progressivement plus petites. Pensez-y comme des tasses de plus en plus petites empilées les unes dans les autres. L'entraînement est réalisé de sorte qu'à l'inférence vous puissiez choisir la taille souhaitée et tirer le meilleur de la performance des modèles plus grands.

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

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

Vous pouvez aussi choisir de mélanger et assortir où vous sélectionnez par exemple, S/4 un sous-bloc de taille S/2 d'une autre couche et S/8 d'un autre bloc de taille. 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. C'est essentiellement comme choisir votre propre structure à chaque couche. Ainsi, en entraînant seulement un modèle d'une taille particulière, vous créez exponentiellement de nombreux modèles de tailles plus petites. Aucun apprentissage n'est perdu. 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