Gemma 4 31B'yi Lokal Olarak Nasıl Çalıştırırsınız: Unsloth, Ollama, llama.cpp ve HuggingFace

Google DeepMind, Gemma 4'ü 2026 başlarında piyasaya sürdü ve 31B instruction-tuned varyasyonu tam kıvamında bir model: muhakeme benchmark'larında mülkiyetli modellerle yarışacak kadar güçlü, iyi bir tüketici GPU'sunda çalışacak kadar kompakt. MMLU Pro'da %85.2 ve AIME 2026'da araç kullanmadan %89.2 skor alıyor, bu da onu iki kat büyük modellerle aynı ligde konumlandırıyor.

İşte sorun hep şuydu: "Bunu nasıl çalıştıracağım?" 30.7B parametreli bir model full precision'da yaklaşık 62GB VRAM istiyor. Bunu tek bir kartta bulmak pek mümkün değil. Ama doğru quantization ve doğru araçlarla bunu 24GB'lık bir RTX 4090'da çalıştırabilir, hatta 16GB'lık bir kartta CPU'ya kısmen yükleyebilirsiniz. GPU'lu VPS istiyorsanız taahhüt olmadan LightNode'u öneriyoruz.

Bu rehber dört yöntemi kapsıyor ve çoğu kişi için ana öneri Unsloth.

İçindekiler

1. Gemma 4 Model Ailesine Genel Bakış
2. Donanım Gereksinimleri
3. Yöntem 1: Unsloth Studio (Önerilen)
4. Yöntem 2: Ollama
5. Yöntem 3: llama.cpp
6. Yöntem 4: HuggingFace Transformers
7. GGUF Quantization Formatlarını Anlamak
8. Performans İpuçları
9. Sorun Giderme
10. Hangi Yöntemi Seçmelisiniz?

Gemma 4 Model Family Overview

Gemma 4 dört farklı boyutta geliyor. Doğrusunu seçmek önemli çünkü aralarındaki donanım sıçraması ciddi.

Varyant	Toplam Param	Aktif Param	Bağlam	Modaliteler	En İyi Kullanım
E2B	5.1B	2.3B efektif	128K	Metin, Görsel, Ses	Telefonlar, Raspberry Pi
E4B	8B	4.5B efektif	128K	Metin, Görsel, Ses	Dizüstü bilgisayarlar, sadece CPU
26B A4B (MoE)	25.2B	3.8B aktif	256K	Metin, Görsel	Hızlı çıkarım, daha az VRAM
31B (Dense)	30.7B	30.7B	256K	Metin, Görsel	Maksimum kalite

26B A4B akıllı olanı: 25.2B toplam parametre var ama Mixture-of-Experts mimarisi sayesinde çıkarım sırasında sadece 3.8B'si aktif oluyor (128 uzman içinden 8 aktif, artı 1 paylaşılan). Neredeyse 4B'lik bir model kadar hızlı çalışırken 31B'nin kalitesine yakın sonuçlar veriyor. GPU'nuzda 12-16GB VRAM varsa, Q4 quantization'da 26B A4B muhtemelen en iyi seçeneğiniz.

31B Dense, bu rehberin odaklandığı model. Her forward pass'te tüm parametreleri aktif olan tam yağlı model. En iyi kalite, en yüksek donanım gereksinimi.

Dört varyantın hepsi yapılandırılabilir düşünme modu (chain-of-thought muhakemesi), yerel sistem promptları, fonksiyon çağırma ve 140+ dili destekliyor.

Hardware Requirements

Bir yöntem seçmeden önce elimizdeki donanımı belirleyelim.

Gemma 4 31B-it İçin

Quantization	Gerekli VRAM	Kalite Kaybı	Tipik Donanım
FP16 (full precision)	~62 GB	Yok	A100, birden fazla GPU
Q8_0 (8-bit)	~32 GB	ihmal edilebilir	RTX 4090 (24GB) + CPU offload
Q5_K_M (5-bit)	~22 GB	Minimum	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 GB	Az	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 GB	Farkedilir	RTX 4070, kısmi offload

Gemma 4 26B A4B (MoE) İçin

