Qwen-Image-NVFP4 4-Bit Quantized Image Generation Model: 48GB+ VRAM


At a Glance
| Item | Value |
|---|---|
| Repository | nvidia/Qwen-Image-NVFP4 |
| Publisher guide | NVIDIA: models and licenses |
| Published | 2026-10-10 |
| License | apache-2.0 |
| Formats | safetensors |
| Paper | arXiv:2508.02324 |
| Source type | Primary source (the publisher itself) |
Values determined by this site’s code when the information was collected. Dates are JST.
Overview
NVIDIA has released “nvidia/Qwen-Image-NVFP4", an open-weight text-to-image generation model. This model is based on “Qwen/Qwen-Image", a base model developed by Alibaba’s Qwen team in China, and has been quantized into the 4-bit floating-point format (NVFP4) using NVIDIA’s optimization tool, Model Optimizer. It allows users to generate high-quality RGB images by inputting text prompts.
The model is optimized for the NVIDIA Blackwell architecture (GB300) and the inference engine “TensorRT-LLM VisualGen". It aims to achieve fast inference using NVFP4 precision weights and activations in supported linear operations while maintaining the advanced text rendering capabilities and instruction-following performance of the base model.
Specifications
Based on the published model card, the known specifications and details are as follows:
- Model Type: Text-to-Image Diffusion Transformer (MMDiT)
- Parameter Count: 20.43B for the denoising transformer alone, and 28.85B for the full pipeline including the text encoder and VAE.
- Pipeline Architecture: Consists of the Qwen2.5-VL text encoder, Qwen tokenizer, a 60-layer Qwen-Image transformer, Qwen-Image VAE, and FlowMatch Euler scheduler.
- Quantization Details: Uses NVIDIA Model Optimizer v0.47.0. A total of 784 linear weight matrices across transformer blocks 2 through 57 (14 matrices per block) are quantized to NVFP4 format. Other transformer parameters, the text encoder, and the VAE retain higher precision.
- Input Specifications: Accepts one-dimensional text strings. Prompts are allowed up to 1,024 tokens, with 500 tokens as the default. Supports English and Chinese prompt workflows.
- Output Specifications: Outputs two-dimensional RGB images (PIL image format). It is recommended to specify width and height values that are multiples of 16 to avoid unintended automatic resizing.
- Recommended Inference Settings: Model card evaluations and sample generations use 50 steps, a guidance scale (CFG) of 4.0, and a single blank space (" “) as the negative prompt.
- Calibration Data: Only text prompts from the “Gustavosta/Stable-Diffusion-Prompts" dataset were used for calibration during quantization.
- License Terms: The model card explicitly states that it is ready for commercial or non-commercial use.
Performance
NVIDIA has published comparative benchmark results between the BF16 precision base model (Qwen/Qwen-Image revision 75e0b4be) and the NVFP4 quantized version. Evaluations were conducted under identical conditions: 1024×1024 resolution, 50 steps, CFG 4.0, and a single blank space negative prompt.
| Model | Qwen-Image-Bench | OneIG-EN |
|---|---|---|
| Baseline (BF16) | 48.986 | 51.337 |
| NVFP4 | 49.754 | 51.563 |
According to the published figures, on “Qwen-Image-Bench"—which evaluates image quality, aesthetics, text-image alignment, and real-world fidelity—the NVFP4 version scored 49.754, outperforming the BF16 baseline’s 48.986. Furthermore, on “OneIG-EN", which comprehensively evaluates alignment, text rendering, reasoning, style, and diversity, the NVFP4 version scored 51.563, slightly exceeding the BF16 baseline’s 51.337. The evaluation results presented by NVIDIA indicate that benchmark accuracy equal to or greater than the original BF16 model is maintained even after applying 4-bit quantization.
Strengths and Use Cases
“nvidia/Qwen-Image-NVFP4" is provided for creative content prototyping, visual production workflows, and integration into various AI image generation applications. Because it is provided as a pre-quantized model in NVFP4 format, users can deploy it into inference systems without requiring additional quantization processing.
Its expressive power and generation characteristics inherit the capabilities of the base model, “Qwen/Qwen-Image". A major strength of the original model is its complex text rendering within images. It can seamlessly blend typographical details and layout consistency into images not only for alphabetic languages like English, but also for Chinese characters such as kanji. Samples shown in the model card demonstrate accurate rendering of Chinese characters like “春日茶馆" on a teahouse signboard.
Additionally, it supports photorealistic photographic expressions capturing depth of field, wood grain, ceramic textures, and soft natural light; close-up portraits depicting skin texture and pupil highlights with precision; and diverse artistic styles such as anime-inspired or impressionist looks. Supporting both English and Chinese prompts with inputs up to 1,024 tokens, it is well-suited for image generation instructed by detailed and complex scenarios.
Hardware Requirements
Estimated requirements (calculated by Local Model Watch) — 20.4B parameters (taken from the base model Qwen/Qwen-Image)
| Your VRAM | Quantization | File size | Est. memory needed |
|---|---|---|---|
| 48GB (RTX 6000 Ada / A6000, etc.) | NVFP4 | 28.3GB | 33.9GB |
Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.
Can You Run It Locally?
The publisher distributes this model as safetensors.
License — apache-2.0 (Commercial use allowed): Permits commercial use, modification and redistribution. Redistribution requires including the license and stating changes; includes a patent grant.
Compiled by this site’s code from the published formats and the license field. License summaries are not legal advice — check the publisher’s original terms before relying on them.
Distributed Files
Weight files published in nvidia/Qwen-Image-NVFP4, listed by this site from the Hugging Face API. Sizes are the actual file sizes.
| File | Size |
|---|---|
text_encoder/model.safetensors |
16.58GB |
transformer/diffusion_pytorch_model.safetensors |
13.51GB |
vae/diffusion_pytorch_model.safetensors |
254MB |
How to Get It
The model weights are distributed in safetensors format and can be obtained from the Hugging Face repository “nvidia/Qwen-Image-NVFP4". Use huggingface_hub to download the model.
python3 -m pip install --upgrade huggingface_hub
hf download nvidia/Qwen-Image-NVFP4 \
--local-dir./Qwen-Image-NVFP4
export MODEL_DIR="$(realpath./Qwen-Image-NVFP4)"
This checkpoint has been verified for operation in a Linux environment with NVIDIA Blackwell architecture (GB300) using “TensorRT-LLM VisualGen 1.3.0rc28". Because VisualGen directly reads the stored ModelOpt NVFP4 format weights and quantization settings, no prior weight conversion or runtime source code patches are required.
To use it, create a configuration file for serving and then launch the inference server using a Docker container.
cat > visualgen-eager.yaml <<'YAML'
attention_config:
backend: VANILLA
parallel_config:
cfg_size: 1
ulysses_size: 1
torch_compile_config:
enable: false
cuda_graph_config:
enable: false
compilation_config:
skip_warmup: true
YAML
export VISUALGEN_CONFIG="$(realpath visualgen-eager.yaml)"
After creating the configuration file, start the container and service with the following command:
docker run --rm \
--gpus '"device=0"' \
--ipc=host \
-p 127.0.0.1:8000:8000 \
-v "$MODEL_DIR:/model:ro" \
-v "$VISUALGEN_CONFIG:/visualgen-eager.yaml:ro" \
nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc28 \
trtllm-serve /model \
--host 0.0.0.0 \
--port 8000 \
--visual_gen_args /visualgen-eager.yaml
Once the server starts up, you can check its operational status using the health check endpoint (http://127.0.0.1:8000/health). Image generation can be executed by sending a JSON request to the OpenAI-compatible image generation endpoint (/v1/images/generations). Below is an implementation example for image generation using Python:
import base64
import json
import urllib.request
from pathlib import Path
payload = {
"model": "/model",
"prompt": (
"A realistic photograph of a red ceramic teapot on a wooden "
"table beside a window, soft morning light, detailed wood grain."
),
"negative_prompt": " ",
"size": "512x512",
"num_inference_steps": 50,
"guidance_scale": 4.0,
"seed": 42,
"response_format": "b64_json",
"format": "png",
}
request = urllib.request.Request(
"http://127.0.0.1:8000/v1/images/generations",
data=json.dumps(payload).encode("utf-8"),
headers={"Content-Type": "application/json"},
method="POST",
)
with urllib.request.urlopen(request, timeout=600) as response:
result = json.load(response)
output = Path("qwen-image-nvfp4.png")
output.write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(f"Saved {output.resolve()}")
Note that to prevent unintended automatic resizing, it is recommended that the width and height specified for the generation size are multiples of 16.
Related Articles
- Cosmos3-H-Dreams Video Generation Model: 48GB+ VRAM, File List
- NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4: ~84GB Memory
- DeepSeek-V4-Pro-0813-nvfp4-DSpark: ~1005GB Memory
- MetricTrail: File List
What to Read Next
- Find models by VRAM (This model needs at least 48GB) → VRAM quick reference
- What NVFP4 mean and where to get this model → NVFP4 / MXFP4 format guide and models / Quantization and model-format glossary
- Learn about the publisher → NVIDIA: models, licenses and articles
- Other models for the same task → Other image generation models

