Cara Menjalankan Gemma 4 31B Secara Lokal: Unsloth, Ollama, llama.cpp, dan HuggingFace

Sekitar 10 menit

Cara Menjalankan Gemma 4 31B Secara Lokal: Unsloth, Ollama, llama.cpp, dan HuggingFace

Google DeepMind merilis Gemma 4 di awal 2026, dan varian instruction-tuned 31B-nya ada di titik yang pas: cukup besar untuk bersaing dengan model proprietary di benchmark reasoning, cukup kecil untuk dijalankan di GPU konsumen yang layak. Dia mendapat skor 85.2% di MMLU Pro dan 89.2% di AIME 2026 tanpa tools, yang menempatkannya di liga yang sama dengan model dua kali ukurannya.

Masalahnya selalu "gimana caranya menjalankan model ini?" Model 30.7B parameter dalam full precision butuh sekitar 62GB VRAM. Gak ada yang punya sebesar itu di satu kartu grafis. Tapi dengan kuantisasi yang tepat dan tools yang benar, kamu bisa menjalankannya di RTX 4090 24GB, atau bahkan sebagian di-offload ke CPU di kartu 16GB. Kami merekomendasikan LightNode sebagai provider VPS kalau kamu mau instance GPU tanpa komitmen.

Panduan ini mencakup empat metode, dengan Unsloth sebagai rekomendasi utama untuk kebanyakan orang.

Daftar Isi

Sekilas Tentang Keluarga Model Gemma 4
Persyaratan Perangkat Keras
Metode 1: Unsloth Studio (Direkomendasikan)
Metode 2: Ollama
Metode 3: llama.cpp
Metode 4: HuggingFace Transformers
Memahami Format Kuantisasi GGUF
Tips Performa
Pemecahan Masalah
Metode Mana yang Harus Kamu Pilih?

Sekilas Tentang Keluarga Model Gemma 4

Gemma 4 hadir dalam empat ukuran. Memilih yang tepat itu penting karena lompatan perangkat keras antar ukurannya cukup drastis.

Varian	Total Param	Param Aktif	Konteks	Modalitas	Cocok Untuk
E2B	5.1B	2.3B efektif	128K	Teks, Gambar, Audio	Ponsel, Raspberry Pi
E4B	8B	4.5B efektif	128K	Teks, Gambar, Audio	Laptop, hanya CPU
26B A4B (MoE)	25.2B	3.8B aktif	256K	Teks, Gambar	Inferensi cepat, VRAM lebih sedikit
31B (Dense)	30.7B	30.7B	256K	Teks, Gambar	Kualitas maksimum

Varian 26B A4B adalah yang paling cerdas: total 25.2B parameter, tapi hanya 3.8B yang aktif selama inferensi berkat arsitektur Mixture-of-Experts (8 expert aktif dari 128, plus 1 shared). Performanya hampir secepat model 4B sambil menghasilkan kualitas mendekati 31B penuh. Kalau GPU kamu punya 12-16GB VRAM, 26B A4B dengan kuantisasi Q4 kemungkinan pilihan terbaik.

31B Dense adalah fokus panduan ini. Model full-fat dengan semua parameter aktif di setiap forward pass. Kualitas terbaik, kebutuhan perangkat keras tertinggi.

Keempat varian mendukung mode thinking yang bisa dikonfigurasi (penalaran chain-of-thought), system prompt native, function calling, dan 140+ bahasa.

Persyaratan Perangkat Keras

Sebelum memilih metode, ketahui dulu perangkat keras yang kamu punya.

Untuk Gemma 4 31B-it

Kuantisasi	VRAM Dibutuhkan	Kehilangan Kualitas	Perangkat Keras Tipikal
FP16 (full precision)	~62 GB	Tidak ada	A100, multi-GPU
Q8_0 (8-bit)	~32 GB	Sangat kecil	RTX 4090 (24GB) + CPU offload
Q5_K_M (5-bit)	~22 GB	Minimal	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 GB	Sedikit	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 GB	Terasa	RTX 4070, offload parsial

Untuk Gemma 4 26B A4B (MoE)

