ERNIE-Image NVFP4 vs INT8: Artifacts, Loaders, and GPU Checks

May 17, 2026

Abstract: Before comparing NVFP4 vs INT8 for ERNIE-Image, match the base model, artifact revision, loader, and GPU compute path. This guide checks two named community artifacts, shows what their metadata establishes, and separates native low-precision execution from unverified compatibility or fallback.

Published: 2026-05-17
Reading time: about 12 minutes
Difficulty: Intermediate to advanced

NVFP4 vs INT8: what should you check first?

Check that you are comparing the same ERNIE-Image model before choosing a bit width. The NVFP4 community example below declares ERNIE-Image-Turbo as its base; the SDNQ INT8 example declares ERNIE-Image, the standard model. Comparing their outputs or timings would mix a model-version change with a quantization change. Neither artifact has been benchmarked for this article.

Decision What to establish If the evidence is missing
Base model Standard or Turbo, plus the original checkpoint revision Do not attribute an output or speed difference to NVFP4 versus INT8.
Weight artifact Publisher, fixed revision, file names, and which modules are quantized Treat the name as a lead to investigate, not a complete format specification.
Runtime and loader Loader/custom-node revision, dependencies, and companion components A downloadable checkpoint is not yet a reproducible loading recipe.
Native compute or fallback The GPU architecture and the actual kernel path selected by the loader Loading or dequantizing weights does not demonstrate native NVFP4/INT8 execution or a speedup.
Measured result Same workload, resolution, steps, batch, offload, and text checks Keep memory, speed, and output-quality results marked unmeasured.

If your goal is to try the hosted service rather than deploy weights locally, open the ERNIE-Image image generator. It is a separate workflow: the site does not offer an NVFP4/INT8 checkpoint selector. Check the model options currently shown in the generator.

Two community artifacts checked at fixed revisions

The following is a source and configuration check on 2026-11-13, not a download of model weights or a GPU test. Community repositories are maintained by their named publishers; they are separate from Baidu's official model release.

Artifact Verified source information What remains unknown here
ApacheOne/ERNIE-Image-nvfp4_mixed Revision 1ba22458a9dc05b1e3f5ed536a9f854d9c2fdb72; the publisher's card declares a Turbo base and names ERNIE-Turbo-nvfp4.safetensors, which is present in that revision. The card does not pin a loader/custom-node version or provide a hardware test matrix. The exact quantized-module coverage, dependency lock, native/fallback kernel path, and results on your GPU are unverified.
OzzyGT/ERNIE_Image_sdnq_dynamic_int8 Revision 7cea07b563fa6271fba51d34e58a51ef7d69e9d0; the card identifies standard ERNIE-Image with SDNQ dynamic quantization. Files include transformer, text-encoder, VAE, and prompt-enhancer components. The presence of these files does not establish a tested install, total VRAM use, end-to-end speed, LoRA compatibility, or output fidelity.

The INT8 example's pinned transformer configuration records sdnq_version: 0.1.6, weights_dtype: int8, and use_dynamic_quantization: true. Its per-module list also contains unsigned-integer and floating-point formats: the entire pipeline should not be described as uniformly INT8. Importantly, the saved setting is use_quantized_matmul: false; it is not evidence that an INT8 matrix-multiplication kernel was used. These are export settings, not a tested dependency lock.

The card links to the publisher's Diffusers recipe, frozen here at repository commit 3b3c8af5cfd4f50191c708d162e2e0e64fe59576. It defaults to SDNQ_BITS = 4; select 8 for the INT8 artifact discussed here. It loads quantized transformer/text-encoder components, optionally the prompt enhancer, then enables quantized matrix multiplication only under its runtime condition. It does not pin model revisions in its loading calls. Record and pin those separately before treating it as a reproducible environment; this article has not executed the script. The SDNQ maintainer documentation, checked at commit 206162e105d9bef4147c226e217662117a6df9ca, treats quantized matrix multiplication as an explicit runtime option, distinct from the stored weight type.

Native NVFP4 is a hardware-and-runtime question

NVIDIA's Transformer Engine support matrix, checked on 2026-11-13, lists no NVFP4 support for Ampere or Ada in that library, full support for Blackwell data-center compute capability 10.x, and partial support for Blackwell 12.x. Those are Transformer Engine recipe limits, not a support matrix for the ApacheOne checkpoint or every image loader.

On an RTX 30- or 40-series device, do not infer native NVFP4 acceleration from a file name. A loader may reject the artifact or use a different compute path; that path and its memory/performance must be verified in the specific loader. Conversely, a Blackwell GPU alone does not prove that an ERNIE-Image loader implements the required kernel. No load or fallback result for either community artifact is claimed here.

A reproducible next step

Choose one base model and retain its BF16 reference. Record the full community revision above, selected component files and downloaded-file checksums, then pin the loader, framework, driver, and quantization backend. Capture the kernel configuration or logs before calling the run native low-precision inference. Run a small fixed prompt set that includes the text or details you care about, and report failed loads as well as completed outputs. Artifact-file checksums and target-device results remain unmeasured in this source-only check.

The sections below retain the precision concepts and measurement checklist for that comparison.

Quantization Strategy Overview

Quantization changes how model values are represented at runtime. The name of a format alone does not establish that an ERNIE-Image checkpoint, loader, or hardware backend supports it.

  • BF16 is the precision used by the documented ERNIE-Image model workflow and is the safest reference when comparing another runtime.
  • FP8 represents values with an 8-bit floating-point format. Its range and scaling behavior depend on the format and implementation.
  • INT8 represents values with 8-bit integers. The calibration, scales, and kernels used by a particular runtime determine the result.
  • NVFP4 refers to a 4-bit floating-point quantization approach used in some NVIDIA tooling and community workflows. The exact implementation and loader must be identified before treating it as an ERNIE-Image option.

