Koliko RAM-a potrebujem za lokalni zagon Gemma 4?

Gemma 4 E2B in E4B delujeta že s 5GB RAM s 4-bit quantization — primeren je vsak sodoben prenosnik. Model 26B MoE potrebuje približno 18GB RAM (prilega se v RTX 4090 s 24GB VRAM). Model 31B Dense potrebuje približno 20GB RAM. Za CPU-only izvajanje dodajte 20-30 % več RAM-a, kot je velikost modela.

Kateri model Gemma 4 naj izberem za lokalno uporabo?

Za prenosnike brez namenske GPU: E2B (najhitrejši, najlažji). Za prenosnike z GPU ali namizne računalnike: E4B (boljša kakovost, še vedno lahek). Za namizne računalnike z RTX 4090 ali ekvivalentom: 26B MoE (najboljše razmerje med kakovostjo in zmogljivostjo). Za delovne postaje s 24GB+ VRAM: 31B Dense (najvišja kakovost). 26B MoE je idealna izbira za večino razvijalcev.

Ali je Gemma 4 brezplačna za lokalno uporabo?

Da. Gemma 4 je izdana pod licenco Apache 2.0, ki dovoljuje neomejeno uporabo, vključno s komercialnimi aplikacijami. Ollama je prav tako brezplačna in odprtokodna. Edini strošek je vaša strojna oprema. Ni API fees, ni omejitev uporabe in ni licenčnih omejitev.

Kako hitra je Gemma 4 lokalno v primerjavi s cloud APIs?

Na RTX 4090 Gemma 4 E4B generira 80-120 tokens per second. Model 26B MoE generira 30-50 tokens/sec. Model 31B Dense generira 20-35 tokens/sec. Cloud APIs, kot je Google AI Studio, so morda hitrejši za največje modele, vendar dodajo omrežno latenco 100-500ms na zahtevo. Za interaktivno uporabo je lokalna inferenca na manjših modelih videti trenutna.

Ali lahko Gemma 4 lokalno uporabljam kot API za svoje aplikacije?

Da. Ollama izpostavi lokalni REST API na port 11434, ki je združljiv z OpenAI API formatom. Vsaka aplikacija, framework ali orodje, ki podpira OpenAI API, se lahko poveže z lokalno Gemma 4 tako, da usmeri base URL na http://localhost:11434/v1. To vključuje Python, Node.js in večino AI frameworks.

Ali Gemma 4 podpira GPU acceleration z Ollama?

Da. Ollama samodejno zazna in uporabi NVIDIA GPUs (CUDA), Apple Silicon (Metal) in AMD GPUs (ROCm). Dodatna konfiguracija ni potrebna — če ima vaša GPU dovolj VRAM za model, ga bo Ollama uporabila samodejno. NVIDIA je izdala tudi RTX-optimized različice Gemma 4 za dodatne izboljšave zmogljivosti.

Ključna ugotovitev

Lokalno izvajanje modela Gemma 4 traja manj kot 5 minut z orodjem Ollama: namestite Ollama, zaženite en ukaz in na lastni strojni opremi imate popolnoma zmogljiv model AI brez stroškov API, brez pošiljanja podatkov iz vaše naprave in brez omejitev uporabe pod licenco Apache 2.0. Model E2B deluje na katerem koli prenosniku. Model 26B MoE se prilega na eno kartico RTX 4090 in zagotavlja kakovost, ki tekmuje z modeli z 10x večjim številom aktivnih parametrov.

Lokalno izvajanje modela Gemma 4: Celoten vodnik

Zakaj izvajati Gemma 4 lokalno?

Preden se poglobimo v nastavitev, so tukaj razlogi, zakaj je lokalno sklepanje (inference) pomembno v letu 2026:

