Lihat repositori Gemma Cookbook untuk mengetahui contoh pembuatan dan penyesuaian. Pelajari lebih lanjut

Halaman ini diterjemahkan oleh Cloud Translation API.

Menjalankan Gemma menggunakan PyTorch

Panduan ini menunjukkan cara menjalankan Gemma menggunakan framework PyTorch, termasuk cara menggunakan data gambar untuk meminta model Gemma rilis 3 dan yang lebih baru. Untuk mengetahui detail selengkapnya tentang penerapan Gemma PyTorch, lihat README repositori project.

Penyiapan

Bagian berikut menjelaskan cara menyiapkan lingkungan pengembangan, termasuk cara mendapatkan akses ke model Gemma untuk didownload dari Kaggle, menetapkan variabel autentikasi, menginstal dependensi, dan mengimpor paket.

Persyaratan sistem

Library Pytorch Gemma ini memerlukan prosesor GPU atau TPU untuk menjalankan model Gemma. Runtime Python CPU Colab standar dan runtime Python GPU T4 sudah cukup untuk menjalankan model Gemma berukuran 1B, 2B, dan 4B. Untuk kasus penggunaan lanjutan GPU atau TPU lainnya, lihat README di repositori Gemma PyTorch.

Mendapatkan akses ke Gemma di Kaggle

Untuk menyelesaikan tutorial ini, Anda harus mengikuti petunjuk penyiapan di Penyiapan Gemma, yang menunjukkan cara melakukan hal berikut:

Dapatkan akses ke Gemma di kaggle.com.
Pilih runtime Colab dengan resource yang memadai untuk menjalankan model Gemma.
Buat dan konfigurasikan nama pengguna dan kunci API Kaggle.

Setelah menyelesaikan penyiapan Gemma, lanjutkan ke bagian berikutnya, tempat Anda akan menetapkan variabel lingkungan untuk lingkungan Colab.

Menetapkan variabel lingkungan

Tetapkan variabel lingkungan untuk KAGGLE_USERNAME dan KAGGLE_KEY. Saat diminta dengan pesan "Berikan akses?", setujui untuk memberikan akses 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')

Menginstal dependensi

pip install -q -U torch immutabledict sentencepiece

Mendownload bobot model

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

Tetapkan jalur tokenizer dan titik pemeriksaan untuk model.

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

Mengonfigurasi lingkungan run

Bagian berikut menjelaskan cara menyiapkan lingkungan PyTorch untuk menjalankan Gemma.

Menyiapkan lingkungan operasi PyTorch

Siapkan lingkungan eksekusi model PyTorch dengan meng-clone repositori Pytorch Gemma.

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

Menetapkan konfigurasi model

Sebelum menjalankan model, Anda harus menetapkan beberapa parameter konfigurasi, termasuk varian Gemma, tokenizer, dan tingkat kuantisasi.

# 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

Mengonfigurasi konteks perangkat

Kode berikut mengonfigurasi konteks perangkat untuk menjalankan model:

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

Membuat instance dan memuat model

Muat model dengan bobotnya untuk bersiap menjalankan permintaan.

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

Menjalankan inferensi

Berikut adalah contoh untuk membuat dalam mode chat dan membuat dengan beberapa permintaan.

Model Gemma yang disesuaikan dengan petunjuk dilatih dengan pemformat tertentu yang menambahkan anotasi pada contoh penyesuaian petunjuk dengan informasi tambahan, baik selama pelatihan maupun inferensi. Anotasi (1) menunjukkan peran dalam percakapan, dan (2) mendelineasikan giliran dalam percakapan.

Token anotasi yang relevan adalah:

user: giliran pengguna
model: model turn
<start_of_turn>: awal giliran dialog
<start_of_image>: tag untuk input data gambar
<end_of_turn><eos>: akhir giliran dialog

Untuk informasi selengkapnya, baca tentang pemformatan perintah untuk model Gemma yang disesuaikan dengan petunjuk [di sini](https://ai.google.dev/gemma/core/prompt-structure

Membuat teks dengan teks

Berikut adalah contoh cuplikan kode yang menunjukkan cara memformat perintah untuk model Gemma yang disesuaikan dengan petunjuk menggunakan template chat pengguna dan model dalam percakapan multi-giliran.

# 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"

Membuat teks dengan gambar

Dengan Gemma rilis 3 dan yang lebih baru, Anda dapat menggunakan gambar dengan perintah. Contoh berikut menunjukkan cara menyertakan data visual dengan perintah Anda.

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

Pelajari lebih lanjut

Setelah mempelajari cara menggunakan Gemma di Pytorch, Anda dapat menjelajahi banyak hal lain yang dapat dilakukan Gemma di ai.google.dev/gemma. Lihat juga referensi terkait lainnya berikut: