This gemma4 model was trained 2x faster with Unsloth and Huggingface's TRL library.
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.
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.
| Precision | Weights | Memory needed | Cheapest setup | Per hour | Also 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.
Every file
| File | Type | Size | SHA-256 |
|---|---|---|---|
| model.safetensors | Weights | 7.4 GB | 3889eaefb394 |
| config.json | Configuration | 22.3 KB | — |
| generation_config.json | Configuration | 204 B | — |
| processor_config.json | Configuration | 1.7 KB | — |
| quality_stamp.json | Configuration | 810 B | — |
| recipe.yaml | Configuration | 432 B | — |
| README.md | Documentation | 7.8 KB | — |
| chat_template.jinja | Other | 17.3 KB | — |
| datafree-rtn-2026-06-22.txt | Other | 164 B | — |
| .gitattributes | Repository | 1.6 KB | — |
| tokenizer.json | Tokenizer | 32.2 MB | cc8d3a0ce364 |
| tokenizer_config.json | Tokenizer | 2.7 KB | — |
License and Download
- License
- apache-2.0
- Access
- Open weights, no gate
- Download size
- 7.4 GB
Released by 88plug through its official repository on Hugging Face. Read the license.
Memory Requirements
| Precision | Weights in memory |
|---|---|
| As published | 7.4 GB |
| 16-bit | 10.2 GB |
| 8-bit | 5.1 GB |
| 4-bit | 2.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
This model is a fine-tuned version of Agtian/cpt8. It has been trained using TRL. This model was trained with SFT.
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…
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…
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…
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…