The official ERNIE-Image model card documents the model and its available files, but it does not publish an official FP8/INT8/NVFP4 artifact comparison. Do not infer model size, VRAM use, quality loss, or speed from the bit width alone.

FP8 vs INT8 vs NVFP4 Deep Comparison

1. Precision concepts

FP8 keeps a floating-point representation and therefore has different range and scaling behavior from INT8. NVIDIA's FP8 primer describes the format and the need to match the implementation to the compute path.

INT8 uses integer values with scale information. A runtime may quantize weights, activations, or both, and the quality and memory behavior can differ between those choices.

NVFP4 uses fewer bits than FP8 or INT8, but the practical result depends on the scaling scheme, kernels, and model components that are quantized. A label such as NVFP4 is not enough to establish compatibility with an ERNIE-Image pipeline.

2. What can be compared safely

The following comparisons are useful only after the exact artifact and runtime are identified:

Question What must be checked
Does it load? The checkpoint format, loader, framework version, and required model components
Does it fit? Peak memory measured on the target device with the same resolution, steps, and batch settings
Does quality hold? The same prompts, seeds, scheduler, model revision, and a review set that includes text-rich images
Is it faster? End-to-end timing after warm-up, including model loading and any CPU offload
Does an adapter work? The exact quantized modules, LoRA loader, and a side-by-side output check

There is no source-backed ERNIE-Image table that assigns a universal quality loss, speed gain, or VRAM requirement to FP8, INT8, and NVFP4. Those figures should be reported only with the artifact, software versions, hardware, method, and measurement procedure.

3. Model-specific limits

Quantization can change more than memory use. It can affect text rendering, fine details, conditioning, and adapter behavior. In a related official DiffSynth-Studio Z-Image note, the maintainers warn that FP8 quantization can visibly degrade Z-Image Turbo output. That is a model-specific warning, not an ERNIE-Image benchmark, and it is a reason to validate each model and runtime separately.

Quantization Level Decision Tree

Use this sequence instead of a fixed VRAM or quality table:

  1. Start with the official ERNIE-Image checkpoint and workflow.
  2. If a quantized artifact is proposed, verify its publisher, revision, checksum, model components, and loader instructions.
  3. Run a small, repeatable comparison on the target device. Keep the prompt set focused on the intended task, including in-image text when that matters.
  4. Record peak memory, completion time, failed loads, and visible quality changes together.
  5. Keep the reference BF16 path available until the quantized path has passed the target workload.

If any of those checks is missing, describe the format as an experiment rather than a supported deployment recommendation. Do not treat a lower bit count as a guarantee of lower memory use or higher throughput.

ComfyUI Quantization Switching Workflow

The official ERNIE-Image repository links to a ComfyUI workflow for the documented model path. Use that workflow as the reference, then confirm that any quantized checkpoint has matching loader instructions. The model card remains the source for the files that Baidu publishes.

Before switching a checkpoint, record:

  • the model and quantization artifact URL and revision;
  • the loader or custom node and its version;
  • the VAE, text encoder, and other companion components;
  • the device, driver, framework, and ComfyUI versions;
  • the prompt, seed, resolution, and inference settings used for comparison.

The UI label or a filename is not proof that the artifact is official. Avoid hard-coding a guessed .safetensors name into a workflow until the publisher documents it.

Quantization and LoRA compatibility

The official ERNIE-Image sources reviewed here do not define a general FP8/INT8/NVFP4 plus LoRA compatibility matrix. Test the adapter with the exact loader and quantized modules, and keep the unquantized reference output for comparison. A result that loads is not automatically a result that preserves the adapter's effect.

Batch Inference Measurements

For a useful benchmark, use a fixed model revision and prompt set, warm up the runtime, measure multiple complete requests, and report the hardware, software, steps, resolution, batch setting, and failure cases.

Batch size can change peak memory and scheduler behavior. A single-device result must not be generalized to a different GPU, backend, or offload setting.

GPU Platform Compatibility

There is no official ERNIE-Image compatibility matrix covering every NVIDIA, AMD, Apple, and edge device for every quantization format. Support depends on the backend's kernels and the loader used for the specific artifact. Check the model and runtime documentation for the target platform, then verify it with a real load and a representative output.

Practical Deployment Recommendations

For a quality reference

Keep the documented BF16 workflow as the comparison path. Compare prompt adherence, text rendering, and image details before deciding that a smaller representation is acceptable.

For a constrained device

Choose an artifact only after verifying that its loader and kernels support the target device. Measure peak memory and completion time in the actual workflow; do not use a generic device table as a substitute.

For a production or batch workflow

Pin the artifact and runtime revisions, record the measurement method, and keep a rollback path to the reference checkpoint. Re-run the comparison after changing the loader, quantization method, model revision, or scheduler.

Summary

  • FP8, INT8, and NVFP4 describe different representation and quantization approaches; the labels do not establish an ERNIE-Image artifact or compatibility.
  • The official ERNIE-Image model card and repository do not provide a general comparison of size, quality loss, throughput, and GPU compatibility across these formats.
  • Quantized deployment needs an identified artifact, loader, model components, and repeatable target-hardware measurements.
  • Treat LoRA compatibility and text-rendering quality as test results for a specific runtime, not universal properties of a bit width.

References

ERNIE-Image Team