Zasebnost — Vaši podatki nikoli ne zapustijo vaše naprave. Nobenih pozivov (prompts) se ne pošilja na zunanje strežnike. Ključno za lastniško kodo, pravne dokumente, medicinske podatke ali katere koli občutljive informacije.
Stroški — Nič stroškov na API tokens po enkratni naložbi v strojno opremo. Intenzivni uporabniki prihranijo na stotine dolarjev na mesec v primerjavi s cenami API.
Zakasnitev — Brez omrežnih prenosov. Modela E2B in E4B se na sodobni strojni opremi odzoveta v milisekundah.
Zanesljivost — Brez omejitev hitrosti API (rate limits), brez izpadov, brez sprememb pravilnikov ponudnikov. Vaš model je vedno na voljo.
Prilagajanje — Prosto izvajajte fine-tune, kvantizacijo in spreminjanje modela pod licenco Apache 2.0.
Dostop brez povezave — Deluje brez internetne povezave, ko je model enkrat prenesen.

Gemma 4 je posebej primerna za lokalno namestitev, ker je Google manjše modele zasnoval posebej za uporabo na robu (edge) in na napravah. Modela E2B in E4B nista bila ustvarjena naknadno — sta vrhunska modela, optimizirana za omejitve lokalne strojne opreme.

Predpogoji

Strojne zahteve po modelih

Model	Najmanj RAM	Priporočeno VRAM	Možno samo s CPU?	Prostor na disku
E2B (4-bit)	5 GB	4 GB	Da	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Da	~2.8 GB
E4B (FP16)	9 GB	9 GB	Počasno	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Zelo počasno	~15 GB
26B MoE (FP16)	52 GB	48 GB	Ne	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Zelo počasno	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Ne	~62 GB

Ključna ugotovitev: Če imate prenosnik, izdelan po letu 2022, lahko poganjate E2B ali E4B. Če imate RTX 4090 (24GB VRAM) ali Apple M-series Mac z 32GB+ RAM, lahko poganjate 26B MoE ali 31B Dense pri 4-bit kvantizaciji.

Programske zahteve

Operacijski sistem: macOS, Linux ali Windows
Ollama: Različica 0.6+ (prenos z ollama.com)
GPU gonilniki (neobvezno): NVIDIA CUDA 12+ za NVIDIA GPU, za Apple Silicon dodatni gonilniki niso potrebni

Korak 1: Namestite Ollama

macOS

Prenesite z ollama.com/download ali uporabite Homebrew:

brew install ollama

Linux

Ukaz za namestitev v eni vrstici:

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

Windows

Prenesite namestitveni program z ollama.com/download in ga zaženite. Ollama se v Windows izvaja kot storitev v ozadju.

Preverite namestitev

ollama --version

Videti bi morali ollama version 0.6.x ali novejšo. Če vidite številko različice, je Ollama pravilno nameščena.

Vir: Ollama navodila za namestitev

Korak 2: Prenesite model Gemma 4

Izberite model, ki ustreza vaši strojni opremi:

Za prenosnike in lažje delovne obremenitve

# Najmanjši model — deluje na vsakem sodobnem prenosniku (5GB RAM)
ollama pull gemma4:e2b

# Majhen model z večjimi zmogljivostmi (5-9GB RAM)
ollama pull gemma4:e4b

Za namizne računalnike z namensko grafično kartico (GPU)

# Najboljša učinkovitost — vrhunska kakovost pri 3.8B aktivnih parametrih (18GB RAM)
ollama pull gemma4:26b-moe

# Najvišja kakovost — celotnih 31B parametrov (20GB RAM)
ollama pull gemma4:31b

Določanje kvantizacije

Ollama privzeto prenese priporočeno kvantizacijo za vsak model (običajno Q4_K_M za dobro ravnovesje med kakovostjo in velikostjo). Določite lahko tudi druge kvantizacije:

# Višja kakovost, večja velikost
ollama pull gemma4:31b-q5_K_M

# Manjša velikost, nekoliko nižja kakovost
ollama pull gemma4:31b-q3_K_M

# Polna natančnost (zahteva veliko več RAM)
ollama pull gemma4:31b-fp16

Prenos bo trajal nekaj minut, odvisno od vaše internetne povezave. Velikosti modelov se gibljejo od ~1.5GB (E2B 4-bit) do ~62GB (31B FP16).

Korak 3: Zaženite Gemma 4

Interaktivni klepet

ollama run gemma4:e4b

To odpre interaktivno sejo klepeta. Vtipkajte svoj poziv in pritisnite Enter:

>>> What are the key differences between REST and GraphQL APIs?

