Drejtoni Gemma duke përdorur PyTorch

Shikoni në ai.google.dev Ekzekutoni në Google Colab Shiko burimin në GitHub

Ky udhëzues ju tregon se si të ekzekutoni Gemma duke përdorur kornizën PyTorch, duke përfshirë mënyrën e përdorimit të të dhënave të imazhit për të nxitur lëshimin e Gemma 3 dhe modelet e mëvonshme. Për më shumë detaje mbi zbatimin e Gemma PyTorch, shihni depon e projektit README .

Konfigurimi

Seksionet e mëposhtme shpjegojnë se si të konfiguroni mjedisin tuaj të zhvillimit, duke përfshirë mënyrën se si të merrni akses në modelet Gemma për shkarkim nga Kaggle, vendosjen e variablave të vërtetimit, instalimin e varësive dhe importimin e paketave.

Kërkesat e sistemit

Kjo bibliotekë Gemma Pytorch kërkon procesorë GPU ose TPU për të ekzekutuar modelin Gemma. Koha standarde e ekzekutimit e Colab CPU Python dhe koha e ekzekutimit të T4 GPU Python janë të mjaftueshme për ekzekutimin e modeleve me madhësi Gemma 1B, 2B dhe 4B. Për rastet e përdorimit të avancuar për GPU ose TPU të tjera, ju lutemi referojuni README në repon Gemma PyTorch.

Merrni qasje në Gemma në Kaggle

Për të përfunduar këtë tutorial, së pari duhet të ndiqni udhëzimet e konfigurimit në konfigurimin Gemma , të cilat ju tregojnë se si të bëni sa më poshtë:

  • Merrni akses në Gemma në kaggle.com .
  • Zgjidhni një kohë ekzekutimi Colab me burime të mjaftueshme për të ekzekutuar modelin Gemma.
  • Gjeneroni dhe konfiguroni një emër përdoruesi dhe çelës API të Kaggle.

Pasi të keni përfunduar konfigurimin e Gemma, kaloni në seksionin tjetër, ku do të vendosni variablat e mjedisit për mjedisin tuaj Colab.

Vendosni variablat e mjedisit

Cakto variablat e mjedisit për KAGGLE_USERNAME dhe KAGGLE_KEY . Kur kërkohet me "Grant qasje?" mesazhe, pranoni të siguroni akses sekret.

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')

Instaloni varësitë 

pip install -q -U torch immutabledict sentencepiece

Shkarkoni peshat e modelit 

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

CONFIG = VARIANT[:2]
if CONFIG == '4b':
  CONFIG = '4b-v1'

import kagglehub

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

Vendosni shtigjet e tokenizuesit dhe të pikës së kontrollit për modelin.

# 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!'

Konfiguro mjedisin e ekzekutimit

Seksionet e mëposhtme shpjegojnë se si të përgatisni një mjedis PyTorch për ekzekutimin e Gemma.

Përgatitni mjedisin e ekzekutimit të PyTorch

Përgatitni mjedisin e ekzekutimit të modelit PyTorch duke klonuar depon e Gemma Pytorch.

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/gemma')

from gemma_pytorch.gemma.config import get_model_config
from gemma_pytorch.gemma.gemma3_model import Gemma3ForMultimodalLM

import os
import torch

Vendosni konfigurimin e modelit

Përpara se të ekzekutoni modelin, duhet të vendosni disa parametra konfigurimi, duke përfshirë variantin Gemma, tokenizuesin dhe nivelin e kuantizimit. 

# Set up model config.
model_config = get_model_config(VARIANT)
model_config.dtype = "float32" if MACHINE_TYPE == "cpu" else "float16"
model_config.tokenizer = tokenizer_path

Konfiguro kontekstin e pajisjes

Kodi i mëposhtëm konfiguron kontekstin e pajisjes për ekzekutimin e modelit: 

@contextlib.contextmanager
def _set_default_tensor_type(dtype: torch.dtype):
    """Sets the default torch dtype to the given dtype."""
    torch.set_default_dtype(dtype)
    yield
    torch.set_default_dtype(torch.float)

Instantoni dhe ngarkoni modelin

Ngarkoni modelin me peshat e tij për t'u përgatitur për të ekzekutuar kërkesat. 

device = torch.device(MACHINE_TYPE)
with _set_default_tensor_type(model_config.get_dtype()):
    model = Gemma3ForMultimodalLM(model_config)
    model.load_state_dict(torch.load(ckpt_path)['model_state_dict'])
    model = model.to(device).eval()
print("Model loading done.")

print('Generating requests in chat mode...')

Ekzekutoni konkluzionet

Më poshtë janë shembuj për gjenerimin në modalitetin e bisedës dhe gjenerimin me kërkesa të shumta.

Modelet Gemma të akorduara nga udhëzimet u trajnuan me një formatues specifik që shënon shembujt e akordimit të udhëzimeve me informacion shtesë, si gjatë trajnimit ashtu edhe gjatë përfundimit. Shënimet (1) tregojnë rolet në një bisedë dhe (2) përvijojnë kthesat në një bisedë.

Shenjat përkatëse të shënimeve janë:

  • user : kthesa e përdoruesit
  • model : kthesë model
  • <start_of_turn> : fillimi i kthesës së dialogut
  • <start_of_image> : etiketë për futjen e të dhënave të imazhit
  • <end_of_turn><eos> : fundi i kthesës së dialogut

Për më shumë informacion, lexoni rreth formatimit të shpejtë për modelet Gemma të akorduara me udhëzim [këtu]( https://ai.google.dev/gemma/core/prompt-structure

Gjeneroni tekst me tekst

Më poshtë është një fragment kodi shembull që demonstron se si të formatoni një kërkesë për një model Gemma të akorduar me udhëzime duke përdorur shabllonet e bisedës së përdoruesit dhe modelit në një bisedë me shumë kthesa. 

# 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=256,
)

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"

Gjeneroni tekst me imazhe

Me versionin 3 të Gemma dhe versionet më të reja, mund të përdorni imazhe me kërkesën tuaj. Shembulli i mëposhtëm ju tregon se si të përfshini të dhënat vizuale me kërkesën tuaj. 

print('Chat with images...\n')

def read_image(url):
    import io
    import requests
    import PIL

    contents = io.BytesIO(requests.get(url).content)
    return PIL.Image.open(contents)

image_url = 'https://storage.googleapis.com/keras-cv/models/paligemma/cow_beach_1.png'
image = read_image(image_url)

print(model.generate(
    [['<start_of_turn>user\n',image, 'What animal is in this image?<end_of_turn>\n', '<start_of_turn>model\n']],
    device=device,
    output_len=OUTPUT_LEN,
))

Mësoni më shumë

Tani që keni mësuar se si të përdorni Gemma në Pytorch, mund të eksploroni shumë gjëra të tjera që Gemma mund të bëjë në ai.google.dev/gemma . Shihni gjithashtu këto burime të tjera të lidhura: