Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind
Google Gemma adalah keluarga model bahasa open-source yang dikembangkan oleh Google DeepMind. Dibangun dengan teknologi dan riset yang sama dengan model Gemini, Gemma menawarkan performa yang sangat kompetitif dalam ukuran yang ringan dan efisien. Tutorial ini akan membahas cara menggunakan Gemma untuk berbagai keperluan, mulai dari inference sederhana hingga fine-tuning untuk kebutuhan spesifik.
Mengapa Gemma?
Gemma hadir dalam beberapa varian ukuran (2B, 7B, 9B, 27B parameter) yang dirancang untuk berjalan efisien di berbagai hardware. Beberapa keunggulan Gemma dibanding model open-source lainnya:
- Performa tinggi per parameter: Gemma secara konsisten mengungguli model sekelasnya di berbagai benchmark
- Lisensi terbuka: Dapat digunakan untuk keperluan komersial dan riset
- Dukungan ekosistem luas: Kompatibel dengan Hugging Face Transformers, vLLM, Ollama, llama.cpp, dan banyak framework lainnya
- Varian khusus: Tersedia CodeGemma untuk coding, PaliGemma untuk vision, dan RecurrentGemma untuk efisiensi memori
- Optimasi hardware: Dioptimalkan untuk GPU NVIDIA, TPU Google, dan bahkan CPU
Instalasi dan Persiapan
Prasyarat
Pastikan Anda memiliki Python 3.9 atau lebih baru dan pip yang sudah terinstall.
python --version
pip --version
Instalasi Library
pip install torch transformers accelerate bitsandbytes
pip install huggingfacehub
Untuk mengakses model Gemma, Anda perlu membuat akun di Hugging Face dan menyetujui lisensi penggunaan Gemma:
pip install huggingfacehub
huggingface-cli login
Masukkan token Hugging Face Anda saat diminta. Token bisa didapatkan dari halaman Settings > Access Tokens di website Hugging Face.
Verifikasi GPU (Opsional tapi Disarankan)
import torch
print(f"CUDA available: {torch.cuda.isavailable()}")
if torch.cuda.isavailable():
print(f"GPU: {torch.cuda.getdevicename(0)}")
print(f"Memory: {torch.cuda.getdeviceproperties(0).totalmem / 1e9:.1f} GB")
Basic Usage: Text Generation
Menggunakan Pipeline (Cara Termudah)
from transformers import pipeline
generator = pipeline(
"text-generation",
model="google/gemma-2-9b-it",
devicemap="auto",
torchdtype="auto"
)
prompt = "Jelaskan konsep machine learning dalam 3 paragraf:"
output = generator(
prompt,
maxnewtokens=512,
temperature=0.7,
topp=0.9,
dosample=True
)
print(output[0]["generatedtext"])
Menggunakan Model dan Tokenizer Langsung
Untuk kontrol lebih granular, Anda bisa memuat model dan tokenizer secara terpisah:
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
modelid = "google/gemma-2-9b-it"
tokenizer = AutoTokenizer.frompretrained(modelid)
model = AutoModelForCausalLM.frompretrained(
modelid,
devicemap="auto",
torchdtype=torch.bfloat16
)
prompt = "Apa perbedaan antara supervised dan unsupervised learning?"
inputs = tokenizer(prompt, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(
inputs,
maxnewtokens=256,
temperature=0.7,
topp=0.9,
dosample=True
)
response = tokenizer.decode(outputs[0], skipspecialtokens=True)
print(response)
Format Chat Template
Model Gemma instruction-tuned (varian -it) menggunakan format chat khusus. Gunakan chat template bawaan untuk hasil optimal:
messages = [
{"role": "user", "content": "Buatkan fungsi Python untuk menghitung fibonacci"},
]
inputtext = tokenizer.applychattemplate(
messages,
tokenize=False,
addgenerationprompt=True
)
inputs = tokenizer(inputtext, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(
inputs,
maxnewtokens=512,
temperature=0.3
)
response = tokenizer.decode(outputs[0][inputs["inputids"].shape[-1]:], skipspecialtokens=True)
print(response)
Multi-turn Conversation
conversation = [
{"role": "user", "content": "Apa itu neural network?"},
{"role": "assistant", "content": "Neural network adalah model komputasi yang terinspirasi dari cara kerja otak manusia. Model ini terdiri dari lapisan-lapisan neuron buatan yang saling terhubung dan dapat mempelajari pola dari data."},
{"role": "user", "content": "Bagaimana cara melatihnya?"},
]
inputtext = tokenizer.applychattemplate(
conversation,
tokenize=False,
addgenerationprompt=True
)
inputs = tokenizer(inputtext, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(inputs, maxnewtokens=512, temperature=0.7)
response = tokenizer.decode(outputs[0][inputs["inputids"].shape[-1]:], skipspecialtokens=True)
print(response)
Quantization: Menjalankan Gemma di Hardware Terbatas
4-bit Quantization dengan BitsAndBytes
Quantization memungkinkan Anda menjalankan model besar di GPU dengan VRAM terbatas:
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
import torch
quantizationconfig = BitsAndBytesConfig(
loadin4bit=True,
bnb4bitcomputedtype=torch.bfloat16,
bnb4bitusedoublequant=True,
bnb4bitquanttype="nf4"
)
modelid = "google/gemma-2-27b-it"
tokenizer = AutoTokenizer.frompretrained(modelid)
model = AutoModelForCausalLM.frompretrained(
modelid,
quantizationconfig=quantizationconfig,
devicemap="auto"
)
print(f"Model loaded. Memory usage: {model.getmemoryfootprint() / 1e9:.2f} GB")
Dengan 4-bit quantization, Gemma 27B yang normalnya membutuhkan sekitar 54GB VRAM bisa dijalankan hanya dengan sekitar 16GB VRAM.
8-bit Quantization
Jika Anda menginginkan keseimbangan antara kualitas dan efisiensi memori:
quantizationconfig = BitsAndBytesConfig(
load
in8bit=True
)
model = AutoModelForCausalLM.from
pretrained(
"google/gemma-2-9b-it",
quantizationconfig=quantizationconfig,
devicemap="auto"
)
Perbandingan Kebutuhan VRAM
| Model | FP16 | 8-bit | 4-bit |
|-------|------|-------|-------|
| Gemma 2B | ~4 GB | ~2.5 GB | ~1.5 GB |
| Gemma 7B | ~14 GB | ~8 GB | ~5 GB |
| Gemma 2 9B | ~18 GB | ~10 GB | ~6 GB |
| Gemma 2 27B | ~54 GB | ~28 GB | ~16 GB |
Menggunakan Gemma dengan Ollama
Cara termudah untuk menjalankan Gemma secara lokal:
# Install Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh
Download dan jalankan Gemma
ollama run gemma2:9b
Atau versi yang lebih kecil
ollama run gemma2:2b
Mengakses Ollama dari Python
import requests
import json
def chatwithgemma(prompt, model="gemma2:9b"):
response = requests.post(
"http://localhost:11434/api/generate",
json={
"model": model,
"prompt": prompt,
"stream": False,
"options": {
"temperature": 0.7,
"topp": 0.9,
"numpredict": 512
}
}
)
return response.json()["response"]
result = chatwithgemma("Jelaskan cara kerja transformer architecture")
print(result)
Ollama dengan OpenAI-compatible API
from openai import OpenAI
client = OpenAI(
baseurl="http://localhost:11434/v1",
apikey="ollama"
)
response = client.chat.completions.create(
model="gemma2:9b",
messages=[
{"role": "user", "content": "Buatkan query SQL untuk menghitung rata-rata penjualan per bulan"}
],
temperature=0.3
)
print(response.choices[0].message.content)
Advanced Usage: Fine-tuning Gemma dengan LoRA
Fine-tuning memungkinkan Anda menyesuaikan Gemma untuk task spesifik. Menggunakan LoRA (Low-Rank Adaptation) membuat proses ini efisien dan terjangkau.
Instalasi Dependency Tambahan
pip install peft trl datasets
Menyiapkan Dataset
from datasets import Dataset
data = {
"instruction": [
"Klasifikasikan sentimen review berikut",
"Klasifikasikan sentimen review berikut",
"Klasifikasikan sentimen review berikut",
"Ekstrak entitas dari teks berikut",
],
"input": [
"Produk ini sangat bagus, pengiriman cepat!",
"Kualitas buruk, tidak sesuai deskripsi.",
"Lumayan sih, tapi bisa lebih baik.",
"Budi membeli laptop di Tokopedia kemarin.",
],
"output": [
"Positif",
"Negatif",
"Netral",
"Entitas: Budi (Orang), Tokopedia (Organisasi), kemarin (Waktu)",
]
}
dataset = Dataset.fromdict(data)
def formatinstruction(example):
if example["input"]:
text = f"""ofturn>user
{example['instruction']}
{example['input']}ofturn>
ofturn>model
{example['output']}ofturn>"""
else:
text = f"""ofturn>user
{example['instruction']}ofturn>
ofturn>model
{example['output']}ofturn>"""
return {"text": text}
dataset = dataset.map(format
instruction)
print(dataset[0]["text"])
Konfigurasi LoRA dan Training
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, getpeftmodel, preparemodelforkbittraining
from trl import SFTTrainer, SFTConfig
import torch
modelid = "google/gemma-2-9b-it"
bnbconfig = BitsAndBytesConfig(
loadin4bit=True,
bnb4bitcomputedtype=torch.bfloat16,
bnb4bitusedoublequant=True,
bnb4bitquanttype="nf4"
)
tokenizer = AutoTokenizer.frompretrained(modelid)
tokenizer.padtoken = tokenizer.eostoken
model = AutoModelForCausalLM.frompretrained(
modelid,
quantizationconfig=bnbconfig,
devicemap="auto"
)
model = preparemodelforkbittraining(model)
loraconfig = LoraConfig(
r=16,
loraalpha=32,
targetmodules=["qproj", "kproj", "vproj", "oproj"],
loradropout=0.05,
bias="none",
tasktype="CAUSALLM"
)
model = getpeftmodel(model, loraconfig)
model.printtrainableparameters()
trainingconfig = SFTConfig(
outputdir="./gemma-finetuned",
numtrainepochs=3,
perdevicetrainbatchsize=4,
gradientaccumulationsteps=4,
learningrate=2e-4,
weightdecay=0.01,
warmupratio=0.1,
loggingsteps=10,
savestrategy="epoch",
bf16=True,
maxseqlength=512,
datasettextfield="text",
)
trainer = SFTTrainer(
model=model,
traindataset=dataset,
args=trainingconfig,
tokenizer=tokenizer,
)
trainer.train()
trainer.savemodel("./gemma-finetuned-final")
tokenizer.savepretrained("./gemma-finetuned-final")
Menggunakan Model yang Sudah Di-fine-tune
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
basemodel = AutoModelForCausalLM.frompretrained(
"google/gemma-2-9b-it",
devicemap="auto",
torchdtype=torch.bfloat16
)
model = PeftModel.frompretrained(basemodel, "./gemma-finetuned-final")
tokenizer = AutoTokenizer.frompretrained("./gemma-finetuned-final")
model = model.mergeandunload()
prompt = """ofturn>user
Klasifikasikan sentimen review berikut
Pelayanan toko ini sangat memuaskan, pasti belanja lagi!ofturn>
ofturn>model
"""
inputs = tokenizer(prompt, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(inputs, maxnewtokens=50, temperature=0.1)
response = tokenizer.decode(outputs[0][inputs["inputids"].shape[-1]:], skipspecialtokens=True)
print(response)
Menggunakan Gemma untuk Task Spesifik
Text Summarization
def summarize(text, maxlength=256):
messages = [
{
"role": "user",
"content": f"Buatkan ringkasan singkat dari teks berikut:\n\n{text}"
}
]
inputtext = tokenizer.applychattemplate(
messages, tokenize=False, addgenerationprompt=True
)
inputs = tokenizer(inputtext, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(
inputs,
maxnewtokens=maxlength,
temperature=0.3,
repetitionpenalty=1.1
)
return tokenizer.decode(
outputs[0][inputs["inputids"].shape[-1]:],
skipspecialtokens=True
)
article = """
Indonesia menargetkan transformasi digital di sektor kesehatan melalui penerapan
rekam medis elektronik di seluruh rumah sakit pemerintah. Program ini diharapkan
meningkatkan efisiensi layanan kesehatan dan memudahkan pasien mengakses riwayat
kesehatannya secara digital. Pemerintah mengalokasikan anggaran sebesar 2 triliun
rupiah untuk infrastruktur teknologi informasi di 3000 rumah sakit.
"""
summary = summarize(article)
print(summary)
Code Generation
def generatecode(taskdescription):
messages = [
{
"role": "user",
"content": f"""Buatkan kode Python untuk: {task
description}
Berikan kode yang bersih, dengan type hints, dan contoh penggunaan."""
}
]
inputtext = tokenizer.applychattemplate(
messages, tokenize=False, addgenerationprompt=True
)
inputs = tokenizer(inputtext, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(
inputs,
maxnewtokens=1024,
temperature=0.2,
topp=0.95
)
return tokenizer.decode(
outputs[0][inputs["inputids"].shape[-1]:],
skipspecialtokens=True
)
code = generatecode("REST API endpoint untuk CRUD operasi dengan FastAPI dan SQLAlchemy")
print(code)
Structured Data Extraction
import json
def extractentities(text):
messages = [
{
"role": "user",
"content": f"""Ekstrak entitas dari teks berikut dalam format JSON.
Kategori entitas: person, organization, location, date, amount.
Teks: {text}
Berikan output hanya dalam format JSON seperti ini:
{{"entities": [{{"text": "...", "type": "..."}}]}}"""
}
]
inputtext = tokenizer.applychattemplate(
messages, tokenize=False, addgenerationprompt=True
)
inputs = tokenizer(inputtext, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(
inputs,
maxnewtokens=512,
temperature=0.1
)
response = tokenizer.decode(
outputs[0][inputs["inputids"].shape[-1]:],
skipspecialtokens=True
)
try:
return json.loads(response)
except json.JSONDecodeError:
return {"rawresponse": response}
text = "PT Telkom Indonesia melaporkan pendapatan Rp 150 triliun pada kuartal ketiga 2026 di Jakarta."
entities = extractentities(text)
print(json.dumps(entities, indent=2, ensureascii=False))
Serving Gemma dengan vLLM
Untuk deployment production, vLLM menawarkan inference yang sangat cepat:
pip install vllm
Menjalankan vLLM Server
python -m vllm.entrypoints.openai.apiserver \
--model google/gemma-2-9b-it \
--dtype bfloat16 \
--max-model-len 4096 \
--gpu-memory-utilization 0.9 \
--port 8000
Client untuk vLLM Server
from openai import OpenAI
client = OpenAI(
baseurl="http://localhost:8000/v1",
apikey="not-needed"
)
response = client.chat.completions.create(
model="google/gemma-2-9b-it",
messages=[
{"role": "user", "content": "Buatkan arsitektur microservices untuk e-commerce"}
],
temperature=0.7,
maxtokens=1024
)
print(response.choices[0].message.content)
Batch Inference dengan vLLM
from vllm import LLM, SamplingParams
llm = LLM(
model="google/gemma-2-9b-it",
dtype="bfloat16",
maxmodellen=4096
)
samplingparams = SamplingParams(
temperature=0.7,
topp=0.9,
maxtokens=256
)
prompts = [
"Apa itu containerization?",
"Jelaskan perbedaan SQL dan NoSQL",
"Bagaimana cara mengoptimalkan query database?",
]
outputs = llm.generate(prompts, samplingparams)
for output in outputs:
print(f"Prompt: {output.prompt[:50]}...")
print(f"Response: {output.outputs[0].text}\n")
Best Practices
1. Pilih Ukuran Model yang Tepat
- Gemma 2B: Cocok untuk task sederhana, klasifikasi, atau deployment di edge device
- Gemma 7B/9B: Keseimbangan antara performa dan efisiensi, cocok untuk kebanyakan use case
- Gemma 27B: Untuk task kompleks yang membutuhkan reasoning mendalam
2. Optimasi Prompt
# Kurang optimal
prompt = "ceritakan tentang python"
Lebih optimal - spesifik dan terstruktur
prompt = """Jelaskan 3 keunggulan utama Python untuk data science.
Untuk setiap keunggulan, berikan contoh library yang relevan.
Format: bullet points."""
3. Pengaturan Temperature
- 0.0 - 0.3: Untuk task yang membutuhkan konsistensi (classification, extraction, code generation)
- 0.5 - 0.7: Untuk task kreatif dengan batasan (summarization, rewriting)
- 0.8 - 1.0: Untuk task kreatif bebas (brainstorming, creative writing)
4. Gunakan System Prompt dengan Efektif
messages = [
{
"role": "user",
"content": """Kamu adalah asisten data analyst yang ahli dalam SQL dan Python.
Jawab pertanyaan berikut dengan memberikan kode yang bisa langsung dijalankan.
Pertanyaan: Bagaimana cara menghitung customer churn rate dari tabel transactions?"""
}
]
5. Batasi Output dengan maxnewtokens
Selalu set maxnewtokens sesuai kebutuhan untuk menghindari output yang terlalu panjang dan menghemat waktu inference.
6. Gunakan Repetition Penalty
Untuk menghindari pengulangan teks yang tidak perlu:
outputs = model.generate(
inputs,
maxnewtokens=512,
temperature=0.7,
repetitionpenalty=1.15
)
7. Memory Management
import gc
import torch
Setelah selesai menggunakan model
del model
del tokenizer
gc.collect()
torch.cuda.emptycache()
Perbandingan Varian Gemma
| Fitur | Gemma 1 | Gemma 2 | CodeGemma | PaliGemma |
|-------|---------|---------|-----------|-----------|
| Ukuran | 2B, 7B | 2B, 9B, 27B | 2B, 7B | 3B |
| Fokus | General | General (improved) | Code | Vision + Language |
| Context Length | 8K | 8K | 8K | Varies |
| Use Case | Chat, text gen | Chat, reasoning | Coding, debugging | Image understanding |
Troubleshooting
OutOfMemoryError
Jika Anda mendapat error CUDA out of memory:
# Gunakan quantization
Atau kurangi maxseqlength
Atau gunakan model yang lebih kecil
Cek memory usage
print(f"Allocated: {torch.cuda.memoryallocated() / 1e9:.2f} GB")
print(f"Reserved: {torch.cuda.memoryreserved() / 1e9:.2f} GB")
Slow Generation
# Gunakan torch.compile untuk mempercepat inference
model = torch.compile(model)
Atau gunakan Flash Attention
model = AutoModelForCausalLM.frompretrained(
modelid,
attnimplementation="flashattention2",
torchdtype=torch.bfloat16,
device_map="auto"
)
Kesimpulan
Google Gemma adalah pilihan yang sangat baik untuk siapa saja yang ingin menggunakan model bahasa open-source yang berkualitas tinggi. Dengan berbagai varian ukuran dan dukungan ekosistem yang luas, Gemma bisa digunakan mulai dari eksperimen di laptop hingga deployment production skala besar.
Poin-poin kunci yang perlu diingat:
- Pilih varian model sesuai kebutuhan dan resource yang tersedia
- Gunakan quantization untuk menjalankan model besar di hardware terbatas
- Manfaatkan chat template untuk hasil optimal pada model instruction-tuned
- Fine-tuning dengan LoRA sangat efisien dan terjangkau
- Untuk production, pertimbangkan vLLM atau Ollama untuk serving yang optimal
Dengan penguasaan Gemma, Anda memiliki fondasi yang kuat untuk membangun berbagai aplikasi AI yang powerful dan efisien.