Gemma 4 (26B MoE, 4B सक्रिय)

Gemma 4 (26B MoE, 4B सक्रिय) को Google द्वारा Clore.ai पर डिप्लॉय करें — अप्रैल 2026 में जारी किया गया ओपन-वेट मॉडल जो पहुँच गया

स्थिति (अप्रैल 2026): Gemma 4 को जारी किया गया था 2 अप्रैल, 2026 को Google द्वारा Gemma ओपन-वेट परिवार की अगली पीढ़ी के रूप में। दो वेरिएंट उपलब्ध हैं: एक 31B डेंस मॉडल (google/gemma-4-31b-it) और एक 26B MoE, लगभग 4B सक्रिय पैरामीटर के साथ (google/gemma-4-26b-it). दोनों को मानक Gemma उपयोग शर्तों के अंतर्गत huggingface.co/google/gemma-4-26b-it और huggingface.co/google/gemma-4-31b-it.

पर प्रकाशित किया गया है। Gemma 4, Gemma लाइन में Google की पहली MoE प्रविष्टि है और पहली Gemma रिलीज़ है जो LMSYS Arena के शीर्ष तक पहुँची (विक्रेता रिपोर्टें रिलीज़ पर कुल #3बताती हैं, और तथ्यात्मकता तथा निर्देश-पालन में कई बंद मॉडलों को पीछे छोड़ती हैं)। मुख्य संख्या MoE वेरिएंट की है: कुल 26B पैरामीटर, प्रति टोकन लगभग 4B सक्रियजो आपको छोटे डेंस मॉडल की इनफरेंस लागत पर लगभग फ्रंटियर-स्तर का निर्देश-पालन देता है।

Clore.ai उपयोगकर्ताओं के लिए व्यावहारिक निष्कर्ष सरल है — 26B MoE एक अकेले RTX 4090 (24GB) पर FP8 या 4-बिट क्वांटाइज़ेशन के साथ आराम से चलता है (~10 tok/s) और एक अकेले H100 80GB पर प्रोडक्शन-ग्रेड थ्रूपुट (~40+ tok/s) देता है, जिससे Gemma-स्तरीय निर्देश-पालन मार्केटप्लेस पर लगभग $0.5–2/दिन की लागत में संभव हो जाता है। 31B डेंस वेरिएंट अधिक सक्षम लेकिन अधिक महंगा भाई है, जिसे सर्व करने के लिए 2× RTX 4090 या 1× H100 चाहिए।

मुख्य विशेषताएँ

• MoE आर्किटेक्चर (26B वेरिएंट) — 26B कुल पैरामीटर, प्रति टोकन लगभग 4B सक्रिय; 26B-श्रेणी की गुणवत्ता के लिए 4B-श्रेणी की इनफरेंस लागत चुकाएँ

• डेंस विकल्प (31B वेरिएंट) — उन टीमों के लिए जो डेंस इनफरेंस की पूर्वानुमेयता और टूलिंग की परिपक्वता पसंद करती हैं

• 128K कॉन्टेक्स्ट विंडो — लंबे दस्तावेज़ों पर Q&A, मध्यम आकार के कोडबेस पर RAG, मल्टी-टर्न एजेंट लूप

• मजबूत निर्देश-पालन — Gemma 4 को खास तौर पर टूल उपयोग, संरचित आउटपुट, और बाधाओं का निष्ठापूर्वक पालन करने के लिए ट्यून किया गया है

• बहुभाषी — Gemma 3 की पूरी बहुभाषी कवरेज आगे लाई गई है, साथ ही एक विस्तारित गैर-अंग्रेज़ी बेंचमार्क सूट

• ओपन वेट्स, Gemma शर्तें — अधिकांश व्यावसायिक उपयोग के लिए मुफ़्त; आगे बढ़ाने से पहले Gemma निषिद्ध उपयोग नीति की समीक्षा करें

• प्रथम श्रेणी टूलिंग — vLLM, SGLang, Ollama, और Hugging Face Transformers में डिफ़ॉल्ट रूप से समर्थित

अपना वेरिएंट चुनें

वेरिएंट	कुल पैरामीटर	सक्रिय	कॉन्टेक्स्ट	अनुशंसित क्वांट	अनुशंसित Clore GPU
Gemma 4 26B MoE (gemma-4-26b-it)	26B	~4B प्रति टोकन	128K	FP8 या 4-बिट GPTQ	1× RTX 4090 (24GB, क्वांटाइज़्ड)
Gemma 4 31B Dense (gemma-4-31b-it)	31B	31B (सभी)	128K	FP8 या BF16	1× H100 (80GB, BF16)

व्यावहारिक चयन: 90% सिंगल-GPU डिप्लॉयमेंट्स के लिए Gemma 4 26B MoE on FP8चुनें। आपको 4090 पर ~10–15 tok/s और H100 पर ~40+ tok/s के साथ Arena-स्तरीय गुणवत्ता मिलेगी, बिना डेंस 31B इनफरेंस की लेटेंसी लागत के।

---

सर्वर आवश्यकताएँ

घटक	26B MoE (4-बिट, 4090)	26B MoE (FP8, H100)	31B Dense (BF16, H100)
GPU VRAM	24GB	80GB	80GB
सिस्टम RAM	32GB	64GB	64GB
डिस्क	60GB NVMe	80GB NVMe	90GB NVMe
नेटवर्क	HF pull के लिए 100 Mbps	1 Gbps बेहतर	1 Gbps बेहतर
CUDA	12.1+	12.4+	12.4+
ड्राइवर	550+	555+	555+

लंबे कॉन्टेक्स्ट में KV cache को संभालने के लिए स्थिर वेट फुटप्रिंट के ऊपर लगभग 20% अतिरिक्त VRAM हेडरूम की योजना बनाएँ। --gpu-memory-utilization 0.90 को vLLM में सेट करना एक अच्छा डिफ़ॉल्ट है।

---

CLORE.AI पर त्वरित डिप्लॉय

सबसे तेज़ रास्ता: एक अकेला GPU किराए पर लें, मानक vllm/vllm-openai इमेज खींचें, और मॉडल को OpenAI-संगत API के साथ सर्व करें। नीचे वह docker-compose लेआउट है जिसका उपयोग इन गाइड्स के बाकी हिस्सों में किया गया है — ऊपर चुने गए वेरिएंट के आधार पर मॉडल नाम और tensor-parallel आकार समायोजित करें।

विकल्प A — एक अकेले GPU पर Gemma 4 26B MoE (vLLM, FP8)

version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model google/gemma-4-26b-it
      --quantization fp8
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --served-model-name gemma-4-26b
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    shm_size: "8gb"

volumes:
  hf_cache:

# इसे शुरू करें
HF_TOKEN=hf_xxx docker compose up -d

# वेट्स डाउनलोड होते समय लॉग्स देखें
docker compose logs -f vllm

लाइसेंस गेटिंग: Hugging Face पर Gemma मॉडल के लिए प्रति खाते Google की शर्तों को एक बार स्वीकार करना आवश्यक है। ब्राउज़र में मॉडल पेज पर जाएँ, "Acknowledge license" पर क्लिक करें, फिर HF_TOKEN export करें ताकि कंटेनर वेट्स खींच सके।

विकल्प B — H100 पर Gemma 4 31B Dense (vLLM, BF16)

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model google/gemma-4-31b-it \
  --dtype bfloat16 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90 \
  --served-model-name gemma-4-31b

विकल्प C — 2× RTX 4090 पर Gemma 4 31B Dense (FP8, tensor-parallel)

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model google/gemma-4-31b-it \
  --quantization fp8 \
  --tensor-parallel-size 2 \
  --max-model-len 16384 \
  --gpu-memory-utilization 0.90 \
  --served-model-name gemma-4-31b

विकल्प D — Ollama के साथ त्वरित स्थानीय परीक्षण

लैपटॉप-स्तरीय प्रयोग के लिए, Ollama GGUF समुदाय बिल्ड्स को रैप करता है। अपेक्षा करें कि क्वांट्स आधिकारिक रिलीज़ के कुछ दिनों बाद उपलब्ध होंगे।

# एक बार जब समुदाय GGUF प्रकाशित हो जाए
ollama pull gemma4:26b-moe-q4_k_m
ollama run gemma4:26b-moe-q4_k_m

# :11434 पर OpenAI-संगत API
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:26b-moe-q4_k_m",
    "messages": [{"role":"user","content":"दो वाक्यों में MoE रूटिंग दृष्टिकोण का सार बताइए."}]
  }'

देखें Ollama गाइड सामान्य सेटअप, मॉडल प्रबंधन, और persistence सुझावों के लिए।

---

उपयोग उदाहरण

vLLM कंटेनर एक OpenAI-संगत API को :8000पर एक्सपोज़ करता है। जो कुछ भी OpenAI chat-completions schema बोलता है, वह सीधे काम करता है।

Curl chat completion

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma-4-26b",
    "messages": [
      {"role": "system", "content": "आप एक सावधान तकनीकी लेखक हैं."},
      {"role": "user", "content": "उपमाओं का उपयोग किए बिना MoE रूटिंग को तीन वाक्यों में समझाइए."}
    ],
    "max_tokens": 512,
    "temperature": 0.7
  }'

Python (OpenAI क्लाइंट)

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

resp = client.chat.completions.create(
    model="gemma-4-26b",
    messages=[
        {"role": "system", "content": "आप सादा पाठ में उत्तर देते हैं, कोई markdown नहीं."},
        {"role": "user", "content": "Go HTTP handler के लिए 5-बिंदुओं वाली code review checklist दीजिए."},
    ],
    temperature=0.7,
    max_tokens=1024,
)
print(resp.choices[0].message.content)

Streaming responses

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

stream = client.chat.completions.create(
    model="gemma-4-26b",
    messages=[{"role": "user", "content": "Distributed inference पर एक हाइकु लिखिए."}],
    stream=True,
    max_tokens=128,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
print()

Hugging Face Transformers (ऑफ़लाइन उपयोग)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "google/gemma-4-26b-it"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True,  # MoE एक अकेले 24GB कार्ड में फिट हो जाता है
)

