Skip to page content
SAVRN
Search Plan a project

Open-weight model · Image and text to text

Gemma4-E2B-it-W4A16

by 88plug 88plug/Gemma4-E2B-it-W4A16

Gemma4-E2B-it-W4A16 is an open-weight model for image and text to text from 88plug, released under Apache License 2.0. It has 5.1B parameters and a 131,072-token context. At 16-bit it needs about 12.3 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index. It draws 154 downloads a month.

These weights are compressed-tensors (pack-quantized / int-quantized). Do not deploy via TGI “text-generation-inference” paths — that backend does not load our CT format and produces opaque worker/load errors.

Parameters5.1B
Context131,072
Weights7.4 GB
Licenseapache-2.0
AccessOpen weights
Monthly Downloads154

Runs On

What it takes to serve Gemma4-E2B-it-W4A16 (5.1B parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 10.2 GB 12.3 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 5.1 GB 6.1 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 2.6 GB 3.1 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 23, 2026.

Gemma4-E2B-it-W4A16 on every accelerator the SAVRN Index prices, at every precision

Model Card

By 88plug, published under apache-2.0, revision 58dd7350f9f1.

These weights are compressed-tensors (pack-quantized / int-quantized). Do not deploy via TGI “text-generation-inference” paths — that backend does not load our CT format and produces opaque worker/load errors. INT4 post-training quantization of google/gemma-4-e2b-it — Google's 2B-active multimodal MoE with 128 experts. The smallest capable multimodal MoE. Runs on any 8 GB GPU. Quantized with datafree RTN (QuantizationModifier) — AutoRound (blocked — see KNOWN-FAILURES) wrapper blocked by Gemma4 qproj.linear children (see KNOWN-FAILURES). Temporary path until upstream fixed. The LLM backbone is W4A16; vision tower, projector, and PLE layers remain BF16. embedtokensperlayer and…

Read 88plug's full model card

Load path (important)

These weights are compressed-tensors (pack-quantized / int-quantized).

Runtime Supported
vLLM ≥ 0.21 Yes — preferred (auto-detect CT; no --quantization flag)
transformers + compressed-tensors Yes for many text models; multimodal may need custom code
Text Generation Inference (TGI) Not supported for these CT packs
Hugging Face Inference Widget Often fails — use vLLM locally instead
# Preferred
vllm serve 88plug/<ModelName> --trust-remote-code

Do not deploy via TGI “text-generation-inference” paths — that backend does not load our CT format and produces opaque worker/load errors.

Gemma4-E2B-W4A16

INT4 post-training quantization of google/gemma-4-e2b-it — Google's 2B-active multimodal MoE with 128 experts. The smallest capable multimodal MoE. Runs on any 8 GB GPU.

Quantized with datafree RTN (QuantizationModifier) — AutoRound (blocked — see KNOWN-FAILURES) wrapper blocked by Gemma4 q_proj.linear children (see KNOWN-FAILURES). Temporary path until upstream fixed. The LLM backbone is W4A16; vision tower, projector, and PLE layers remain BF16.


At a Glance

Property Value
Base model google/gemma-4-e2b-it
Release tier Provisional (datafree RTN — re-quant scheduled)
Quant method datafree RTN W4A16 (AutoRound blocked — KNOWN-FAILURES)
FLAC status Not measured (T+7d milestone)
Architecture Sparse MoE, 128 experts, hybrid sliding+global attention + SigLIP vision
Quant scheme W4A16 (4-bit weights, 16-bit activations)
Quant format compressed-tensors (native vLLM)
Quantized language_model.* — all Linear layers (attn + MLP)
Kept BF16 vision_tower, audio_tower, multi_modal_projector, embed_tokens_per_layer (PLE), per_layer_model_projection (PLE), lm_head, norms, embeddings
Disk size ~7.0 GiB
Min GPU 1× RTX 3080 10GB / RTX 4070

PLE layers kept at BF16

embed_tokens_per_layer and per_layer_model_projection implement Per-Layer Embeddings — ablations show catastrophic output degradation if quantized. Always excluded.


Memory Requirements

Configuration BF16 This Quant (W4A16)
Weights (disk/VRAM) ~14 GB ~7.0 GiB
KV cache @ 32k ctx (fp8) ~1.0 GB ~1.0 GB
Total @ 32k ctx ~15 GB ~7 GB
Minimum GPU RTX 3090 24GB 1× 8GB GPU (RTX 3080 10GB / RTX 4070)

The smallest capable multimodal MoE: W4A16 fits the model on any modern 8 GB GPU with room for KV cache.


Quick Start

Tested with vLLM v0.21.0 (vllm/vllm-openai:v0.21.0-cu129-ubuntu2404). Weights are in compressed-tensors format — vLLM detects and loads quantization automatically. No --quantization flag needed.

vLLM

docker run --gpus device=0 -p 8080:8080 \
  vllm/vllm-openai:v0.21.0-cu129-ubuntu2404 vllm serve \
  88plug/Gemma4-E2B-it-W4A16 \
  --kv-cache-dtype fp8 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

Weights are in compressed-tensors format — no --quantization flag needed.

Python client

from openai import OpenAI

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

response = client.chat.completions.create(
    model="88plug/Gemma4-E2B-it-W4A16",
    messages=[{"role": "user", "content": "Explain sparse mixture-of-experts in two sentences."}],
    max_tokens=256,
)
print(response.choices[0].message.content)

Quantization Design

The recipe targets all Linear modules in the LLM backbone with W4A16 (4-bit symmetric weight quantization, activations remain BF16). The following are excluded and kept at BF16:

Excluded pattern Reason
lm_head Output projection — quality-sensitive
.*embed_tokens$ Token embeddings
.*norm$ Layer norms
.*embed_tokens_per_layer.* PLE: per-layer token embeddings — catastrophic if quantized
.*per_layer_model_projection.* PLE: projection into hidden dim — catastrophic if quantized
.*vision_tower.* SigLIP vision encoder — multimodal quality
.*audio_tower.* Audio encoder — multimodal quality
.*multi_modal_projector.* Cross-modal projector

All self_attn.{q,k,v,o}_proj and mlp.{gate,up,down}_proj layers across all transformer blocks are quantized to W4A16.


Competitor Comparables

Model Source Format Compare angle
google/gemma-4-e2b-it official BF16 quality ceiling
RedHatAI/gemma-3n-E4B-it-quantized.w4a16 RedHatAI compressed-tensors W4A16 same format, prior generation, larger model
88plug/Gemma4-E2B-it-W8A16 88plug compressed-tensors W8A16 higher precision variant

First-to-market note: No compressed-tensors or vLLM-native quant found for gemma-4-e2b-it at release time. This is the first W4A16 for Gemma4 E2B.


Benchmarks

Metric Score
Throughput total (in2048_out512) 7507 tok/s (prompt+output)
Throughput total (in512_out256) 7263 tok/s (prompt+output)
Throughput total (in8192_out512) 6926 tok/s (prompt+output)

Results from 88plug benchmark ladder — vLLM v0.21.0, lm-evaluation-harness. No fabricated numbers.

Quality Targets

Metric Target
KL divergence vs BF16 < 0.014
MMLU recovery ≥ 99%

SGLang Note

SGLang does not natively support compressed-tensors weights. To use SGLang, run the BF16 base model (google/gemma-4-e2b-it) directly:

docker run --gpus device=0 -p 30000:30000 \
  lmsysorg/sglang:v0.5.8-cu129 python -m sglang.launch_server \
  --model-path google/gemma-4-e2b-it \
  --tp 1 \
  --mem-fraction-static 0.85 \
  --port 30000

SGLang benchmark results above reflect BF16 baseline throughput, not this quant.


llama.cpp / GGUF

Fits entirely on an 8 GB GPU with Q4 quantization. Convert from the BF16 base checkpoint — not from compressed-tensors weights. VLM requires a separate mmproj GGUF for image input.

python convert_hf_to_gguf.py google/gemma-4-e2b-it \
  --outfile Gemma4-E2B-BF16.gguf
python convert_hf_to_gguf.py google/gemma-4-e2b-it \
  --mmproj --outfile Gemma4-E2B-mmproj.gguf

llama-quantize Gemma4-E2B-BF16.gguf Gemma4-E2B-Q8_0.gguf Q8_0
llama-quantize --imatrix calibration_datav3.txt \
  Gemma4-E2B-BF16.gguf Gemma4-E2B-IQ4_XS.gguf IQ4_XS

llama-server \
  --model Gemma4-E2B-Q8_0.gguf \
  --mmproj Gemma4-E2B-mmproj.gguf \
  --n-gpu-layers 999 \
  --ctx-size 32768 \
  --port 8081

Citation

@misc{gemma4report,
  title  = {Gemma 4 Technical Report},
  author = {Google DeepMind},
  year   = {2025},
  url    = {https://huggingface.co/google/gemma-4-e2b-it}
}

About

88plug AI Lab ships compressed-tensors quantizations for native vLLM v0.21.0+ deployment.

This release: Provisional tier — datafree RTN (weight-only rounding, no calibration corpus). A gold AutoRound re-quant is scheduled; 88plug architecture forbids new provisional W4A16 uploads.

Browse all releases → huggingface.co/88plug

Configuration

Architecture
Gemma4ForConditionalGeneration
Context length (tokens)
131,072
Layers
35
Hidden size
1,536
Feed-forward size
6,144
Attention heads
8
Key/value heads
1
Head dimension
256
Vocabulary size
262,144
Sliding window (tokens)
512
Model type
gemma4
Quantization
compressed-tensors

Identity and Version

Repository
88plug/Gemma4-E2B-it-W4A16
Publisher
88plug
Task
Image and text to text
Modality
Image and text
Library
transformers
Parameters
5.1B parameters
Languages
en
Revision
58dd7350f9f14feec551e24a15cb1e1a5ceb8fe6
First published
2026-05-24
Last updated
2026-10-23

Files and Weights

12 files, 7.5 GB in total. The weights are 1 file totalling 7.4 GB in safetensors.

Weights1 file · 7.4 GB
Configuration5 files · 25.4 KB
Tokenizer2 files · 32.2 MB
Documentation1 file · 7.8 KB
Other2 files · 17.5 KB
Repository1 file · 1.6 KB
Every file
FileTypeSizeSHA-256
model.safetensorsWeights7.4 GB 3889eaefb394
config.jsonConfiguration22.3 KB —
generation_config.jsonConfiguration204 B —
processor_config.jsonConfiguration1.7 KB —
quality_stamp.jsonConfiguration810 B —
recipe.yamlConfiguration432 B —
README.mdDocumentation7.8 KB —
chat_template.jinjaOther17.3 KB —
datafree-rtn-2026-06-22.txtOther164 B —
.gitattributesRepository1.6 KB —
tokenizer.jsonTokenizer32.2 MB cc8d3a0ce364
tokenizer_config.jsonTokenizer2.7 KB —

License and Download

License
apache-2.0
Access
Open weights, no gate
Download size
7.4 GB
Download from 88plug

Released by 88plug through its official repository on Hugging Face. Read the license.

Memory Requirements

PrecisionWeights in memory
As published7.4 GB
16-bit10.2 GB
8-bit5.1 GB
4-bit2.6 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About Gemma4-E2B-it-W4A16

How much GPU memory does Gemma4-E2B-it-W4A16 need?

About 12.3 GB at 16-bit and 3.1 GB at 4-bit: the weights (5.1B parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run Gemma4-E2B-it-W4A16 on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use Gemma4-E2B-it-W4A16 commercially?

Yes. Gemma4-E2B-it-W4A16 is released under Apache License 2.0. The Apache License 2.0 is a permissive open-source license. It permits commercial use, modification and redistribution. It requires keeping the license and copyright notices and any NOTICE file, stating significant changes, and it includes an express patent grant from contributors.

What is Gemma4-E2B-it-W4A16's context length?

131,072 tokens, from the maximum position embeddings in its published configuration.

Similar Models

Model · Image and text to text

dama-aibrain

Parkseonghun

This gemma4 model was trained 2x faster with Unsloth and Huggingface's TRL library.

Open weights apache-2.0 5.1B parameters 131,072 tokens transformers

Model · Image and text to text

cpt8

Xabxa

This model is a fine-tuned version of Agtian/cpt8. It has been trained using TRL. This model was trained with SFT.

Open weights 5.1B parameters 131,072 tokens transformers

Model · Image and text to text

vllm-translategemma-4b-it

Infomaniak Network SA

This is a modified version of google/translategemma-4b-it optimized for deployment with vLLM. The original TranslateGemma model requires a structured payload with dedicated sourcelangcode and targetlangcode fields: However, vLLM does not support these custom content parameters. To maintain compatibility, the chat template has been modified to encode language codes directly in the message content using a delimiter-based format: Format: >>{sourcelang} >>{targetlang} >>{texttotranslate} If you need to provide a custom prompt input The original model uses the new Transformers RoPE configuration format with separate attention type settings: This has been simplified for vLLM compatibility: The…

Open weights gemma 5B parameters 131,072 tokens transformers

Model · Image and text to text

chandra-ocr-2

Datalab

Chandra 2 is a state of the art OCR model from Datalab that outputs markdown, HTML, and JSON. It is highly accurate at extracting text from images and PDFs, while preserving layout information. Try Chandra in the free playground, or use the hosted API for higher accuracy and speed. - 85.8% olmocr bench score (sota), 77.8% multilingual bench score (12% improvement over Chandra 1) - Significant improvements to math, tables, complex layouts - 90+ language support with major accuracy gains - Convert documents to markdown, HTML, or JSON with detailed layout information - Reconstructs forms accurately, including checkboxes - Strong performance with tables, math, and complex layouts - Extracts…

Open weights openrail 5.3B parameters 262,144 tokens transformers

Model · Image and text to text

Qwen3.8-Flash-Next-4bit-paged

GREENBITAI

Expert-paged build of Vontra/Qwen3.8-Flash-Next-MLX-4bit. The weights that are read a fraction at a time live in their own containers, so a machine loads what it needs rather than all Total 105.46 GiB. Of that, 103.94 GiB is the source build, whose bytes moved into containers rather than being copied, and 1.52 GiB is the draft head, which no published build of this model carries. Where the weights fit they are filled from experts.bin and the model runs the stock path at stock speed; where they do not, they stream from disk. Reading the machine decides that, not a flag. To override that: GBXPAGING=off holds the experts resident, GBXPLE=off holds the n-gram table resident. Checked at build…

Open weights other 5.4B parameters 262,144 tokens mlx

Model · Image and text to text

SDRPN-Qwen3.5-4B

Yuheng Shi

Papers: https://arxiv.org/abs/2609.19745 (Vision-RL²) · https://arxiv.org/abs/2509.16944 (SD-RPN) SD-RPN stage-1 checkpoint: a self-distilled RoI predictor twig (K = 21, T = 3) trained on a frozen Qwen/Qwen3.5-4B. This is the initialisation of the Vision-RL² RL run YuhengSSS/VisionRL2-Qwen3.5-4B. The backbone weights are unchanged from the base model; only the three attached twig blocks are trained, from self-distilled attention pseudo-labels (no human RoI annotation). These weights need the modeling code in YuHengsss/VisionRL2. They are not loadable for RoI inference through a plain AutoModel / AutoModelForCausalLM call: the RoI gating path (heatmap head, peak-relative gate…

Open weights apache-2.0 5.5B parameters 262,144 tokens