Exécuter la génération et les inférences de contenu Gemma
Lorsque vous souhaitez exécuter un modèle Gemma, vous devez prendre deux décisions clés : 1) quelle variante de Gemma vous souhaitez exécuter et 2) quel framework d'exécution d'IA allez-vous utiliser pour l'exécuter ? Un problème clé pour prendre ces deux décisions concerne le matériel dont vous et vos utilisateurs disposez pour exécuter le modèle.
Cette présentation vous aide à prendre ces décisions et à commencer à travailler avec les modèles Gemma. Pour exécuter un modèle Gemma, procédez comme suit:
Les modèles Gemma sont compatibles avec divers frameworks d'exécution d'IA générative. L'un des principaux facteurs de prise de décision lors de l'exécution d'un modèle Gemma est les ressources informatiques dont vous disposez (ou que vous aurez) pour exécuter le modèle. La plupart des frameworks d'IA compatibles nécessitent du matériel spécialisé, tel que des GPU ou des TPU, pour exécuter efficacement un modèle Gemma. Des outils tels que Google Colab peuvent fournir ces ressources de calcul spécialisées de manière limitée. Certains frameworks d'exécution d'IA, tels que Ollama et Gemma.cpp, vous permettent d'exécuter Gemma sur des processeurs plus courants utilisant des architectures ARM ou compatibles x86.
Voici des guides pour exécuter des modèles Gemma avec différents frameworks d'exécution d'IA:
Assurez-vous que le format de modèle Gemma que vous prévoyez de déployer, tel que le format natif Keras, Safetensors ou GGUF, est compatible avec le framework que vous avez choisi.
Sélectionner une variante Gemma
Les modèles Gemma sont disponibles dans plusieurs variantes et tailles, y compris les modèles Gemma de base ou fondamentaux, ainsi que des variantes de modèles plus spécialisées telles que PaliGemma et DataGemma, et de nombreuses variantes créées par la communauté de développeurs d'IA sur des sites tels que Kaggle et Hugging Face. Si vous ne savez pas par quelle variante commencer, sélectionnez le dernier modèle IT (instruction-tuned) du noyau Gemma avec le moins de paramètres. Ce type de modèle Gemma présente des exigences de calcul faibles et peut répondre à une grande variété d'invites sans nécessiter de développement supplémentaire.
Tenez compte des facteurs suivants lorsque vous choisissez une variante Gemma:
Gemma (core) et d'autres familles de variantes telles que PaliGemma et CodeGemma :
Nous vous recommandons Gemma (core). Les variantes Gemma au-delà de la version de base ont la même architecture que le modèle de base et sont entraînées pour être plus performantes dans des tâches spécifiques. À moins que votre application ou vos objectifs ne correspondent à la spécialisation d'une variante Gemma spécifique, il est préférable de commencer par un modèle de base Gemma.
Ajustement par instruction (IT), pré-entraînement (PT), ajustement fin (FT), mix: Nous vous recommandons d'utiliser IT.
Les variantes Gemma adaptées aux instructions sont des modèles qui ont été entraînés pour répondre à diverses instructions ou requêtes en langage humain. Ces variantes de modèle sont le meilleur point de départ, car elles peuvent répondre aux requêtes sans autre entraînement du modèle.
Les variantes Gemma pré-entraînées sont des modèles qui ont été entraînés pour déduire des informations sur le langage ou d'autres données, mais qui n'ont pas été entraînés pour suivre des instructions humaines. Ces modèles nécessitent un entraînement ou un réglage supplémentaires pour pouvoir effectuer des tâches efficacement. Ils sont destinés aux chercheurs ou aux développeurs qui souhaitent étudier ou développer les capacités du modèle et de son architecture.
Les variantes Gemma affinées peuvent être considérées comme des variantes IT, mais elles sont généralement entraînées pour effectuer une tâche spécifique ou pour obtenir de bons résultats sur un benchmark d'IA générative spécifique. La famille de variantes PaliGemma inclut un certain nombre de variantes FT.
Les variantes Gemma mixtes sont des versions de modèles PaliGemma qui ont été adaptées aux instructions avec diverses instructions et qui sont adaptées à une utilisation générale.
Paramètres: Recommend smallest number available (Recommander le plus petit nombre disponible). En général, plus un modèle comporte de paramètres, plus il est performant. Toutefois, l'exécution de modèles plus volumineux nécessite des ressources de calcul plus importantes et plus complexes, et ralentit généralement le développement d'une application d'IA. Sauf si vous avez déjà déterminé qu'un modèle Gemma plus petit ne répond pas à vos besoins, choisissez-en un avec un petit nombre de paramètres.
Niveaux de quantification:nous recommandons la demi-précision (16 bits), sauf pour le réglage. La quantification est un sujet complexe qui se résume à la taille et à la précision des données, et par conséquent à la quantité de mémoire qu'un modèle d'IA générative utilise pour les calculs et la génération de réponses. Une fois qu'un modèle a été entraîné avec des données à haute précision, qui sont généralement des données à virgule flottante sur 32 bits, des modèles tels que Gemma peuvent être modifiés pour utiliser des données à précision inférieure, telles que des tailles de 16, 8 ou 4 bits. Ces modèles Gemma quantiques peuvent toujours fonctionner correctement, en fonction de la complexité des tâches, tout en utilisant beaucoup moins de ressources de calcul et de mémoire. Toutefois, les outils de réglage des modèles quantiques sont limités et peuvent ne pas être disponibles dans le framework de développement d'IA que vous avez choisi. En règle générale, vous devez affiner un modèle comme Gemma avec une précision maximale, puis quantizer le modèle obtenu.
Pour obtenir la liste des principaux modèles Gemma publiés par Google, consultez la section Premiers pas avec les modèles Gemma, puis la liste des modèles Gemma.
Exécuter des requêtes de génération et d'inférence
Une fois que vous avez sélectionné un framework d'exécution d'IA et une variante Gemma, vous pouvez commencer à exécuter le modèle et l'inviter à générer du contenu ou à effectuer des tâches.
Pour en savoir plus sur l'exécution de Gemma avec un framework spécifique, consultez les guides indiqués dans la section Choisir un framework.
Mise en forme de la requête
Toutes les variantes Gemma adaptées aux instructions sont soumises à des exigences de formatage des requêtes spécifiques. Certaines de ces exigences de mise en forme sont gérées automatiquement par le framework que vous utilisez pour exécuter des modèles Gemma. Toutefois, lorsque vous envoyez des données d'invite directement à un tokenizer, vous devez ajouter des balises spécifiques. Les exigences de balisage peuvent changer en fonction de la variante Gemma que vous utilisez. Pour en savoir plus sur la mise en forme des requêtes de variante Gemma et les instructions système, consultez les guides suivants:
Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/06/11 (UTC).
[[["Facile à comprendre","easyToUnderstand","thumb-up"],["J'ai pu résoudre mon problème","solvedMyProblem","thumb-up"],["Autre","otherUp","thumb-up"]],[["Il n'y a pas l'information dont j'ai besoin","missingTheInformationINeed","thumb-down"],["Trop compliqué/Trop d'étapes","tooComplicatedTooManySteps","thumb-down"],["Obsolète","outOfDate","thumb-down"],["Problème de traduction","translationIssue","thumb-down"],["Mauvais exemple/Erreur de code","samplesCodeIssue","thumb-down"],["Autre","otherDown","thumb-down"]],["Dernière mise à jour le 2025/06/11 (UTC)."],[],[],null,["# Run Gemma content generation and inferences\n\nThere are two key decisions to make when you want to run a Gemma model:\n1) what Gemma variant you want to run, and 2) what AI execution framework you\nare going to use to run it? A key issue in making both these decisions has to do\nwith what are hardware you and your users have available to run the model.\n\nThis overview helps you navigate these decisions and start working with Gemma\nmodels. The general steps for running a Gemma model are as follows:\n\n- [Choose a framework for running](#choose-a-framework)\n- [Select a Gemma variant](#select-a-variant)\n- [Run generation and inference requests](#run-generation)\n\nChoose a framework\n------------------\n\nGemma models are compatible with a variety of generative AI execution\nframeworks. One of the key decision making factors in running a Gemma model is\nwhat computing resources you have (or will have) available to you to run the\nmodel. Most compatible AI frameworks require specialized hardware, such as GPUs\nor TPUs, to run a Gemma model effectively. Tools such as\n[Google Colab](https://colab.research.google.com/) can provide these specialized\ncompute resources on a limited basis. Some AI execution frameworks, such as\n[Ollama](/gemma/docs/integrations/ollama) and\n[Gemma.cpp](/gemma/docs/gemma_cpp), allow you to run Gemma on more common CPUs\nusing x86-compatible or ARM architectures.\n\nHere are guides for running Gemma models with various AI runtime frameworks:\n\n- [Ollama](/gemma/docs/integrations/ollama)\n- [Hugging Face Transformers](https://huggingface.co/docs/transformers/en/model_doc/gemma2)\n- [Gemma library for JAX](https://gemma-llm.readthedocs.io)\n- [Keras](/gemma/docs/keras_inference)\n- [PyTorch](/gemma/docs/pytorch_gemma)\n- [MediaPipe LLM Inference API](/edge/mediapipe/solutions/genai/llm_inference)\n- [Hugging Face Transformers](https://huggingface.co/docs/transformers/en/model_doc/gemma2)\n- [Gemma.cpp](/gemma/docs/gemma_cpp)\n- [vLLM](https://github.com/google-gemini/gemma-cookbook/blob/main/Gemma/%5BGemma_2%5DDeploy_with_vLLM.ipynb)\n- Google Cloud [Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/open-models/use-gemma)\n- [Google Cloud Kubernetes Engine (GKE)](/gemma/docs/code/gke)\n- [Google Cloud Run](/gemma/docs/core/deploy_to_cloud_run_from_ai_studio)\n\n| **Note:** The JAX inference run guide has been replaced by the [Gemma library sampling](https://gemma-llm.readthedocs.io/en/latest/colab_sampling.html) guide.\n\nMake sure your intended deployment Gemma model format, such as Keras native\nformat, Safetensors, or GGUF, is supported by your chosen framework.\n\nSelect a Gemma variant\n----------------------\n\nGemma models are available in several variants and sizes, including the\nfoundation or [core](/gemma/docs/core) Gemma models, and more\nspecialized model variants such as\n[PaliGemma](/gemma/docs/paligemma) and\n[DataGemma](/gemma/docs/datagemma), and many variants\ncreated by the AI developer community on sites such as\n[Kaggle](https://www.kaggle.com/models?query=gemma) and\n[Hugging Face](https://huggingface.co/models?search=gemma). If you are unsure\nabout what variant you should start with, select the latest Gemma\n[core](/gemma/docs/core) instruction-tuned (IT) model with\nthe lowest number of parameters. This type of Gemma model has low compute\nrequirements and be able to respond to a wide variety of prompts without\nrequiring additional development.\n\nConsider the following factors when choosing a Gemma variant:\n\n- **Gemma core, and other variant families such as PaliGemma, CodeGemma** : *Recommend Gemma (core).* Gemma variants beyond the core version have the same architecture as the core model, and are trained to perform better at specific tasks. Unless your application or goals align with the specialization of a specific Gemma variant, it is best to start with a Gemma core, or base, model.\n- **Instruction-tuned (IT), pre-trained (PT), fine-tuned (FT), mixed\n (mix)** : *Recommend IT.*\n - *Instruction-tuned* (IT) Gemma variants are models that have been trained to respond to a variety of instructions or requests in human language. These model variants are the best place to start because they can respond to prompts without further model training.\n - *Pre-trained* (PT) Gemma variants are models that have been trained to make inferences about language or other data, but have not been trained to follow human instructions. These models require additional training or tuning to be able to perform tasks effectively, and are meant for researchers or developers who want to study or develop the capabilities of the model and its architecture.\n - *Fine-tuned* (FT) Gemma variants can be considered IT variants, but are typically trained to perform a specific task, or perform well on a specific generative AI benchmark. The PaliGemma variant family includes a number of FT variants.\n - *Mixed* (mix) Gemma variants are versions of PaliGemma models that have been instruction tuned with a variety of instructions and are suitable for general use.\n- **Parameters** : *Recommend smallest number available*. In general, the more parameters a model has, the more capable it is. However, running larger models requires larger and more complex compute resources, and generally slows down development of an AI application. Unless you have already determined that a smaller Gemma model cannot meet your needs, choose a one with a small number of parameters.\n- **Quantization levels:** *Recommend half precision (16-bit), except for\n tuning*. Quantization is a complex topic that boils down to what size and precision of data, and consequently how much memory a generative AI model uses for calculations and generating responses. After a model is trained with high-precision data, which is typically 32-bit floating point data, models like Gemma can be modified to use lower precision data such as 16, 8 or 4-bit sizes. These quantized Gemma models can still perform well, depending on the complexity of the tasks, while using significantly less compute and memory resources. However, tools for tuning quantized models are limited and may not be available within your chosen AI development framework. Typically, you must fine-tune a model like Gemma at full precision, then quantize the resulting model.\n\nFor a list of key, Google-published Gemma models, see the\n[Getting started with Gemma models](/gemma/docs/get_started#models-list),\nGemma model list.\n\nRun generation and inference requests\n-------------------------------------\n\nAfter you have selected an AI execution framework and a Gemma variant, you can\nstart running the model, and prompting it to generate content or complete tasks.\nFor more information on how to run Gemma with a specific framework, see the\nguides linked in the [Choose a framework](#choose-a-framework) section.\n\n### Prompt formatting\n\nAll instruction-tuned Gemma variants have specific prompt formatting\nrequirements. Some of these formatting requirements are handled automatically by\nthe framework you use to run Gemma models, but when you are sending prompt data\ndirectly to a tokenizer, you must add specific tags, and the tagging\nrequirements can change depending on the Gemma variant you are using. See the\nfollowing guides for information on Gemma variant prompt formatting and system\ninstructions:\n\n- [Gemma prompt and system instructions](/gemma/docs/core/prompt-structure)\n- [PaliGemma prompt and system instructions](/gemma/docs/paligemma/prompt-system-instructions)\n- [CodeGemma prompt and system instructions](/gemma/docs/codegemma/prompt-structure)"]]