messages = [
    {"role": "user", "content": "पठनीयता के लिए इस Python फ़ंक्शन को refactor करें:\n\ndef f(x): return [i for i in x if i%2==0 and i>10]"},
]
input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=512, do_sample=True, temperature=0.7)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))

---

प्रदर्शन सुझाव

• Hopper पर FP8 का उपयोग करें। H100 पर FP8 चेकपॉइंट BF16 की तुलना में लगभग आधी मेमोरी लेता है, और निर्देश-पालन कार्यों में गुणवत्ता का कोई मापनीय नुकसान नहीं होता। इसे vLLM को पास करें --quantization fp8 ।

• Ada (RTX 4090) पर 4-बिट GPTQ का उपयोग करें। एक अकेले 4090 पर MoE वेरिएंट के लिए, समुदाय द्वारा बना GPTQ 4-बिट बिल्ड व्यावहारिक रूप से सबसे अच्छा विकल्प है — ~10–15 tok/s की अपेक्षा करें। Ollama के Q4_K_M GGUF बिल्ड सरल संचालन के साथ समान गुणवत्ता देते हैं।

• 31B Dense के लिए tensor parallelism। 2× RTX 4090 पर, पास करें --tensor-parallel-size 2। कॉन्टेक्स्ट को उतना ही रखें जितना वास्तव में चाहिए (--max-model-len 16384) — कॉन्टेक्स्ट के हर दोगुने होने पर KV cache फुटप्रिंट लगभग दोगुना हो जाता है।

• MoE के लिए expert parallelism। 26B MoE के लिए multi-GPU सेटअप पर, vLLM का --enable-expert-parallel उच्च batch sizes पर throughput में उल्लेखनीय वृद्धि दे सकता है। सिंगल-GPU के लिए यह ज़रूरत से ज़्यादा है।

• लंबे कॉन्टेक्स्ट के लिए chunked prefill। 32K से आगे बढ़ते समय, vLLM में --enable-chunked-prefill जोड़ें। यह prefill latency को नियंत्रित रखता है और decode path पर stalls को रोकता है।

• वेट्स पहले से खींचें। अस्थायी Clore rentals के लिए, /root/.cache/huggingface पर एक persistent volume माउंट करें ताकि बाद के रन 50–60GB डाउनलोड छोड़ दें।