Kuantisasi	VRAM Dibutuhkan	Kehilangan Kualitas	Perangkat Keras Tipikal
Q5_K_M	~14 GB	Minimal	RTX 4070 Ti
Q4_K_M	~10 GB	Sedikit	RTX 4070, RTX 3080
Q3_K_M	~8 GB	Terasa	RTX 4060 Ti 8GB

Kalau kamu cuma pakai CPU, varian E4B atau E2B akan berjalan dengan lancar. 31B di CPU secara teknis bisa tapi rasanya lambat banget (siap-siap 1-3 token per detik di CPU modern).

Kebutuhan RAM: Tambahkan 8-16GB RAM sistem di atas VRAM untuk overhead runtime, lebih banyak kalau kamu offload layer ke CPU.

Metode 1: Unsloth Studio (Direkomendasikan)

Unsloth adalah cara paling gampang untuk menjalankan Gemma 4 secara lokal. Ini adalah web UI yang menangani download model, pemilihan kuantisasi, dan inferensi dalam satu paket. Bekerja di Windows, Linux, macOS, dan WSL.

Kenapa Unsloth

Pencarian dan download model dari HuggingFace dalam satu klik
Otomatis memilih kuantisasi GGUF yang tepat untuk perangkat keras kamu
Antarmuka chat bawaan dengan dukungan gambar, PDF, dan dokumen
Tool calling dan pencarian web sudah built-in
Sandbox eksekusi kode
Gak perlu pusing dengan command line

Instalasi

macOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows (PowerShell):

irm https://unsloth.ai/install.ps1 | iex

Docker:

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 8000:8000 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Menjalankan

unsloth studio -H 0.0.0.0 -p 8888

Buka http://localhost:8888 di browser kamu. Kamu akan melihat antarmuka Unsloth Studio.

Menjalankan Gemma 4 31B

Cari modelnya: Di kolom pencarian model, ketik gemma-4-31B
Pilih kuantisasi: Unsloth menyediakan file GGUF yang sudah dikuantisasi. Untuk GPU 24GB, pilih Q4_K_M atau Q5_K_M. Untuk 16GB, pakai Q3_K_M
Download: Klik download. Varian Q4_K_M ukurannya sekitar 18GB
Mulai chat: Setelah didownload, model otomatis dimuat ke antarmuka chat

Unsloth menyediakan varian GGUF berikut untuk Gemma 4 31B-it:

File	Ukuran	Kuantisasi
`gemma-4-31B-it-Q3_K_M.gguf`	~14 GB	3-bit (seimbang)
`gemma-4-31B-it-Q4_K_M.gguf`	~18 GB	4-bit (direkomendasikan)
`gemma-4-31B-it-Q5_K_M.gguf`	~22 GB	5-bit (kualitas tinggi)
`gemma-4-31B-it-Q6_K.gguf`	~26 GB	6-bit (hampir tanpa kehilangan)
`gemma-4-31B-it-Q8_0.gguf`	~32 GB	8-bit (praktis tanpa kehilangan)

Repo HuggingFace ada di unsloth/gemma-4-31B-it-GGUF.

Menggunakan Antarmuka Chat

Chat Unsloth Studio mendukung:

Percakapan teks dengan toggle mode thinking
Upload gambar: Drag and drop gambar untuk visual question answering
Upload PDF/DOCX: Ekstrak dan diskusikan isi dokumen
Eksekusi kode: Model bisa menulis dan menguji kode di sandbox
System prompt kustom: Atur perilaku dan persona

Untuk mengaktifkan mode thinking Gemma 4, toggle opsi "Thinking" di pengaturan chat. Ini mengaktifkan penalaran chain-of-thought, di mana model menyelesaikan masalah langkah demi langkah sebelum memberikan jawaban akhir.

Fine-Tuning dengan Unsloth

Kalau kamu mau lebih dari sekadar inferensi, Unsloth juga bisa menangani training:

Fine-tuning LoRA: Latih adapter dengan hingga 70% lebih sedikit VRAM
GRPO reinforcement learning: Library RL paling efisien yang tersedia
Data Recipes: Otomatis buat dataset training dari file PDF, CSV, DOCX
Dukungan multi-GPU: Tersedia sekarang dengan peningkatan yang terus datang