Model bo odgovoril neposredno v vašem terminalu. Za izhod vtipkajte /bye.

Posamezen poziv (neinteraktivno)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Z načinom razmišljanja (Thinking Mode)

Gemma 4 podpira nastavljiv način razmišljanja za zapletene naloge. Omogočite ga z dodajanjem sistemskega poziva:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Pri matematičnih, logičnih in kompleksnih analizah način razmišljanja znatno izboljša kakovost odgovorov. Model bo ustvaril 4,000+ tokens notranjega razmišljanja, preden poda končni odgovor.

Korak 4: Uporabite lokalni API

Ollama izpostavi REST API na localhost:11434, ki je združljiv z OpenAI API formatom. To pomeni, da se lahko katero koli orodje ali knjižnica, ki podpira OpenAI API, poveže z vašo lokalno Gemma 4 s preprosto spremembo URL.

Testirajte API s curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Končna točka, združljiva z OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Vir: Ollama API dokumentacija

Korak 5: Integracija v vašo aplikacijo

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Uporaba
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python z OpenAI SDK

from openai import OpenAI

# Povezava na lokalno Ollama namesto na OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama ne zahteva pravega API ključa
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Uporaba z LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Uporaba z LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Razlaga možnosti kvantizacije

Kvantizacija zmanjša velikost modela in porabo pomnilnika z uporabo števil z nižjo natančnostjo za predstavitev uteži modela. Kompromis je med kakovostjo in porabo virov:

Kvantizacija	Bitov na utež	Vpliv na kakovost	Prihranek pomnilnika	Najboljše za
FP16	16 bits	Brez (polna kakovost)	Izhodišče	Strežniki z obilo VRAM
Q8_0	8 bits	Zanemarljiv	~50%	Visokokakovostno lokalno sklepanje
Q6_K	6 bits	Zelo majhen	~62%	Lokalna uporaba s poudarkom na kakovosti
Q5_K_M	5 bits	Majhen	~69%	Dobro ravnovesje
Q4_K_M	4 bits	Majhen	~75%	Priporočena privzeta možnost
Q3_K_M	3 bits	Zmeren	~81%	Omejena strojna oprema
Q2_K	2 bits	Znatno	~87%	Ekstremne omejitve

Q4_K_M je zlata sredina za večino uporabnikov. Razlika v kakovosti glede na FP16 je dovolj majhna, da večina nalog daje neločljive rezultate, medtem ko prihranek pomnilnika v višini 75% predstavlja razliko med "potrebuje strežnik" in "deluje na mojem prenosniku".

Izbira prave kvantizacije

Za Gemma 4 E2B/E4B: Uporabite privzeto (Q4_K_M). Ti modeli so že tako majhni, da višja kvantizacija ne spremeni bistveno uporabniške izkušnje.

Za Gemma 4 26B MoE: Q4_K_M se prilega v 18GB RAM, kar je znotraj 24GB VRAM kartice RTX 4090 s prostorom za KV cache. Če imate 48GB+ VRAM (A6000, dvojni GPU), razmislite o Q8_0 za malenkost boljšo kakovost.

Za Gemma 4 31B Dense: Q4_K_M pri 20GB se prilega v RTX 4090 s tesnimi robovi. Q5_K_M daje nekoliko boljše rezultate, vendar zahteva ~24GB, kar porabi ves razpoložljiv VRAM. Če imate 32GB+ VRAM (RTX 5090, A6000), sta Q6_K ali Q8_0 vredna nadgradnje.

Optimizacija zmogljivosti

Razbremenitev na GPU (GPU Offloading)

Ollama samodejno preloži plasti modela na GPU, ko je VRAM na voljo. Če se le del modela prilega v VRAM, Ollama delo razdeli med GPU in CPU. To lahko nadzirate:

# Prisilno naloži vse plasti na GPU (spodleti, če ni dovolj VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Prisilno uporabi samo CPU (uporabno za testiranje)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfiguracija okna konteksta (Context Window)

Za večjo učinkovitost Ollama privzeto uporablja okno konteksta 2048 tokens. Za uporabo polnih zmogljivosti konteksta Gemma 4:

