Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind

# 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 ris...

By Ruby Abdullah · · tutorial
Google GemmaLLMOpen SourceFine-tuningHugging Face

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(

loadin8bit=True

)

model = AutoModelForCausalLM.frompretrained(

"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(formatinstruction)

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: {taskdescription}

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.

Artikel Terkait

Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet

Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet Hugging Face AutoTrain adalah platform dan lib...

Tutorial Lengkap Fine-tuning LLM dengan LoRA dan PEFT

Tutorial Lengkap Fine-tuning LLM dengan LoRA dan PEFT Fine-tuning Large Language Models (LLM) secara tradisional membutu...

Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom

Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom Model bahasa besar (LLM) open-source terus berk...

Tutorial LitGPT: Framework untuk Melatih dan Fine-Tuning Large Language Models

Tutorial LitGPT: Framework untuk Melatih dan Fine-Tuning Large Language Models LitGPT adalah framework open-source dari ...