Untuk fine-tuning Gemma 4 31B, kamu butuh setidaknya satu GPU 24GB dengan QLoRA (training terkuantisasi 4-bit).

Update Unsloth

Jalankan lagi perintah instalasi yang sama:

# macOS/Linux/WSL
curl -fsSL https://unsloth.ai/install.sh | sh

# Windows
irm https://unsloth.ai/install.ps1 | iex

Metode 2: Ollama

Ollama adalah cara tercepat untuk mulai kalau kamu lebih suka command line. Dia menangani download model, deteksi GPU, dan serving secara otomatis.

Instalasi

# macOS
brew install ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# Download dari https://ollama.com/download

Menjalankan Gemma 4

# Pull dan jalankan model 31B
ollama run gemma4:31b-it

# Atau varian MoE yang lebih kecil untuk VRAM lebih sedikit
ollama run gemma4:26b-a4b-it

# Atau model dense yang lebih kecil
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama otomatis mengkuantisasi ke Q4_K_M secara default. Kalau kamu mau kuantisasi yang berbeda:

# Jalankan dengan kuantisasi tertentu
ollama run gemma4:31b-it-q5_K_M

Menggunakan API

Ollama menyediakan API lokal di port 11434:

import requests

response = requests.post('http://localhost:11434/api/chat', json={
    "model": "gemma4:31b-it",
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    "stream": False
})

print(response.json()['message']['content'])

Kelebihan dan Kekurangan Ollama

Kelebihan: Zero konfigurasi, deteksi GPU otomatis, CLI yang bersih, API server sudah included, manajemen model yang simpel.

Kekurangan: Opsi kuantisasi lebih sedikit daripada llama.cpp, tidak ada dukungan gambar built-in untuk semua model (cek kompatibilitas terbaru), kontrol yang lebih sedikit atas parameter inferensi.

Metode 3: llama.cpp

Untuk kontrol maksimal atas kuantisasi, penggunaan memori, dan parameter inferensi, llama.cpp adalah jalannya. Ini yang menjadi mesin di balik Ollama dan Unsloth untuk inferensi GGUF.

Build dari Source

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Dengan dukungan CUDA (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Dengan dukungan Metal (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# Hanya CPU
cmake -B build
cmake --build build --config Release -j$(nproc)

Download Model GGUF

Ambil model yang sudah dikuantisasi dari repo HuggingFace Unsloth:

# Install huggingface-cli
pip install huggingface-hub

# Download Q4_K_M (direkomendasikan untuk GPU 24GB)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# Atau Q5_K_M untuk kualitas lebih baik
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Menjalankan Model

# Chat dasar
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64 \
  -p "You are a helpful assistant.\nUser: Explain quantum computing in simple terms.\nAssistant:"

Flag penting:

-ngl 99: Offload semua layer ke GPU. Kurangi angka ini kalau VRAM kamu tidak cukup (misalnya, -ngl 40 meng-offload sekitar dua pertiga layer)
-c 8192: Panjang konteks dalam token. Naikkan hingga 256K untuk dokumen panjang, tapi konteks lebih banyak = VRAM lebih banyak
--temp 1.0: Google merekomendasikan temperature=1.0 untuk Gemma 4
--top-p 0.95 dan --top-k 64: Parameter sampling yang direkomendasikan

Menjalankan Server

./build/bin/llama-server \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Kemudian akses web UI di http://localhost:8080 atau panggil API yang kompatibel dengan OpenAI:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="unused")

response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a Rust function to reverse a linked list."}
    ]
)

print(response.choices[0].message.content)

Strategi GPU Offloading

Kalau GPU kamu tidak punya cukup VRAM untuk model penuh, kamu bisa membagi layer antara GPU dan CPU:

# Untuk GPU 16GB dengan model Q4 (~18GB total)
# Offload sekitar 40 layer ke GPU, sisanya ke CPU
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Ini lebih lambat dari full GPU offload tapi muat di kartu yang lebih kecil. Perkiraan sekitar 5-15 token per detik tergantung CPU kamu dan berapa banyak layer yang di-offload.

Metode 4: HuggingFace Transformers