• सही serving backend चुनें। vLLM सुरक्षित डिफ़ॉल्ट है। SGLang अक्सर Hopper पर उच्च-concurrency workloads में जीतता है; व्यापक तुलना के लिए देखें vLLM गाइड ।

---

बेंचमार्क

विक्रेता द्वारा प्रकाशित संख्याएँ — स्वतंत्र सत्यापन लंबित। नीचे दिए गए आंकड़े Google की 2 अप्रैल, 2026 लॉन्च सामग्री से आए हैं। निजी evals पर स्वतंत्र पुनरुत्पादन अभी भी आ रहे हैं। Arena रैंकिंग और factuality स्कोर को दिशा-सूचक मानें, पूर्ण नहीं।

बेंचमार्क	Gemma 4 26B MoE	Gemma 4 31B Dense	संदर्भ
LMSYS Arena (कुल)	रिलीज़ पर #3	रिलीज़ पर लगभग #5	विक्रेता-रिपोर्टेड
निर्देश-पालन (IFEval)	विक्रेता Gemma 3 पर मजबूत सुधार रिपोर्ट करते हैं	विक्रेता Gemma 3 पर मजबूत सुधार रिपोर्ट करते हैं	विक्रेता-रिपोर्टेड
तथ्यात्मकता (SimpleQA / समान)	Google के अनुसार कई बंद मॉडलों से बेहतर	तुलनीय	विक्रेता-रिपोर्टेड
बहुभाषी (Global-MMLU)	विक्रेता बहुत बड़े मॉडलों के बराबर प्रदर्शन रिपोर्ट करते हैं	अब तक का सर्वश्रेष्ठ Gemma स्कोर	विक्रेता-रिपोर्टेड

Gemma 4 की पोज़िशनिंग दलील है "प्रति सक्रिय पैरामीटर अधिक उपयोगी," न कि "कच्चा HumanEval राजा।" यदि आपको शुद्ध code generation चाहिए, तो इसकी तुलना करें GLM-5.1 (फ्रंटियर कोडिंग) या Qwen3.5 (सर्वश्रेष्ठ 35B-श्रेणी का डेंस)। यदि आपको लंबे-क्षितिज वाले agentic loops चाहिए, तो GLM-5.1 अभी भी अधिक उपयुक्त उपकरण है।

---

समस्या निवारण

समस्या	समाधान
OutOfMemoryError 24GB पर 26B MoE लोड करते समय	FP8 (--quantization fp8) या 4-bit (Transformers में load_in_4bit=True ) पर स्विच करें। KV cache छोटा करने के लिए --max-model-len को 16384 पर घटाएँ।
OutOfMemoryError H100 पर 31B Dense लोड करते समय	32K कॉन्टेक्स्ट पर BF16 80GB पर ठीक सीमा पर है। --max-model-len को 16384 पर घटाएँ या FP8 पर जाएँ।
Hugging Face डाउनलोड 403 के साथ विफल होता है	आपने model page पर Gemma लाइसेंस स्वीकार नहीं किया है। URL को ब्राउज़र में खोलें, शर्तें स्वीकार करें, फिर ऐसे टोकन के साथ पुनः pull करें जिसमें read scope हो।
बहुत धीमा पहला टोकन	ठंडा वेट लोड (~30–60s पहली रिक्वेस्ट पर) और लंबे इनपुट पर prefill। सर्वर शुरू होने के बाद एक dummy warm-up request चलाएँ। लंबे-कॉन्टेक्स्ट workloads के लिए जोड़ें --enable-chunked-prefill ।
विकृत आउटपुट / repetition loops	chat template जाँचें — tokenizer.apply_chat_template आवश्यक है; system+user strings को मैन्युअली concatenate न करें। सेट करें temperature=0.7 और top_p=0.95 सामान्य उपयोग के लिए।
Tool / JSON आउटपुट अविश्वसनीय	vLLM के --guided-decoding-backend का उपयोग करें या JSON schema को response_formatके माध्यम से पास करें। मॉडल constraints को अच्छी तरह मानता है, लेकिन असंरचित prompts फिर भी भटक सकते हैं।
unsupported quantization त्रुटि in vLLM	अप्रैल 2026 के बाद जारी vLLM संस्करण में अपडेट करें (pip install -U vllm --pre)। Gemma 4 आर्किटेक्चर को नवीनतम config parsers चाहिए।

