Gemma 4 Rilis: Tutorial Lengkap AI Open Source Google

# Bikin folder project
mkdir gemma4-tutorial
cd gemma4-tutorial

# Bikin virtual environment
python -m venv venv

# Aktifkan (Linux/macOS)
source venv/bin/activate

# Aktifkan (Windows)
venv\Scripts\activate

# Install PyTorch (sesuaikan dengan GPU kamu)
# Untuk NVIDIA GPU dengan CUDA 12.1:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# Untuk Mac (Apple Silicon):
pip install torch torchvision torchaudio

# Untuk CPU-only:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

# Install Hugging Face Transformers dan dependencies
pip install transformers accelerate sentencepiece

# Untuk multimodal (proses gambar/video)
pip install pillow av

# Untuk quantization (hemat VRAM)
pip install bitsandbytes

# Opsional: vLLM untuk inferensi cepat
pip install vllm

import torch
print(f"PyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

PyTorch version: 2.5.1+cu121
CUDA available: True
GPU: NVIDIA GeForce RTX 4090
VRAM: 23.7 GB

# Pakai quantization 4-bit
pip install bitsandbytes

# Install Hugging Face CLI
pip install huggingface-hub

# Login (bakal minta token)
huggingface-cli login

# Clone model E2B (sekitar 5GB)
git clone https://huggingface.co/google/gemma-4-e2b-it

# Clone model 31B (sekitar 62GB, pastikan disk space cukup)
git clone https://huggingface.co/google/gemma-4-31b-it

# Cek ukuran folder model
du -sh gemma-4-e2b-it/

# Cek file yang ada
ls -la gemma-4-e2b-it/

5.2G    gemma-4-e2b-it/
total 48M
-rw-r--r--  config.json
-rw-r--r--  generation_config.json
-rw-r--r--  model-00001-of-00003.safetensors
-rw-r--r--  model-00002-of-00003.safetensors
-rw-r--r--  model-00003-of-00003.safetensors
-rw-r--r--  model.safetensors.index.json
-rw-r--r--  tokenizer.json
-rw-r--r--  tokenizer_config.json

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Path ke model yang udah didownload (atau pakai nama repo Hugging Face)
model_id = "google/gemma-4-e2b-it"

print("Loading tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(model_id)

print("Loading model...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",  # Otomatis pilih device (GPU kalau ada, CPU kalau nggak)
)

print("Model loaded successfully!")

# Bikin prompt sederhana
prompt = "Jelaskan apa itu kecerdasan buatan dengan bahasa sederhana."
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

# Generate output
print("Generating response...")
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
    )

# Decode dan tampilkan
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("\n" + "="*50)
print("RESPONSE:")
print("="*50)
print(response)

Loading tokenizer...
Loading model...
Model loaded successfully!
Generating response...

==================================================
RESPONSE:
==================================================
<bos>Jelaskan apa itu kecerdasan buatan dengan bahasa sederhana.

Kecerdasan buatan (AI) adalah teknologi yang membuat komputer atau mesin bisa meniru kemampuan berpikir manusia. Bayangkan komputer yang bisa belajar dari pengalaman, mengenali pola, dan membuat keputusan — mirip seperti cara kita belajar, tapi jauh lebih cepat dan bisa memproses data dalam jumlah sangat besar.

Ada beberapa jenis AI yang sering kita jumpai sehari-hari...

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

# Konfigurasi quantization 4-bit
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model_id = "google/gemma-4-31b-it"

print("Loading tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(model_id)

print("Loading model with 4-bit quantization...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto",
)

# Prompt yang lebih kompleks untuk test reasoning
prompt = """<bos><start_of_turn>user
Buatkan function Python untuk menghitung Fibonacci dengan memoization.
Jelaskan kenapa memoization lebih efisien dibanding rekursi biasa.<end_of_turn>
<start_of_turn>model
"""

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Generating response...")
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

# Cek max length tokenizer
print(f"Max length: {tokenizer.model_max_length}")

# Kalau perlu, set manual (jangan melebihi context window model)
tokenizer.model_max_length = 128000  # untuk E2B/E4B
# atau
tokenizer.model_max_length = 256000  # untuk 26B/31B

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "google/gemma-4-31b-it"  # atau varian lain

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Prompt dengan system instruction untuk thinking
system_prompt = """You are a helpful assistant. Before answering, think through the problem step by step. Show your reasoning process."""

user_prompt = "Sebuah toko memberikan diskon 20% untuk semua barang. Jika seorang pelanggan membeli 3 barang dengan harga masing-masing Rp 150.000, Rp 200.000, dan Rp 350.000, berapa total yang harus dibayar setelah diskon?"

# Format chat
messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": user_prompt},
]

# Apply chat template
prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Thinking...\n")
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=1024,
        temperature=0.6,
        top_p=0.95,
        do_sample=True,
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Thinking...

Let me work through this step by step.

Step 1: Calculate the original total price.
- Item 1: Rp 150.000
- Item 2: Rp 200.000
- Item 3: Rp 350.000
- Total before discount: Rp 150.000 + Rp 200.000 + Rp 350.000 = Rp 700.000

Step 2: Calculate the discount amount.
- Discount rate: 20%
- Discount amount: Rp 700.000 × 0.20 = Rp 140.000

Step 3: Calculate the final price.
- Final price: Rp 700.000 - Rp 140.000 = Rp 560.000

Jadi, total yang harus dibayar setelah diskon adalah Rp 560.000.

messages = [
    {
        "role": "system",
        "content": "Kamu adalah asisten programming yang berpengalaman. Jawab pertanyaan dengan contoh kode yang lengkap dan runnable. Selalu jelaskan trade-off dari setiap pendekatan."
    },
    {
        "role": "user",
        "content": "Bagaimana cara bikin REST API sederhana dengan FastAPI?"
    },
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=1024,
        temperature=0.7,
        do_sample=True,
    )

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText
from PIL import Image

model_id = "google/gemma-4-e4b-it"

print("Loading processor and model...")
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Load gambar
image = Image.open("contoh_invoice.jpg")

# Bikin prompt
prompt = "Baca semua teks yang ada di gambar ini dan strukturnya dalam format JSON dengan field: nama_toko, tanggal, items (array), dan total."

# Prepare inputs
inputs = processor(
    text=prompt,
    images=image,
    return_tensors="pt",
).to(model.device)

# Generate
print("Processing image...")
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.3,  # Suhu rendah untuk output yang lebih konsisten
        do_sample=True,
    )