Quantization	Gerekli VRAM	Kalite Kaybı	Tipik Donanım
Q5_K_M	~14 GB	Minimum	RTX 4070 Ti
Q4_K_M	~10 GB	Az	RTX 4070, RTX 3080
Q3_K_M	~8 GB	Farkedilir	RTX 4060 Ti 8GB

Sadece CPU'da çalışıyorsanız E4B veya E2B varyantları rahatça çalışır. 31B'yi CPU'da çalıştırmak teknik olarak mümkün ama acı verici derecede yavaş (modern bir CPU'da saniyede 1-3 token bekleyin).

RAM gereksinimi: VRAM'e ek olarak çalışma zamanı yükü için 8-16GB sistem RAM ekleyin, katmanları CPU'ya offload ediyorsanız daha fazla.

Method 1: Unsloth Studio (Önerilen)

Unsloth, Gemma 4'ü lokalde çalıştırmanın en kolay yolu. Model indirme, quantization seçimi ve çıkarımı tek pakette halleden bir web arayüzü. Windows, Linux, macOS ve WSL'de çalışır.

Neden Unsloth

• HuggingFace'ten tek tıkla model arama ve indirme
• Donanımınıza uygun GGUF quantization'ı otomatik seçer
• Görsel, PDF ve doküman desteği olan yerleşik sohbet arayüzü
• Dahili araç çağırma ve web arama
• Kod çalıştırma sandbox'ı
• Komut satırı karmaşası yok

Kurulum

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

Başlatma

unsloth studio -H 0.0.0.0 -p 8888

Tarayıcınızda http://localhost:8888 adresini açın. Unsloth Studio arayüzünü göreceksiniz.

Gemma 4 31B'yi Çalıştırma

1. Modeli arayın: Model arama çubuğuna gemma-4-31B yazın
2. Quantization seçin: Unsloth önceden quantize edilmiş GGUF dosyalarını barındırır. 24GB GPU için Q4_K_M veya Q5_K_M seçin. 16GB için Q3_K_M ile gidin
3. İndirin: İndir'e tıklayın. Q4_K_M varyantı yaklaşık 18GB
4. Sohbete başlayın: İndirme tamamlandığında model otomatik olarak sohbet arayüzüne yüklenir

Unsloth, Gemma 4 31B-it için şu GGUF varyantlarını sunuyor:

Dosya	Boyut	Quantization
gemma-4-31B-it-Q3_K_M.gguf	~14 GB	3-bit (dengeli)
gemma-4-31B-it-Q4_K_M.gguf	~18 GB	4-bit (önerilen)
gemma-4-31B-it-Q5_K_M.gguf	~22 GB	5-bit (yüksek kalite)
gemma-4-31B-it-Q6_K.gguf	~26 GB	6-bit (kayıpsıza yakın)
gemma-4-31B-it-Q8_0.gguf	~32 GB	8-bit (neredeyse kayıpsız)

HuggingFace reposu: unsloth/gemma-4-31B-it-GGUF.

Sohbet Arayüzünü Kullanma

Unsloth Studio'nun sohbeti şunları destekler:

• Düşünme modu açma/kapama ile Metin konuşmaları
• Görsel yükleme: Görsel soru-cevap için sürükle bırak
• PDF/DOCX yükleme: Doküman içeriğini çıkarın ve tartışın
• Kod çalıştırma: Model sandbox içinde kod yazıp test edebilir
• Özel sistem promptları: Davranış ve persona ayarlayın

Gemma 4'ün düşünme modunu etkinleştirmek için sohbet ayarlarından "Thinking" seçeneğini açın. Bu, chain-of-thought muhakemesini aktifleştirir; model nihai cevabını vermeden önce problemleri adım adım çözer.

Unsloth ile Fine-Tuning

Sadece çıkarımın ötesine geçmek istiyorsanız Unsloth eğitim işlemlerini de halleder:

• LoRA fine-tuning: %70'e varan daha az VRAM ile adapter eğitin
• GRPO pekiştirmeli öğrenme: Mevcut en verimli RL kütüphanesi
• Data Recipes: PDF, CSV, DOCX dosyalarından otomatik eğitim verisi oluşturma
• Çoklu GPU desteği: Şu an mevcut, iyileştirmeler yolda

