# Gemma 3 - Guide d'exécution Google publie Gemma 3 avec un nouveau modèle de 270M et les tailles précédentes de 1B, 4B, 12B et 27B. Les modèles 270M et 1B sont uniquement textuels, tandis que les modèles plus grands gèrent à la fois le texte et la vision. Nous fournissons des GGUF, ainsi qu'un guide sur la façon de les exécuter efficacement, et comment affiner et faire [RL](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide) avec Gemma 3 ! {% hint style="success" %} **NOUVEAU 14 août 2025 Mise à jour :** Essayez notre fine-tuning [Carnet Gemma 3 (270M)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(270M\).ipynb) et [GGUFs pour exécuter](https://huggingface.co/collections/unsloth/gemma-3-67d12b7e8816ec6efa7e4e5b). Voir aussi notre [Guide Gemma 3n](https://unsloth.ai/docs/fr/modeles/tutorials/gemma-3-how-to-run-and-fine-tune/gemma-3n-how-to-run-and-fine-tune). {% endhint %} Tutoriel d’exécutionTutoriel d’affinage **Unsloth est le seul framework qui fonctionne sur des machines float16 pour l'inférence et l'entraînement de Gemma 3.** Cela signifie que les notebooks Colab avec GPU Tesla T4 gratuits fonctionnent aussi ! * Affinez Gemma 3 (4B) avec prise en charge de la vision en utilisant notre [notebook Colab gratuit](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\)-Vision.ipynb) {% hint style="info" %} Selon l'équipe Gemma, la configuration optimale pour l'inférence est\ `temperature = 1.0, top_k = 64, top_p = 0.95, min_p = 0.0` {% endhint %} **Téléversements Unsloth Gemma 3 avec configurations optimales :** | GGUF | Unsloth Dynamic 4-bit Instruct | Instruct 16 bits | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | | | ## :gear: Paramètres d’inférence recommandés Selon l'équipe Gemma, les paramètres officiels recommandés pour l'inférence sont : * 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 `\n`sauts de ligne rendus (sauf pour le dernier) {% code overflow="wrap" %} ``` user Hello! model Hey there! user What is 1+1? model\n ``` {% endcode %} {% hint style="danger" %} llama.cpp et d'autres moteurs d'inférence ajoutent automatiquement un \ - NE PAS ajouter DEUX jetons \ ! Vous devez ignorer le \ lors de l'envoi d'invite au modèle ! {% endhint %} ### ✨Exécuter Gemma 3 sur votre téléphone Pour exécuter les modèles sur votre téléphone, nous recommandons d'utiliser n'importe quelle application mobile capable d'exécuter des GGUF localement sur des appareils edge comme les téléphones. Après le fine-tuning, vous pouvez l'exporter en GGUF puis l'exécuter localement sur votre téléphone. Assurez-vous que votre téléphone dispose de suffisamment de RAM/puissance pour traiter les modèles car il peut surchauffer ; nous recommandons donc d'utiliser Gemma 3 270M ou les modèles Gemma 3n pour ce cas d'utilisation. Vous pouvez essayer le [projet open-source AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) application mobile que vous pouvez télécharger sur [Android ici](https://play.google.com/store/apps/details?id=com.anythingllm) ou [ChatterUI](https://github.com/Vali-98/ChatterUI), qui sont d'excellentes applications pour exécuter des GGUFs sur votre téléphone. {% hint style="success" %} N'oubliez pas, vous pouvez changer le nom du modèle 'gemma-3-27b-it-GGUF' pour n'importe quel modèle Gemma comme 'gemma-3-270m-it-GGUF:Q8\_K\_XL' pour tous les tutoriels. {% endhint %} ## :llama: Tutoriel : Comment exécuter Gemma 3 dans Ollama 1. Installer `ollama` si vous ne l’avez pas encore fait ! ```bash apt-get update apt-get install pciutils -y curl -fsSL https://ollama.com/install.sh | sh ``` 2. Exécutez le modèle ! Notez que vous pouvez appeler `ollama serve`dans 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 ! Vous pouvez changer le nom du modèle 'gemma-3-27b-it-GGUF' pour n'importe quel modèle Gemma comme 'gemma-3-270m-it-GGUF:Q8\_K\_XL'. ```bash ollama run hf.co/unsloth/gemma-3-27b-it-GGUF:Q4_K_XL ``` ## 📖 Tutoriel : Comment exécuter Gemma 3 27B dans llama.cpp 1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). 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. ```bash 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 ``` 2. 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` ```bash ./llama.cpp/llama-mtmd-cli \ -hf unsloth/gemma-3-4b-it-GGUF:Q4_K_XL ``` 3. **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 BF16 en pleine précision). Plus de versions sur : ```python # !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-3-27b-it-GGUF", local_dir = "unsloth/gemma-3-27b-it-GGUF", allow_patterns = ["*Q4_K_XL*", "mmproj-BF16.gguf"], # Pour Q4_K_M ) ``` 4. Exécutez le test Flappy Bird d’Unsloth 5. Modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur de contexte (Gemma 3 prend en charge une longueur de contexte de 128K !), `--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. 6. Pour le mode conversation : ```bash ./llama.cpp/llama-mtmd-cli \ --model unsloth/gemma-3-27b-it-GGUF/gemma-3-27b-it-Q4_K_XL.gguf \ --mmproj unsloth/gemma-3-27b-it-GGUF/mmproj-BF16.gguf \ --ctx-size 16384 \ --n-gpu-layers 99 \ --seed 3407 \ --prio 2 \ --temp 1.0 \ --repeat-penalty 1.0 \ --min-p 0.01 \ --top-k 64 \ --top-p 0.95 ``` 7. Pour le mode non conversationnel pour tester Flappy Bird : ```bash ./llama.cpp/llama-cli \ --model unsloth/gemma-3-27b-it-GGUF/gemma-3-27b-it-Q4_K_XL.gguf \ --ctx-size 16384 \ --n-gpu-layers 99 \ --seed 3407 \ --prio 2 \ --temp 1.0 \ --repeat-penalty 1.0 \ --min-p 0.01 \ --top-k 64 \ --top-p 0.95 \ -no-cnv \ --prompt "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.\nmodel\n" ``` L'entrée complète de notre blog 1.58bit est : {% hint style="danger" %} N'oubliez pas de supprimer \ car Gemma 3 ajoute automatiquement un \ ! {% endhint %} {% code overflow="wrap" %} ``` user Créez un jeu Flappy Bird en Python. Vous devez inclure ces éléments : 1. Vous devez utiliser pygame. 2. La couleur de fond doit être choisie au hasard et être une teinte claire. Commencez avec un bleu clair. 3. Appuyer plusieurs fois sur ESPACE accélérera l'oiseau. 4. La forme de l'oiseau doit être choisie aléatoirement parmi carré, cercle ou triangle. La couleur doit être choisie aléatoirement et être sombre. 5. Placez en bas un morceau de terrain coloré en brun foncé ou jaune choisi au hasard. 6. Affichez un score en haut à droite. Incrémentez-le si vous passez les tuyaux sans les toucher. 7. Créez des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé, marron clair ou une teinte gris foncé. 8. Lorsque vous perdez, affichez le meilleur score. Faites apparaître le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant de nouveau sur ESPACE. Le jeu final doit être dans une section markdown en Python. Vérifiez votre code pour les erreurs ``` {% endcode %} ## :sloth: Fine-tuning de Gemma 3 dans Unsloth **Unsloth est le seul framework qui fonctionne sur des machines float16 pour l'inférence et l'entraînement de Gemma 3.** Cela signifie que les notebooks Colab avec GPU Tesla T4 gratuits fonctionnent aussi ! * Essayez notre nouveau [Carnet Gemma 3 (270M)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(270M\).ipynb) qui rend le modèle de 270M paramètres très performant pour jouer aux échecs et peut prédire le prochain coup aux échecs. * Affinez Gemma 3 (4B) en utilisant nos notebooks pour : [**Texte**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\).ipynb) ou [**Vision**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\)-Vision.ipynb) * Ou affinez [Gemma 3n (E4B)](https://unsloth.ai/docs/fr/modeles/tutorials/gemma-3-how-to-run-and-fine-tune/gemma-3n-how-to-run-and-fine-tune) avec [Texte](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Conversational.ipynb) • [Vision](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Vision.ipynb) • [Audio](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Audio.ipynb) {% hint style="warning" %} Lors de l'essai d'un fine-tune complet (FFT) de Gemma 3, toutes les couches passent par défaut en float32 sur des appareils float16. Unsloth s'attend à du float16 et remonte dynamiquement. Pour corriger, exécutez `model.to(torch.float16)` après le chargement, ou utilisez un GPU avec prise en charge du bfloat16. {% endhint %} ### Correctifs de fine-tuning Unsloth Notre solution dans Unsloth est triple : 1. Conserver toutes les activations intermédiaires au format bfloat16 - cela peut être float32, mais cela utilise 2x plus de VRAM ou de RAM (via le checkpointing de gradient asynchrone d'Unsloth) 2. Effectuer toutes les multiplications matricielles en float16 avec les tensor cores, mais en montant/descendant manuellement le type sans l'aide de l'autocast de précision mixte de PyTorch. 3. Monter en float32 toutes les autres options qui n'ont pas besoin de multiplications matricielles (layernorms). ## 🤔 Analyse des correctifs Gemma 3