# Nastavi okno konteksta na 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Nastavi okno konteksta na 128K tokens (zahteva več RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Pomembno: Večja okna konteksta porabijo več RAM za KV cache. Okno 128K na modelu 31B lahko zahteva dodatnih 8-16GB RAM poleg uteži modela. Začnite z 32K in povečujte le, če vaš primer uporabe to zahteva.

Hkratne zahteve

Ollama podpira strežbo več zahtev hkrati:

# Dovoli do 4 hkratne zahteve
OLLAMA_NUM_PARALLEL=4 ollama serve

Vsaka hkratna zahteva doda porabo pomnilnika za svoj KV cache. Na 24GB GPU, ki poganja 26B MoE pri Q4_K_M (~18GB), imate približno 6GB rezerve — dovolj za 2-3 hkratne zahteve s kratkimi konteksti.

Nastavitve ohranjanja v pomnilniku (Keep-Alive)

Ollama privzeto ohranja modele v pomnilniku 5 minut po zadnji zahtevi. To prilagodite svojemu primeru uporabe:

# Ohrani model naložen 1 uro
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Ohrani model naložen za nedoločen čas
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Odloži model takoj po vsaki zahtevi (varčuje s pomnilnikom)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX Optimizacija

NVIDIA je izdala optimizirane različice Gemma 4 za RTX grafične kartice. Te optimizacije vključujejo:

Prilagojena CUDA jedra za mehanizem pozornosti (attention mechanism) modela Gemma 4
Integracija TensorRT-LLM za hitrejše sklepanje
Podpora Flash Attention za manjšo porabo pomnilnika pri sklepanju z dolgim kontekstom
Optimizirano upravljanje KV cache za boljši pretok podatkov

Namestitev NVIDIA-optimizirane Gemma 4

Če imate grafično kartico serije RTX 4000 ali 5000:

# Preverite svojo grafično kartico
nvidia-smi

# Prenesite NVIDIA-optimizirano različico (če je na voljo v Ollama)
ollama pull gemma4:31b-nvidia

Alternativno lahko za maksimalno zmogljivost uporabite NVIDIA AI Workbench ali TensorRT-LLM neposredno. NVIDIA-optimizirane različice lahko zagotovijo 30-50% hitrejše sklepanje na RTX grafičnih karticah v primerjavi s standardnimi Ollama različicami.

Primerjalni testi zmogljivosti v resničnem svetu

Izmerjeno na običajnih strojnih konfiguracijah:

Tokens na sekundo (hitrost generiranja)