Gemma 4 31B fine-tuning için en az bir 24GB GPU ve QLoRA (4-bit quantize edilmiş eğitim) gerekiyor.

Unsloth'u Güncelleme

Aynı kurulum komutunu tekrar çalıştırın:

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

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

Method 2: Ollama

Ollama, komut satırını tercih ediyorsanız en hızlı başlama yolu. Model indirme, GPU algılama ve sunum işlemlerini otomatik halleder.

Kurulum

# macOS
brew install ollama

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

# Windows
# https://ollama.com/download adresinden indirin

Gemma 4'ü Çalıştırma

# 31B modeli indir ve çalıştır
ollama run gemma4:31b-it

# Daha az VRAM için daha küçük MoE varyantı
ollama run gemma4:26b-a4b-it

# Veya daha küçük dense modeller
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama varsayılan olarak Q4_K_M quantization'ını kullanır. Farklı bir quantization istiyorsanız:

# Belirli quantization ile çalıştır
ollama run gemma4:31b-it-q5_K_M

API Kullanımı

Ollama 11434 portunda yerel bir API sunar:

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

Ollama Avantaj ve Dezavantajları

Avantajlar: Sıfır konfigürasyon, otomatik GPU algılama, temiz CLI, dahili API sunucusu, basit model yönetimi.

Dezavantajlar: llama.cpp'den daha az quantization seçeneği, tüm modeller için yerleşik görsel desteği yok (mevcut uyumluluğu kontrol edin), çıkarım parametreleri üzerinde daha az kontrol.

Method 3: llama.cpp

Quantization, bellek kullanımı ve çıkarım parametreleri üzerinde maksimum kontrol istiyorsanız llama.cpp doğru seçim. Ollama ve Unsloth'un GGUF çıkarımı için arka planda kullandığı şey budur.

Kaynaktan Derleme

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

# CUDA desteği ile (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Metal desteği ile (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

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

GGUF Modelini İndirme

Quantize edilmiş modeli Unsloth'un HuggingFace reposundan alın:

# huggingface-cli'yi kurun
pip install huggingface-hub

# Q4_K_M indirin (24GB GPU'lar için önerilen)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# Veya daha iyi kalite için Q5_K_M
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Modeli Çalıştırma

# Temel sohbet
./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:"

Önemli parametreler:

• -ngl 99: Tüm katmanları GPU'ya offload edin. Yeterli VRAM'iniz yoksa bu sayıyı azaltın (örn., -ngl 40 katmanların yaklaşık üçte birini GPU'ya yükler)
• -c 8192: Token cinsinden bağlam uzunluğu. Uzun dokümanlar için 256K'ya kadar çıkarın, ancak daha fazla bağlam daha fazla VRAM kullanır
• --temp 1.0: Google, Gemma 4 için temperature=1.0 öneriyor
• --top-p 0.95 ve --top-k 64: Önerilen sampling parametreleri

Sunucu Başlatma

./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

Ardından http://localhost:8080 adresinden web arayüzüne erişin veya OpenAI uyumlu API'yi çağırın:

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)

GPU Offloading Stratejisi

GPU'nuzda tüm model için yeterli VRAM yoksa katmanları GPU ve CPU arasında bölebilirsiniz:

# 16GB GPU ile Q4 modeli için (~18GB toplam)
# Yaklaşık 40 katmanı GPU'ya, kalanı CPU'ya offload edin
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Bu, tam GPU offload'dan daha yavaş çalışır ama daha küçük kartlara sığar. CPU'nuza ve kaç katman offload ettiğinize bağlı olarak yaklaşık saniyede 5-15 token bekleyin.

Method 4: HuggingFace Transformers

Bir uygulama geliştiriyorsanız ve programatik kontrole ihtiyacınız varsa, HuggingFace Transformers size full precision veya özel quantization ile doğrudan model erişimi sağlar.

Kurulum

pip install -U transformers torch accelerate