Kalau kamu sedang membangun aplikasi dan butuh kontrol programatik, HuggingFace Transformers memberikan akses langsung ke model dengan full precision atau kuantisasi kustom.

Instalasi

pip install -U transformers torch accelerate

Untuk dukungan gambar:

pip install -U transformers torch torchvision accelerate

Menjalankan dalam Full Precision (62GB+ VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."},
]

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False
)

inputs = processor(text=text, return_tensors="pt").to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Menjalankan dengan Kuantisasi 4-bit (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

MODEL_ID = "google/gemma-4-31B-it"

# Konfigurasi kuantisasi 4-bit
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quantization_config,
    device_map="auto"
)

Memproses Gambar

Model 31B mendukung input teks dan gambar:

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/photo.jpg"},
            {"type": "text", "text": "Describe what you see in this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Mengaktifkan Mode Thinking

Gemma 4 mendukung penalaran chain-of-thought. Aktifkan dengan mengatur enable_thinking=True:

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Mengaktifkan mode penalaran
)

Saat thinking diaktifkan, model menghasilkan penalaran internal diikuti oleh jawaban akhir. Gunakan processor.parse_response(response) untuk memisahkan thinking dari jawaban.

Memahami Format Kuantisasi GGUF

Kalau kamu mendownload file GGUF, kamu akan melihat banyak akhiran aneh. Ini artinya dalam praktiknya.

Format	Bit	Ukuran (31B)	Kapan Digunakan
Q8_0	8-bit	~32 GB	Kualitas terbaik, butuh VRAM 32GB+
Q6_K	6-bit	~26 GB	Hampir tanpa kehilangan, VRAM 24GB+
Q5_K_M	5-bit	~22 GB	Sweet spot untuk kualitas/ukuran
Q4_K_M	4-bit	~18 GB	Keseimbangan terbaik, muat di GPU 24GB
Q3_K_M	3-bit	~14 GB	GPU lebih kecil, sedikit kehilangan kualitas
Q2_K	2-bit	~10 GB	Pilihan terakhir, degradasi yang terasa

Rekomendasi saya: Q4_K_M untuk GPU 24GB, Q5_K_M kalau kamu bisa menyisakan 4GB ekstra. Perbedaan kualitas antara Q4_K_M dan Q5_K_M bisa diukur di benchmark tapi sulit dirasakan dalam penggunaan sehari-hari. Turun di bawah Q3_K_M tidak sepadan kecuali kamu benar-benar tidak ada pilihan lain.

Akhiran _K_M berarti "K-quantization, medium." Ada juga varian _K_S (small, lebih banyak kompresi) dan _K_L (large, lebih sedikit kompresi). _K_M adalah rekomendasi default.

Tips Performa

Manajemen Panjang Konteks

Gemma 4 31B mendukung konteks hingga 256K token, tapi setiap token dalam konteks memakan VRAM. Beberapa panduan praktis:

4K token: Nyaman di GPU apa pun yang muat modelnya
8K token: Standar untuk kebanyakan percakapan, masih nyaman
32K token: Butuh sekitar 4-6GB VRAM ekstra tergantung kuantisasinya
128K+ token: Membutuhkan VRAM yang besar atau offloading agresif

Mulai dengan -c 8192 dan naikkan hanya ketika kamu butuh.

Parameter Sampling

Google merekomendasikan pengaturan ini untuk Gemma 4:

temperature = 1.0
top_p = 0.95
top_k = 64

Ini beda dari yang dipakai kebanyakan model. Jangan pakai temperature=0.7 dengan Gemma 4; dia dilatih untuk temperature=1.0 dan menghasilkan hasil yang lebih baik di pengaturan itu.

Flash Attention

Kalau kamu pakai HuggingFace Transformers, aktifkan Flash Attention untuk inferensi yang lebih cepat dan penggunaan memori yang lebih rendah:

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

Ini membutuhkan pip install flash-attn dan GPU yang kompatibel (kebanyakan kartu NVIDIA RTX bisa).

Setup Multi-GPU

Kalau kamu punya beberapa GPU, device_map="auto" di Transformers menangani pembagian secara otomatis. Untuk llama.cpp:

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # Bagi sama rata antara 2 GPU
  -c 8192

