Executar a geração de conteúdo e as inferências do Gemma
Há duas decisões importantes a serem tomadas ao executar um modelo do Gemma:
1) qual variante do Gemma você quer executar e 2) qual framework de execução de IA você
vai usar para isso? Um problema importante para tomar essas decisões está relacionado
ao hardware que você e seus usuários têm disponível para executar o modelo.
Esta visão geral ajuda você a navegar por essas decisões e começar a trabalhar com os modelos
Gemma. As etapas gerais para executar um modelo Gemma são as seguintes:
Os modelos do Gemma são compatíveis com vários frameworks de execução de IA
generativa. Um dos principais fatores de tomada de decisão na execução de um modelo Gemma é
saber quais recursos de computação você tem (ou terá) disponíveis para executar o
modelo. A maioria dos frameworks de IA compatíveis exige hardware especializado, como GPUs
ou TPUs, para executar um modelo Gemma de maneira eficaz. Ferramentas como o
Google Colab podem fornecer esses recursos
de computação especializados de forma limitada. Alguns frameworks de execução de IA, como
Ollama e
Gemma.cpp, permitem executar o Gemma em CPUs mais comuns
usando arquiteturas ARM ou compatíveis com x86.
Confira os guias para executar modelos do Gemma com vários frameworks de execução de IA:
Confira se o formato do modelo Gemma da implantação pretendida, como o formato nativo
do Keras, Safetensors ou GGUF, é compatível com o framework escolhido.
Selecionar uma variante do Gemma
Os modelos Gemma estão disponíveis em várias variantes e tamanhos, incluindo os modelos
de fundação ou núcleo Gemma e variantes de modelos mais
especializados, como
PaliGemma e
DataGemma, além de muitas variantes
criadas pela comunidade de desenvolvedores de IA em sites como
Kaggle e
Hugging Face. Se você não tiver certeza
sobre qual variante usar, selecione o modelo de ajuste de instrução (IT, na sigla em inglês)
core mais recente do Gemma com
o menor número de parâmetros. Esse tipo de modelo Gemma tem requisitos de computação
baixos e pode responder a uma ampla variedade de comandos sem
requerer desenvolvimento adicional.
Considere os seguintes fatores ao escolher uma variante do Gemma:
Gemma core e outras famílias de variantes, como PaliGemma e CodeGemma:
recomendamos o Gemma (núcleo). As variantes do Gemma além da versão principal têm a mesma arquitetura do modelo principal e são treinadas para ter melhor desempenho em tarefas específicas. A menos que seu aplicativo ou suas metas estejam alinhados com a
especialização de uma variante específica do Gemma, é melhor começar com um modelo
principal ou básico do Gemma.
As variantes Gemma ajustadas por instruções (IT, na sigla em inglês) são modelos que foram
treinados para responder a várias instruções ou solicitações em
linguagem humana. Essas variantes de modelo são o melhor lugar para começar,
porque podem responder a comandos sem mais treinamento de modelo.
As variantes pré-treinadas (PT) do Gemma são modelos que foram
treinados para fazer inferências sobre a linguagem ou outros dados, mas não foram
treinados para seguir instruções humanas. Esses modelos exigem
treinamento ou ajuste adicional para realizar tarefas de maneira eficaz
e são destinados a pesquisadores ou desenvolvedores que querem estudar ou
desenvolver os recursos do modelo e da arquitetura.
As variantes afinada (FT, na sigla em inglês) do Gemma podem ser consideradas variantes de TI, mas geralmente são treinadas para realizar uma tarefa específica ou ter um bom desempenho
em um comparativo de mercado de IA generativa. A família de variantes PaliGemma
inclui várias variantes de FT.
As variantes mistas (mix) do Gemma são versões de modelos PaliGemma
que foram ajustadas com várias instruções e são
adequadas para uso geral.
Parâmetros: Recomendar o menor número disponível. Em geral, quanto
mais parâmetros um modelo tiver, mais capacidade ele terá. No entanto, a execução
de modelos maiores requer recursos de computação maiores e mais complexos e
geralmente retarda o desenvolvimento de um aplicativo de IA. A menos que você já tenha
determinado que um modelo menor do Gemma não atende às suas necessidades,
escolha um com um pequeno número de parâmetros.
Níveis de quantização:recomenda-se meia precisão (16 bits), exceto para
ajustes. A quantização é um tópico complexo que se resume ao tamanho e
à precisão dos dados e, consequentemente, à quantidade de memória que um modelo de IA generativa
usa para cálculos e geração de respostas. Depois que um modelo é treinado
com dados de alta precisão, que normalmente são dados de ponto flutuante de 32 bits,
modelos como Gemma podem ser modificados para usar dados de menor precisão, como tamanhos de 16, 8
ou 4 bits. Esses modelos quantizados do Gemma ainda podem ter bom desempenho,
dependendo da complexidade das tarefas, usando significativamente menos
recursos de computação e memória. No entanto, as ferramentas para ajustar modelos quantizados são
limitadas e podem não estar disponíveis no framework de desenvolvimento de IA
escolhido. Normalmente, é necessário ajustar um modelo como o Gemma com precisão total e, em seguida, quantificar o modelo resultante.
Para conferir uma lista de modelos principais do Gemma publicados pelo Google, consulte a
Introdução aos modelos Gemma,
lista de modelos do Gemma.
Executar solicitações de geração e inferência
Depois de selecionar um framework de execução de IA e uma variante do Gemma, você pode
iniciar a execução do modelo e solicitar que ele gere conteúdo ou conclua tarefas.
Para mais informações sobre como executar o Gemma com uma estrutura específica, consulte os
guias vinculados na seção Escolher uma estrutura.
Formatação do comando
Todas as variantes do Gemma ajustadas por instruções têm requisitos específicos de formatação
de comandos. Alguns desses requisitos de formatação são processados automaticamente pelo
framework usado para executar modelos Gemma. No entanto, ao enviar dados de comando
diretamente para um tokenizer, é necessário adicionar tags específicas. Os requisitos de
tagging podem mudar dependendo da variante do Gemma que você está usando. Consulte os
guias a seguir para saber mais sobre a formatação do comando de variante do Gemma e as instruções
do sistema:
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 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)"]]