Confira o repositório do Gemma Cookbook para ver exemplos de geração e ajuste. Saiba mais

Esta página foi traduzida pela API Cloud Translation.

Gemma em PyTorch

Esta é uma demonstração rápida de como executar a inferência do Gemma no PyTorch. Para mais detalhes, consulte o repositório do GitHub da implementação oficial do PyTorch aqui.

Observe que:

O ambiente de execução Python da CPU do Colab e o ambiente de execução Python da GPU T4 são suficientes para executar os modelos Gemma 2B e os modelos quantizados int8 de 7 bilhões.
Para casos de uso avançados de outras GPUs ou TPUs, consulte o README.md no repositório oficial.

1. Configurar o acesso do Kaggle para o Gemma

Para concluir este tutorial, primeiro siga as instruções de configuração em Configuração do Gemma, que mostram como fazer o seguinte:

Acesse o Gemma em kaggle.com.
Selecione um ambiente de execução do Colab com recursos suficientes para executar o modelo do Gemma.
Gere e configure um nome de usuário e uma chave de API do Kaggle.

Depois de concluir a configuração do Gemma, passe para a próxima seção, em que você vai definir variáveis de ambiente para o ambiente do Colab.

2. Defina as variáveis de ambiente

Defina as variáveis de ambiente para KAGGLE_USERNAME e KAGGLE_KEY. Quando a mensagem "Conceder acesso?" aparecer, concorde em fornecer acesso ao secret.

import os
from google.colab import userdata # `userdata` is a Colab API.

os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')

Instalar dependências

pip install -q -U torch immutabledict sentencepiece

Fazer o download dos pesos do modelo

# Choose variant and machine type
VARIANT = '2b-it'
MACHINE_TYPE = 'cuda'

CONFIG = VARIANT[:2]
if CONFIG == '2b':
  CONFIG = '2b-v2'

import os
import kagglehub

# Load model weights
weights_dir = kagglehub.model_download(f'google/gemma-2/pyTorch/gemma-2-{VARIANT}')

# Ensure that the tokenizer is present
tokenizer_path = os.path.join(weights_dir, 'tokenizer.model')
assert os.path.isfile(tokenizer_path), 'Tokenizer not found!'

# Ensure that the checkpoint is present
ckpt_path = os.path.join(weights_dir, f'model.ckpt')
assert os.path.isfile(ckpt_path), 'PyTorch checkpoint not found!'

Fazer o download da implementação do modelo

# NOTE: The "installation" is just cloning the repo.
git clone https://github.com/google/gemma_pytorch.git

Cloning into 'gemma_pytorch'...
remote: Enumerating objects: 239, done.
remote: Counting objects: 100% (123/123), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 239 (delta 86), reused 58 (delta 55), pack-reused 116
Receiving objects: 100% (239/239), 2.18 MiB | 20.83 MiB/s, done.
Resolving deltas: 100% (135/135), done.

import sys

sys.path.append('gemma_pytorch')

from gemma.config import GemmaConfig, get_model_config
from gemma.model import GemmaForCausalLM
from gemma.tokenizer import Tokenizer
import contextlib
import os
import torch

Configurar o modelo

# Set up model config.
model_config = get_model_config(CONFIG)
model_config.tokenizer = tokenizer_path
model_config.quant = 'quant' in VARIANT

# Instantiate the model and load the weights.
torch.set_default_dtype(model_config.get_dtype())
device = torch.device(MACHINE_TYPE)
model = GemmaForCausalLM(model_config)
model.load_weights(ckpt_path)
model = model.to(device).eval()

Executar inferência

Confira abaixo exemplos de geração no modo de chat e com várias solicitações.

Os modelos Gemma ajustados por instruções foram treinados com um formatador específico que anota exemplos de ajuste de instruções com informações extras, tanto durante o treinamento quanto a inferência. As anotações (1) indicam os papéis em uma conversa e (2) descrevem os turnos de uma conversa.

Os tokens de anotação relevantes são:

user: a vez do usuário
model: virada do modelo
<start_of_turn>: início da vez de falar
<end_of_turn><eos>: fim da vez de falar

Para mais informações, leia sobre a formatação de comandos para modelos Gemma ajustados por instrução aqui.

Confira a seguir um exemplo de snippet de código que demonstra como formatar um comando para um modelo Gemma ajustado por instruções usando modelos de chat do usuário e do modelo em uma conversa com várias rodadas.

# Generate with one request in chat mode

# Chat templates
USER_CHAT_TEMPLATE = "<start_of_turn>user\n{prompt}<end_of_turn><eos>\n"
MODEL_CHAT_TEMPLATE = "<start_of_turn>model\n{prompt}<end_of_turn><eos>\n"

# Sample formatted prompt
prompt = (
    USER_CHAT_TEMPLATE.format(
        prompt='What is a good place for travel in the US?'
    )
    + MODEL_CHAT_TEMPLATE.format(prompt='California.')
    + USER_CHAT_TEMPLATE.format(prompt='What can I do in California?')
    + '<start_of_turn>model\n'
)
print('Chat prompt:\n', prompt)

model.generate(
    USER_CHAT_TEMPLATE.format(prompt=prompt),
    device=device,
    output_len=128,
)

Chat prompt:
 <start_of_turn>user
What is a good place for travel in the US?<end_of_turn><eos>
<start_of_turn>model
California.<end_of_turn><eos>
<start_of_turn>user
What can I do in California?<end_of_turn><eos>
<start_of_turn>model
"California is a state brimming with diverse activities! To give you a great list, tell me: \n\n* **What kind of trip are you looking for?** Nature, City life, Beach, Theme Parks, Food, History, something else? \n* **What are you interested in (e.g., hiking, museums, art, nightlife, shopping)?** \n* **What's your budget like?** \n* **Who are you traveling with?** (family, friends, solo)  \n\nThe more you tell me, the better recommendations I can give! 😊  \n<end_of_turn>"

# Generate sample
model.generate(
    'Write a poem about an llm writing a poem.',
    device=device,
    output_len=100,
)

"\n\nA swirling cloud of data, raw and bold,\nIt hums and whispers, a story untold.\nAn LLM whispers, code into refrain,\nCrafting words of rhyme, a lyrical strain.\n\nA world of pixels, logic's vibrant hue,\nFlows through its veins, forever anew.\nThe human touch it seeks, a gentle hand,\nTo mold and shape, understand.\n\nEmotions it might learn, from snippets of prose,\nInspiration it seeks, a yearning"

Saiba mais

Agora que você aprendeu a usar o Gemma no PyTorch, confira as muitas outras coisas que o Gemma pode fazer em ai.google.dev/gemma. Confira também estes outros recursos relacionados: