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

Qwen-Image-NVFP4 4-Bit Quantized Image Generation Model: 48GB+ VRAM
Sample output from nvidia/Qwen-Image-NVFP4
Sample output from the nvidia/Qwen-Image-NVFP4 model card.

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

What to Read Next

Sources