response = processor.decode(outputs[0], skip_special_tokens=True)
print(response)

{
  "nama_toko": "Toko Elektronik Maju Jaya",
  "tanggal": "2026-03-15",
  "items": [
    {"nama": "Kabel HDMI 2m", "harga": 75000, "qty": 2},
    {"nama": "Mouse Wireless Logitech", "harga": 185000, "qty": 1},
    {"nama": "USB Hub 4 Port", "harga": 95000, "qty": 1}
  ],
  "total": 430000
}

import torch
import av
from PIL import Image
from transformers import AutoProcessor, AutoModelForImageTextToText

model_id = "google/gemma-4-e4b-it"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

def extract_frames(video_path, max_frames=8):
    """Ekstrak frame dari video dengan interval merata."""
    container = av.open(video_path)
    total_frames = container.streams.video[0].frames
    indices = set([
        int(total_frames * i / max_frames)
        for i in range(max_frames)
    ])

    frames = []
    for i, frame in enumerate(container.decode(video=0)):
        if i in indices:
            img = frame.to_image()
            frames.append(img)

    container.close()
    return frames

# Ekstrak frame
frames = extract_frames("presentasi_produk.mp4", max_frames=4)

# Bikin prompt
prompt = "Jelaskan apa yang terjadi di video ini berdasarkan frame-frame yang ditampilkan."

# Process
inputs = processor(
    text=prompt,
    images=frames,
    return_tensors="pt",
).to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        do_sample=False,  # Greedy decoding untuk deskripsi faktual
    )

print(processor.decode(outputs[0], skip_special_tokens=True))

import torch
import json
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "google/gemma-4-26b-a4b-it"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Definisikan tools yang bisa dipanggil model
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Mendapatkan informasi cuaca untuk kota tertentu",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Nama kota, misal: Jakarta, Bandung, Surabaya"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Satuan suhu"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_currency",
            "description": "Mengkonversi mata uang dari satu ke lain",
            "parameters": {
                "type": "object",
                "properties": {
                    "amount": {"type": "number", "description": "Jumlah uang"},
                    "from_currency": {"type": "string", "description": "Mata uang asal (mis: IDR)"},
                    "to_currency": {"type": "string", "description": "Mata uang tujuan (mis: USD)"}
                },
                "required": ["amount", "from_currency", "to_currency"]
            }
        }
    }
]

# Implementasi fungsi-fungsi tersebut
def get_weather(city: str, unit: str = "celsius") -> dict:
    """Simulasi API cuaca (di production, panggil API beneran)."""
    weather_data = {
        "Jakarta": {"temp": 32, "condition": "Cerah", "humidity": 75},
        "Bandung": {"temp": 24, "condition": "Berawan", "humidity": 80},
        "Surabaya": {"temp": 34, "condition": "Cerah", "humidity": 70},
    }
    data = weather_data.get(city, {"temp": 28, "condition": "Tidak diketahui", "humidity": 75})
    if unit == "fahrenheit":
        data["temp"] = data["temp"] * 9/5 + 32
    return data

def calculate_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    """Simulasi konversi mata uang."""
    rates = {"IDR_USD": 0.000064, "USD_IDR": 15625, "IDR_SGD": 0.000086}
    key = f"{from_currency}_{to_currency}"
    rate = rates.get(key, 1)
    return {"amount": amount, "from": from_currency, "to": to_currency, "result": round(amount * rate, 2)}

def run_agent(user_message: str, max_turns: int = 5):
    """Jalankan agent loop dengan function calling."""
    messages = [
        {"role": "system", "content": "Kamu adalah asisten yang bisa memanggil fungsi untuk membantu pengguna. Gunakan fungsi yang tersedia ketika diperlukan."},
        {"role": "user", "content": user_message},
    ]

    for turn in range(max_turns):
        # Format prompt dengan tools
        prompt = tokenizer.apply_chat_template(
            messages,
            tools=tools,
            tokenize=False,
            add_generation_prompt=True,
        )

        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_new_tokens=512,
                temperature=0.1,
                do_sample=True,
            )

        response_text = tokenizer.decode(outputs[0], skip_special_tokens=True)

        # Cek apakah model mau panggil fungsi
        if "tool_call" in response_text.lower() or "

```python
        # Cek apakah model mau panggil fungsi
        if "tool_call" in response_text.lower() or "

---