Pemecahan Masalah

Kehabisan Memori (CUDA OOM)

Masalah yang paling umum. Solusinya berurutan dari yang paling gampang:

Pakai kuantisasi yang lebih kecil: Ganti dari Q5 ke Q4, atau Q4 ke Q3
Kurangi panjang konteks: Turunkan -c dari 8192 ke 4096 atau 2048
Offload ke CPU: Kurangi -ngl untuk meng-offload beberapa layer
Pakai varian 26B A4B MoE: Tingkat kualitas yang sama, sebagian kecil dari VRAM
Pakai varian E4B: Jalan di perangkat apa pun

Inferensi Lambat di CPU

Kalau kamu menjalankan di CPU, bersiaplah untuk 1-3 token per detik untuk model 31B. Pilihannya:

Ganti ke model E4B atau E2B (10-20 token/detik di CPU)
Gunakan instance cloud GPU (LightNode menawarkan opsi VPS GPU)
Build llama.cpp dengan instruction set CPU kamu yang aktif (AVX2, AVX-512)

Kegagalan Download Model

File Q4_K_M sekitar 18GB. Kalau download terus gagal:

# Gunakan huggingface-cli dengan dukungan resume
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models \
  --local-dir-use-symlinks False

Atau gunakan download manager yang mendukung resume. CDN HuggingFace kadang bermasalah untuk file besar.

Error "Model tidak didukung"

Pastikan kamu menggunakan versi terbaru dari tools kamu. Gemma 4 ini baru dan versi lama llama.cpp, Ollama, dan Transformers belum mendukungnya:

# Update llama.cpp
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Update Ollama
ollama pull gemma4:31b-it  # Ini otomatis update kalau perlu

# Update Transformers
pip install -U transformers

Metode Mana yang Harus Kamu Pilih?

Skenario	Metode Terbaik
Kamu mau GUI, gak mau pegang terminal	Unsloth Studio
Kamu mau setup tercepat, CLI gak masalah	Ollama
Kamu butuh kontrol maksimal atas inferensi	llama.cpp
Kamu sedang membuat aplikasi	HuggingFace Transformers
VRAM kamu terbatas (8-16GB)	Unsloth atau Ollama dengan Q3/Q4
Kamu punya VRAM 24GB+	Metode apa pun, pakai Q4_K_M atau Q5_K_M
Kamu butuh pemahaman gambar	Unsloth Studio atau HuggingFace Transformers
Kamu mau fine-tune	Unsloth (training LoRA/GRPO built-in)

Buat kebanyakan orang yang baru mulai, Unsloth Studio adalah jalan paling gampang. Install, cari Gemma 4, pilih kuantisasi yang cocok dengan GPU kamu, dan mulai chat. Seluruh prosesnya cuma butuh sekitar 15 menit dari install sampai percakapan pertama.

Kalau kamu nyaman dengan terminal dan cuma mau menjalankan modelnya, Ollama bisa membawa kamu ke sana dalam dua perintah. Dan kalau kamu butuh akses programatik atau sedang membangun sesuatu di atas model, HuggingFace Transformers dengan kuantisasi 4-bit memberikan kamu akses ke Python API lengkap.

Penutup

Menjalankan Gemma 4 31B secara lokal sekarang sudah sangat praktis. Setahun yang lalu, model 30B di level kualitas ini akan menjadi proyek riset. Sekarang ini cuma proses setup 15 menit dengan Unsloth atau Ollama, dan jalan di perangkat keras konsumen yang bisa kamu beli hari ini.

Modelnya sendiri mampu bersaing dengan alternatif proprietary dalam tugas reasoning, coding, dan multimodal. Konteks 256K, mode thinking built-in, pemahaman gambar, dan function calling membuatnya benar-benar berguna untuk pekerjaan nyata, bukan cuma eksperimen.

Untuk hosting model di GPU remote, LightNode menawarkan instance VPS GPU dengan penagihan per jam, jadi kamu bisa hidupkan saat butuh dan matikan saat tidak.

Model card Gemma 4 di HuggingFace memiliki detail teknis lengkap, dan repo GGUF Unsloth memiliki semua varian terkuantisasi siap diunduh.