---

FAQ

Gemma 4 बनाम Llama 4? अलग-अलग कामों के लिए अलग आकार। Llama 4 Scout 109B/17B-active है और इसका मुख्य आकर्षण 10M context है — जब आपको मॉडल में बहुत बड़े inputs डालने हों तब यह बेहतरीन है। Gemma 4 26B MoE कुल पैरामीटर में कहीं छोटा है (26B बनाम 109B), प्रति टोकन कम पैरामीटर सक्रिय करता है (4B बनाम 17B), और instruction-following तथा factuality के लिए अधिक सख्ती से ट्यून किया गया है। तंग VRAM बजट और quality-per-parameter के लिए Gemma 4 जीतता है। absurd context length के लिए Llama 4 Scout जीतता है।

Gemma 4 26B MoE के लिए कितनी VRAM चाहिए?

• 4-bit GGUF / GPTQ: फिट होता है 24GB (एकल RTX 4090), ~10–15 tok/s।

• FP8: आराम से चलता है 40GBपर, तेज़ चलता है 80GB (H100) पर ~40+ tok/s के साथ।

• BF16 full: ~55GB वेट्स plus KV cache — योजना बनाएँ 80GB कार्ड के लिए।

क्या मैं Gemma 4 का व्यावसायिक उपयोग कर सकता हूँ? हाँ, मानक Gemma उपयोग शर्तों के अंतर्गत। डिप्लॉय करने से पहले Gemma निषिद्ध उपयोग नीति की समीक्षा करें — कुछ उपयोग मामलों (धोखा, CSAM बनाना, अवैध गतिविधि) पर प्रतिबंध हैं, और आपको downstream license notices अपने उपयोगकर्ताओं तक पहुँचाने होंगे। यह Apache 2.0 / MIT मॉडल नहीं है — यह usage policy के तहत open-weight है। यदि आपको पूरी तरह unrestricted license चाहिए, Qwen3.5 (Apache 2.0) या GLM-5.1 (MIT) विकल्प हैं।

Gemma 4 बनाम DeepSeek-V4? DeepSeek-V4 एक अलग वजन वर्ग है — लगभग 1T params, multimodal, 1M context. जब आपको कच्ची क्षमता चाहिए और आपके पास गंभीर GPU rack हो, तब DeepSeek-V4 का उपयोग करें। जब आप एक एकल GPU पर मजबूत instruction-following चाहते हों और Clore पर लगभग $1–2/दिन किराये की परवाह करते हों, तब Gemma 4 26B MoE का उपयोग करें। Gemma 4 “4090 पर फिट होने वाला सबसे अच्छा मॉडल” उम्मीदवार है; DeepSeek-V4 “मैं 8× H200 के लिए भुगतान करूँगा” उम्मीदवार है।

क्या Gemma 4 vision / multimodal inputs का समर्थन करता है? Gemma 4 की मुख्य रिलीज़ text-only instruction-tuned है (*-it)। Google ने ऐतिहासिक रूप से text releases के बाद PaliGemma vision variants जारी किए हैं — अपडेट के लिए huggingface.co/google पर नज़र रखें। आज के लिए image-capable open model के रूप में देखें Kimi K2.5 या Llama 4 Scout.

---

संबंधित गाइड्स

• vLLM — इस गाइड में उपयोग किया गया production serving backend

• Ollama — GGUF बिल्ड्स के साथ स्थानीय परीक्षण का सबसे तेज़ रास्ता

• Llama 4 — 10M context वाला Meta का MoE विकल्प

• GLM-5.1 — frontier-स्तरीय coding MoE (744B/40B-active), जब Gemma का size class पर्याप्त न हो

• Qwen3.5 — Apache-2.0 35B dense, दूसरा मजबूत single-GPU विकल्प

• Gemma 3 — पूर्ववर्ती पीढ़ी, migration के लिए उपयोगी baseline

लिंक

• Hugging Face पर Gemma 4 26B MoE

• Hugging Face पर Gemma 4 31B Dense

• Gemma उपयोग शर्तों

• Gemma निषिद्ध उपयोग नीति

• vLLM दस्तावेज़

• SGLang repo