Görsel destek için:

pip install -U transformers torch torchvision accelerate

Full Precision ile Çalıştırma (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)

4-bit Quantization ile Çalıştırma (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

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

# 4-bit quantization yapılandırması
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"
)

Görsel İşleme

31B model metin ve görsel girdiyi destekler:

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)

Düşünme Modunu Etkinleştirme

Gemma 4 chain-of-thought muhakemesini destekler. enable_thinking=True ayarlayarak etkinleştirin:

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Muhakeme modunu aktifleştirir
)

Düşünme modu etkinleştirildiğinde, model iç muhakemesini ve ardından nihai cevabını üretir. Düşünme ile cevabı ayırmak için processor.parse_response(response) kullanın.

Understanding GGUF Quantization Formats

GGUF dosyaları indiriyorsanız birçok sonek göreceksiniz. Pratikte bunlar ne anlama geliyor?

Format	Bit	Boyut (31B)	Ne Zaman Kullanılır
Q8_0	8-bit	~32 GB	En iyi kalite, 32GB+ VRAM gerekir
Q6_K	6-bit	~26 GB	Kayıpsıza yakın, 24GB+ VRAM
Q5_K_M	5-bit	~22 GB	Kalite/boyut için tatlı nokta
Q4_K_M	4-bit	~18 GB	En iyi denge, 24GB GPU'ya sığar
Q3_K_M	3-bit	~14 GB	Daha küçük GPU, biraz kalite kaybı
Q2_K	2-bit	~10 GB	Son çare, belirgin düşüş

Benim önerim: 24GB GPU'lar için Q4_K_M, fazladan 4GB ayırabiliyorsanız Q5_K_M. Q4_K_M ve Q5_K_M arasındaki kalite farkı benchmark'larda ölçülebilir ama günlük kullanımda fark etmek zor. Q3_K_M'nin altına inmek, başka seçeneğiniz yoksa bile pek mantıklı değil.

_K_M soneki "K-quantization, medium" anlamına gelir. _K_S (küçük, daha fazla sıkıştırma) ve _K_L (büyük, daha az sıkıştırma) varyantları da vardır. Varsayılan öneri _K_M'dir.

Performance Tips

Bağlam Uzunluğu Yönetimi

Gemma 4 31B 256K token'a kadar bağlam destekler, ancak bağlamdaki her token VRAM harcar. Birkaç pratik kılavuz:

• 4K token: Modele sığan herhangi bir GPU'da rahat
• 8K token: Çoğu konuşma için standart, hala rahat
• 32K token: Quantization'a bağlı olarak yaklaşık 4-6GB fazladan VRAM gerekir
• 128K+ token: Ciddi VRAM veya agresif offloading gerekir

-c 8192 ile başlayın ve sadece ihtiyacınız olduğunda artırın.

Sampling Parametreleri

Google, Gemma 4 için şu ayarları öneriyor:

temperature = 1.0
top_p = 0.95
top_k = 64

Bunlar çoğu modelin kullandığından farklı. Gemma 4 ile temperature=0.7 kullanmayın; temperature=1.0 için eğitilmiş ve o ayarda daha iyi sonuçlar üretiyor.

Flash Attention

HuggingFace Transformers kullanıyorsanız, daha hızlı çıkarım ve daha düşük bellek kullanımı için Flash Attention'ı etkinleştirin:

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

Bu, pip install flash-attn ve uyumlu bir GPU gerektirir (çoğu NVIDIA RTX kartı çalışır).

Çoklu GPU Kurulumu

Birden fazla GPU'nuz varsa Transformers'daki device_map="auto" bölmeyi otomatik halleder. llama.cpp için:

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # 2 GPU arasında eşit böl
  -c 8192

Troubleshooting

Bellek Yetersizliği (CUDA OOM)

En yaygın sorun. Çözümler, çaresizlik sırasına göre:

1. Daha küçük quantization kullanın: Q5'ten Q4'e veya Q4'ten Q3'e geçin
2. Bağlam uzunluğunu azaltın: -c değerini 8192'den 4096 veya 2048'e düşürün
3. CPU'ya offload edin: Bazı katmanları offload etmek için -ngl değerini düşürün
4. 26B A4B MoE varyantını kullanın: Aynı kalite seviyesi, VRAM'in çok küçük bir kısmı
5. E4B varyantını kullanın: Her şeyde çalışır

CPU'da Yavaş Çıkarım

CPU'da çalıştırıyorsanız 31B model için saniyede 1-3 token bekleyin. Seçenekler:

• E4B veya E2B modeline geçin (CPU'da saniyede 10-20 token)
• Bir GPU bulut instance'ı kullanın (LightNode GPU VPS seçenekleri sunuyor)
• llama.cpp'yi CPU'nuzun komut setleri etkin olarak derleyin (AVX2, AVX-512)

Model İndirme Hataları

Q4_K_M dosyası yaklaşık 18GB. İndirme sürekli başarısız oluyorsa:

# Resume desteği ile huggingface-cli kullanın
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

Veya resume destekleyen bir indirme yöneticisi kullanın. HuggingFace CDN büyük dosyalar için bazen sorun çıkarabilir.

"Model desteklenmiyor" Hataları

Araçlarınızın en son sürümünü kullandığınızdan emin olun. Gemma 4 yeni ve llama.cpp, Ollama ve Transformers'ın eski sürümleri desteklemiyor:

# llama.cpp'yi güncelleyin
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Ollama'yı güncelleyin
ollama pull gemma4:31b-it  # Gerekirse otomatik güncellenir

# Transformers'ı güncelleyin
pip install -U transformers

Which Method Should You Pick?

Senaryo	En İyi Yöntem
GUI istiyorsunuz, terminali hiç görmek istemiyorsunuz	Unsloth Studio
En hızlı kurulum istiyorsunuz, CLI sorun değil	Ollama
Çıkarım üzerinde maksimum kontrol gerekiyor	llama.cpp
Bir uygulama geliştiriyorsunuz	HuggingFace Transformers
Sınırlı VRAM'iniz var (8-16GB)	Unsloth veya Ollama ile Q3/Q4
24GB+ VRAM'iniz var	Herhangi bir yöntem, Q4_K_M veya Q5_K_M kullanın
Görsel anlama gerekiyor	Unsloth Studio veya HuggingFace Transformers
Fine-tuning yapmak istiyorsunuz	Unsloth (dahili LoRA/GRPO eğitimi)

Yeni başlayanların çoğu için Unsloth Studio en az direnç gösteren yol. Kurun, Gemma 4'ü arayın, GPU'nuzuna uygun bir quantization seçin ve sohbete başlayın. Kurulumdan ilk konuşmaya kadar整个过程 yaklaşık 15 dakika sürer.

Terminalde rahatsanız ve sadece modeli çalıştırmak istiyorsanız, Ollama iki komutla sizi oraya getirir. Ve programatik erişime ihtiyacınız varsa veya model üzerine bir şey inşa ediyorsanız, 4-bit quantization ile HuggingFace Transformers size tam Python API'si sunar.

Sonuç

Gemma 4 31B'yi lokalde çalıştırmak artık şaşırtıcı derecede pratik. Bir yıl önce bu kalite seviyesinde bir 30B model bir araştırma projesi olurdu. Şimdi Unsloth veya Ollama ile 15 dakikalık bir kurulum süreci ve bugün satın alabileceğiniz tüketici donanımında çalışıyor.

Modelin kendisi muhakeme, kodlama ve multimodal görevlerde mülkiyetli alternatiflerle başa baş gidiyor. 256K bağlam, yerleşik düşünme modu, görsel anlama ve fonksiyon çağırma, onu sadece deneme değil gerçek işler için gerçekten kullanışlı kılıyor.

Modeli uzak bir GPU'da barındırmak için LightNode saatlik faturalamayla GPU VPS instance'ları sunuyor; böylece ihtiyacınız olduğunda açıp bitince kapatabilirsiniz.

HuggingFace'teki Gemma 4 model kartında tam teknik detaylar ve Unsloth GGUF reposunda indirmeye hazır tüm quantize edilmiş varyantlar bulunuyor.