Model	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	Samo CPU (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

Kontekst: Hitrost človeškega branja je približno 4-5 tokens na sekundo. Vsak model, ki generira več kot 10 tok/s, deluje "takojšnje" za interaktivno uporabo. Modela E2B in E4B sta dovolj hitra za pretakanje v realnem času na skoraj kateri koli strojni opremi.

Čas do prvega žetona (Latency)

Model	RTX 4090	M3 Max	Samo CPU
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Pri interaktivnih aplikacijah je čas do prvega žetona pomembnejši od hitrosti generiranja. Modela E2B in E4B začneta generirati skoraj takoj tudi na CPU, zaradi česar sta idealna za klepetalne vmesnike v realnem času.

Pogosti primeri uporabe

Lokalni pomočnik za programiranje

Uporabite Gemma 4 kot zasebnega pomočnika za programiranje, ki nikoli ne pošilja vaše kode na zunanje strežnike:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Povežite to z VS Code razširitvami, kot sta Continue ali Twinny, ki podpirata Ollama kot zaledje.

Analiza dokumentov

Obdelujte občutljive dokumente lokalno:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Z 256K kontekstom lahko model 31B obdeluje dokumente do ~750 strani — kar zadostuje za večino pogodb, raziskovalnih nalog in tehnične dokumentacije.

Lokalni RAG (Retrieval-Augmented Generation)

Združite Gemma 4 z lokalno vektorsko bazo podatkov za popolnoma zaseben RAG sistem:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Uporabite Gemma 4 tako za embeddinge kot za generiranje
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Ustvarite vektorsko shrambo iz svojih dokumentov
vectorstore = Chroma.from_documents(documents, embeddings)

# Poizvedba z RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

Izgradnja AI funkcij v aplikacijah

Za razvijalce, ki gradijo aplikacije z AI zmogljivostmi, je izvajanje Gemma 4 lokalno prek Ollama API najhitrejša pot do delujočega prototipa. API, združljiv z OpenAI, pomeni, da lahko začnete z lokalno Gemma 4 za razvoj in preklopite na API-je v oblaku za produkcijo brez spreminjanja kode aplikacije.

Platforme, kot je ZBuild, lahko poskrbijo za infrastrukturo aplikacije — frontend, backend, avtentikacijo, bazo podatkov — medtem ko se vi osredotočite na integracijski sloj AI. Med razvojem usmerite AI končno točko vaše aplikacije na localhost:11434 in preklopite na končno točko v oblaku, ko ste pripravljeni na povečanje obsega.

Odpravljanje težav

Napake "Out of memory"

Če vidite napake glede pomnilnika:

Poskusite z nižjo kvantizacijo: ollama pull gemma4:31b-q3_K_M
Zmanjšajte okno konteksta: --num-ctx 4096
Zaprite druge aplikacije, ki intenzivno uporabljajo GPU
Preklopite na manjši model: 26B MoE zagotavlja kakovost blizu 31B pri nižjih stroških pomnilnika

Počasna hitrost generiranja

Če je generiranje počasnejše od pričakovanega:

Preverite uporabo GPU: nvidia-smi (morala bi kazati visoko uporabo GPU)
Zagotovite, da se model v celoti prilega v VRAM — delna razbremenitev na CPU je bistveno počasnejša
Zmanjšajte --num-ctx, da sprostite VRAM za izračune
Preverite, ali drugi procesi uporabljajo GPU

Model ni najden

Če ukaz ollama run gemma4:26b-moe ne uspe:

# Seznam razpoložljivih modelov
ollama list

# Iskanje modelov Gemma 4
ollama search gemma4

# Prenos specifičnega modela
ollama pull gemma4:26b-moe

Povezava API zavrnjena

Če se aplikacije ne morejo povezati na localhost:11434:

# Preverite, ali se Ollama izvaja
ollama list

# Ročno zaženite strežnik Ollama
ollama serve

# Preverite vrata (port)
curl http://localhost:11434/api/tags

Odločitveno drevo za izbiro modela

Uporabite to za hiter izbor pravega modela:

Ali imate namensko grafično kartico (GPU) s 16GB+ VRAM?

Da → Želite maksimalno kakovost ali maksimalno učinkovitost?
- Maksimalna kakovost → gemma4:31b (Q4_K_M, potrebuje 20GB)
- Maksimalna učinkovitost → gemma4:26b-moe (Q4_K_M, potrebuje 18GB)
Ne → Ali imate 8GB+ RAM?
- Da → gemma4:e4b (Q4_K_M, boljša kakovost)
- Ne → gemma4:e2b (Q4_K_M, deluje na 5GB)

Za večino razvijalcev s sodobnim namiznim ali gaming računalnikom: Začnite z gemma4:26b-moe. Ponuja najboljše razmerje med kakovostjo in viri v celotni družini Gemma 4.

Kaj lahko zgradite

Z lokalno delujočim modelom Gemma 4 imate AI zaledje brez stroškov za:

Aplikacije za klepet s popolno zasebnostjo pogovorov
Orodja za analizo kode, ki delujejo na lastniških bazah kode
Cevovode za obdelavo dokumentov za občutljive podatke
Lokalne AI asistente, ki delujejo brez povezave
Prototipne AI funkcije, preden se zavežete stroškom API v oblaku
Fine-tuned modele za specifične naloge (Apache 2.0 to omogoča prosto)

Licenca Apache 2.0 pomeni, da je vse, kar zgradite, vaše — brez omejitev uporabe, brez delitve prihodkov, brez potrebe po odobritvi. Zaženite ga lokalno, namestite na svoje strežnike, vgradite v svoje izdelke. To je pravi obraz odprte umetne inteligence.

Zaženite Gemma 4 lokalno v 5 minutah: Popoln vodič za nastavitev Ollama (2026)