Gemma 3 1B à 27B dépassent le maximum de float16 qui est 65504

D'abord, avant d'affiner ou d'exécuter Gemma 3, nous avons constaté que lors de l'utilisation de la précision mixte float16, les gradients et **les activations deviennent infinis** malheureusement. Cela se produit sur les GPU T4, la série RTX 20x et les V100 où ils n'ont que des tensor cores float16. Pour les GPU plus récents comme les RTX 30x ou supérieurs, A100, H100, etc., ces GPU disposent de tensor cores bfloat16, donc ce problème n'apparaît pas ! **Mais pourquoi ?**

Wikipedia https://en.wikipedia.org/wiki/Bfloat16_floating-point_format

Le float16 ne peut représenter que des nombres jusqu'à **65504**, tandis que le bfloat16 peut représenter des nombres énormes jusqu'à **10^38** ! Mais remarquez que les deux formats numériques n'utilisent que 16 bits ! C'est parce que le float16 alloue plus de bits pour mieux représenter de petites décimales, tandis que le bfloat16 ne représente pas bien les fractions. Mais pourquoi le float16 ? Utilisons simplement le float32 ! Mais malheureusement le float32 sur GPU est très lent pour les multiplications matricielles - parfois 4 à 10x plus lent ! Nous ne pouvons donc pas faire cela.