{"slug": "quark-support-for-huggingface-diffusers-and-svdquant", "title": "Quark Support for HuggingFace Diffusers and SVDQuant", "summary": "AMD Quark now supports SVDQuant and native Hugging Face Diffusers integration for diffusion models, enabling 4-bit quantization of both weights and activations. On an AMD Instinct MI350 GPU, plain native FP4 quantization of FLUX.1-dev achieves a 1.12× speedup over BF16 with a 33% reduction in model memory, while native SVDQuant trades speed (0.92×) for accuracy and a 27% memory reduction.", "body_md": "# Quark Support for HuggingFace Diffusers and SVDQuant[#](#quark-support-for-huggingface-diffusers-and-svdquant)\n\nDiffusion models are heavy on memory and compute: a single text-to-image call runs a large transformer or UNet dozens of times. Quantization — storing weights (and sometimes activations) in low precision — is one of the most effective ways to cut both the memory footprint and the latency of these models.\n\nIn a previous post [[1]](#references) we showed how **AMD Quark** [[2]](#references) brings **MXFP4** quantization to Diffusers [[3]](#references) and xDiT FLUX.1-dev [[4]](#references) image generation, reaching up to **1.92× speedup** over the BF16 eager baseline on a single AMD Instinct™ MI350 GPU while preserving quality. This post covers two new capabilities for diffusion models: **SVDQuant** [[5]](#references), for accurate low-bit (4-bit) quantization, and Quark’s **native Hugging Face Diffusers support**. Quark now allows quantized diffusion models to be saved and reloaded through the standard Diffusers `save_pretrained`\n\n/ `from_pretrained`\n\nAPIs.\n\n## SVDQuant Support in Quark[#](#svdquant-support-in-quark)\n\nPushing diffusion models to 4-bit — quantizing not just weights but **activations** too — is much harder than the FP8 or INT8 case. Both the weights and the activations in diffusion transformers contain **outlier channels** whose magnitudes dwarf the rest of the tensor. A naive 4-bit grid has to stretch to cover those outliers, which crushes the resolution available for the bulk of the values and shows up as visible artifacts in generated images.\n\nSVDQuant addresses this with two ideas working together:\n\n**Smoothing** migrates part of the activation dynamic range into the weights (as in SmoothQuant[[6]](#references)), so neither side has to absorb the full outlier magnitude alone.A\n\n**high-precision low-rank correction branch** captures the residual outliers that low-bit quantization cannot represent. The weight matrix is decomposed via SVD; at inference, the output is the result of the low-bit residual GEMM**plus** a small rank-16-to-32 correction. That correction is cheap in compute and memory, yet recovers most of the accuracy lost at 4 bits.\n\nThis is what makes 4-bit **activation** quantization viable, not just weight-only compression: the `w4a4`\n\n, `mxfp4`\n\n, and `nvfp4`\n\nmodes below quantize activations as well as weights. In Quark, SVDQuant is configured through `SVDQuantConfig`\n\n, with ready-made schemes from `build_quant_layer_config`\n\n:\n\nMode |\nWeights |\nActivations |\nNotes |\n|---|---|---|---|\n|\nINT4 per-group |\nfp16 / bf16 |\nweight-only 4-bit |\n|\nINT4 per-group |\nINT4 per-group dynamic |\nfully 4-bit |\n|\nMXFP4 |\nMXFP4 (dynamic) |\n|\n|\nFP4 block-16 |\nFP4 block-16 dynamic |\nFP4 with FP8 block scales |\n\n**Native inference.** On MI300 / MI350 GPUs, `quark.torch.enable_native_inference`\n\nruns the low-bit residual GEMM on AMD AITER [[10]](#references) matrix-core kernels. For SVDQuant, the low-rank correction runs as a *separate* branch alongside that GEMM (optionally overlapped on a second CUDA stream via `RuntimeOptions(svdquant_overlap_streams=True)`\n\n); it is **not yet fused into the GEMM kernel** — a fused SVDQuant kernel is planned and will further reduce its latency. This path is part of AMD Quark’s diffusion support.\n\nThe table below shows Quark quantization of FLUX.1-dev on a gfx950 / MI350 GPU, reported relative to the BF16 baseline:\n\nConfig (FLUX.1-dev) |\nSpeedup vs BF16 ↑ |\nModel mem vs BF16 ↓ |\nPeak mem vs BF16 ↓ |\n|---|---|---|---|\nBF16 |\n1.00× |\n1.00× |\n1.00× |\nNative FP4 (plain RTN) |\n1.12× |\n0.67× |\n0.69× |\nNative SVDQuant |\n0.92× |\n0.73× |\n0.75× |\n\nPlain native FP4 runs about **1.12× faster** than BF16 while cutting model memory by roughly a third. Native SVDQuant trades a little speed (currently ~**0.92×** of BF16, due to the extra correction branch that is not yet fused) for the accuracy that makes 4-bit *activations* viable, while still trimming model memory by ~27%. Once the correction branch is fused into the GEMM, SVDQuant’s latency should move toward the plain FP4 path.\n\nThe images below are FLUX.1-dev generations produced with Quark SVDQuant across all four low-bit formats, using the same prompt and seed. Quality holds across INT4 and FP4:\n\nSVDQuant W4A16 |\nSVDQuant W4A4 |\n|---|---|\n|\n|\n\n*Figure 1. FLUX.1-dev generated with Quark SVDQuant across four low-bit formats (INT4 weight-only, INT4 W4A4, MXFP4, NVFP4), same prompt and seed — image quality holds across all four.*\n\nThese samples were produced with `examples/torch/diffusers/testSVDQuant.py`\n\n(multi-mode SVDQuant for SDXL / FLUX / SD3). On FLUX.1-dev, the SVDQuant W4A4, MXFP4, and NVFP4 variants all maintain CLIP scores [[11]](#references) within about half a point of the FP16 reference:\n\nSVDQuant (FLUX.1-dev) |\nResidual rounding |\nCLIP ↑ |\n|---|---|---|\nFP16 (reference) |\n— |\n27.82 |\nW4A4 |\nRTN |\n27.50 |\nW4A4 |\nGPTQ |\n27.40 |\nMXFP4 |\nRTN |\n27.41 |\nMXFP4 |\nGPTQ |\n27.36 |\nNVFP4 |\nRTN |\n27.72 |\nNVFP4 |\nGPTQ |\n28.01 |\n\n*CLIP score with openai/clip-vit-large-patch14 on 1,000 MJHQ [12] prompts (higher is better). “RTN” and “GPTQ” [13] denote how the 4-bit residual weights are rounded.*\n\n## Diffusers Support[#](#diffusers-support)\n\nA single `import quark.integrations.diffusers`\n\nstatement registers Quark as a Hugging Face Diffusers quantizer, so quantized diffusion models behave like any other Diffusers checkpoint. There are two ways to use it.\n\n**Offline quantization — quantize once, reload anywhere.** Quantize a pipeline submodule with `ModelQuantizer`\n\n, save it with `export_safetensors`\n\n(which routes through `save_pretrained`\n\nand embeds the serialized Quark `QConfig`\n\nunder `quantization_config`\n\nin `config.json`\n\n), and reload later with plain `from_pretrained`\n\n. The checkpoint is self-describing: the loader reads the config, rebuilds the quantized layers (with meta-device and `low_cpu_mem_usage`\n\nloading supported), loads the weights, and freezes the model for inference — no `QConfig`\n\nneeded at the call site.\n\n**Native online quantization — quantize at load time.** Pass `quantization_config=...`\n\nto `from_pretrained`\n\nagainst a plain fp16/bf16 checkpoint, and Quark applies weight-only quantization in-process, with no export/reload round-trip. We already offered online quantization through xDiT [[1]](#references) — where Quark replaces a transformer’s linear layers with FP8 or MXFP4 implementations at load time and routes them to AITER kernels — and that same online path is now available directly through Diffusers.\n\n**Availability.** Today this is enabled by importing `quark.integrations.diffusers`\n\n, which self-registers (monkeypatches) the `\"quark\"`\n\nmethod into the Diffusers registries at runtime. We also have a PR to add Quark to Diffusers upstream ([huggingface/diffusers#14077](https://github.com/huggingface/diffusers/pull/14077)); until it merges, the one-line import is all that’s needed — nothing else in your code changes.\n\n## Tutorial: Quantize, Save, and Reload a Diffusion Model[#](#tutorial-quantize-save-and-reload-a-diffusion-model)\n\nThis tutorial is adapted from the scripts in `examples/torch/diffusers`\n\n(`quantize_diffusers.py`\n\n, `testSVDQuant.py`\n\n). It uses SDXL [[14]](#references) and FLUX.1-dev [[4]](#references) as running examples; the same pattern applies to SD1.5 [[15]](#references), SD3 [[16]](#references), and PixArt [[17]](#references) by swapping the pipeline class and the target submodule.\n\n### Environment[#](#environment)\n\nThe setup mirrors the earlier xDiT blog. On an AMD Instinct GPU with a recent ROCm PyTorch image:\n\n```\ndocker run -it \\\n    --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \\\n    --device=/dev/kfd --device=/dev/dri --group-add video \\\n    --ipc=host --network host --shm-size 128G \\\n    -v /shareddata/:/data -w /workspace \\\n    rocm/pytorch-xdit:v26.5\n```\n\nInside the container, install Diffusers and Quark:\n\n```\npip install diffusers transformers accelerate\n# Install Quark from source (public repo, main branch)\ngit clone https://github.com/amd/quark.git Quark && cd Quark && pip install -e .\n```\n\nWhich submodule do you quantize? For\n\nSDXL / SD1.5it is`pipe.unet`\n\n; forFLUX / SD3 / PixArtit is`pipe.transformer`\n\n. Quantization is applied to that submodule, not the VAE or text encoders.\n\n### 1. Quantize, Save, and Reload through Diffusers[#](#quantize-save-and-reload-through-diffusers)\n\nThis is the headline workflow. Weight-only quantization needs no calibration data, so it is the simplest way to see the full round-trip: quantize the target submodule with `ModelQuantizer`\n\n, save it with `export_safetensors`\n\n(which routes through `save_pretrained`\n\nand embeds the Quark `QConfig`\n\nin `config.json`\n\n), and reload it later with plain `from_pretrained`\n\n.\n\n``` python\nimport torch\nfrom diffusers import DiffusionPipeline\nfrom quark.torch import ModelQuantizer, export_safetensors\nfrom quark.torch.quantization.config.config import Int8PerTensorSpec, QConfig, QLayerConfig\n\npipe = DiffusionPipeline.from_pretrained(\n    \"stabilityai/stable-diffusion-xl-base-1.0\",\n    torch_dtype=torch.float16, variant=\"fp16\",\n).to(\"cuda\")\n\n# INT8 weight-only. dataloader=None is allowed because there are no activation quantizers.\nweight_spec = Int8PerTensorSpec(\n    observer_method=\"min_max\", symmetric=True, scale_type=\"float\",\n    round_method=\"half_even\", is_dynamic=False,\n).to_quantization_spec()\nqconfig = QConfig(global_quant_config=QLayerConfig(weight=weight_spec))\n\npipe.unet = ModelQuantizer(qconfig).quantize_model(pipe.unet, dataloader=None)\n\n# Save through the standard Diffusers API: writes diffusion_pytorch_model.safetensors\n# plus a config.json carrying the serialized QConfig under `quantization_config`.\nexport_safetensors(pipe.unet, \"./sdxl-unet-quark-int8\")\n```\n\nReloading is a two-liner. Importing the integration self-registers the `\"quark\"`\n\nmethod; `from_pretrained`\n\nthen reads `quantization_config`\n\n, reconstructs the quantized layers via `process_model_transformation`\n\n, loads the checkpoint, and freezes the model for inference — no `QConfig`\n\nneeded at the call site:\n\n``` python\nimport quark.integrations.diffusers  # registers \"quark\" into the Diffusers registries\nfrom diffusers import UNet2DConditionModel\n\nunet = UNet2DConditionModel.from_pretrained(\"./sdxl-unet-quark-int8\")\npipe.unet = unet  # drop the reloaded, quantized module back into the pipeline\n\nimage = pipe(\"A cat on a windowsill\", num_inference_steps=30, guidance_scale=8.0).images[0]\nimage.save(\"sdxl_int8.png\")\n```\n\nThe same `config.json`\n\nmechanism works when the quantized submodule lives inside a full pipeline directory: `DiffusionPipeline.from_pretrained(\"<org>/<checkpoint>\")`\n\nreloads the whole quantized pipeline in one call. FP8 and other standard PTQ schemes follow the identical export/reload flow (activation-quantized schemes additionally need the calibration step described next).\n\n### 2. Going to 4 Bits with SVDQuant[#](#going-to-4-bits-with-svdquant)\n\nFor true 4-bit quantization you want SVDQuant, and activation-aware schemes need calibration data. The key insight is that a diffusion submodule’s inputs are intermediate latents, timestep embeddings, and conditioning — so calibration means **running the pipeline** and capturing those inputs. `get_calib_dataloader`\n\ndoes exactly that: each prompt triggers one pipeline run, and with `n_steps`\n\ndenoising steps the submodule is called `n_steps`\n\ntimes per prompt, yielding `len(prompts) * n_steps`\n\ncalibration samples.\n\n``` python\nimport torch\nfrom diffusers import FluxPipeline\nfrom quark.torch import ModelQuantizer, save_params\nfrom quark.torch.quantization.config.config import QConfig, SVDQuantConfig\nfrom quark.torch.algorithm.svdquant import build_quant_layer_config\nfrom quark.torch.utils.diffusers import get_calib_dataloader\n\npipe = FluxPipeline.from_pretrained(\n    \"black-forest-labs/FLUX.1-dev\",\n    torch_dtype=torch.bfloat16,\n    device_map=\"balanced\",\n)\n\nprompts = [\n    \"A serene lake reflecting mountains at sunset\",\n    \"A futuristic city with flying cars at night\",\n    \"A close-up portrait with dramatic lighting\",\n    \"A golden retriever playing in autumn leaves\",\n    \"An astronaut floating above Earth\",\n]\n\n# FLUX-specific pipe kwargs are forwarded straight to pipe(...).\ndataloader = get_calib_dataloader(\n    pipe, pipe.transformer, prompts, n_steps=20,\n    height=1024, width=1024, guidance_scale=3.5, max_sequence_length=512,\n)\n```\n\n`build_quant_layer_config(\"mxfp4\")`\n\nselects the MXFP4 scheme (swap in `\"w4a16\"`\n\n, `\"w4a4\"`\n\n, or `\"nvfp4\"`\n\nas needed), and `SVDQuantConfig`\n\nadds the low-rank correction branch. Note the two exclude lists: sensitive embedding/normalization layers are skipped, and `*correction*`\n\nmust always be excluded from quantization so the high-precision low-rank branch is protected.\n\n```\nSVD_EXCLUDE = [\n    \"*x_embedder*\", \"*context_embedder*\", \"*time_text_embed*\",\n    \"*norm_out*\", \"*proj_out*\", \"*norm1.linear*\", \"*norm1_context.linear*\",\n]\n\nqconfig = QConfig(\n    global_quant_config=build_quant_layer_config(\"mxfp4\"),   # or \"w4a16\", \"w4a4\", \"nvfp4\"\n    exclude=[*SVD_EXCLUDE, \"*correction*\"],\n    algo_config=[SVDQuantConfig(\n        svd_rank=32,\n        search_alpha=False,          # set True to search per-layer smoothing alpha\n        min_layer_size=256,\n        exclude_patterns=SVD_EXCLUDE,\n    )],\n)\n\npipe.transformer = ModelQuantizer(qconfig).quantize_model(pipe.transformer, dataloader)\n\nimage = pipe(\n    \"A cat on a windowsill\", num_inference_steps=50,\n    height=1024, width=1024, guidance_scale=3.5, max_sequence_length=512,\n).images[0]\nimage.save(\"flux_svdquant_mxfp4.png\")\n```\n\nAn SVDQuant checkpoint is an `ErrorCorrectedModule`\n\n(a quantized residual plus the low-rank correction and smooth factors), so it is persisted with Quark’s `save_params`\n\nrather than the QDQ Diffusers export above:\n\n```\nfrozen = ModelQuantizer.freeze(pipe.transformer)\nsave_params(frozen, model_type=\"transformer\", export_dir=\"./flux-svdquant-mxfp4\")\n```\n\n**Tuning the smoothing strength with the calibration data.** SVDQuant’s `smooth_alpha`\n\nsets how much of the activation range is migrated into the weights before the SVD split. A single global value (default `0.5`\n\n) is a fine starting point, but the best alpha varies per layer. Setting `search_alpha=True`\n\nturns on a per-layer search that **reuses the calibration activations you already collected**: for each layer, the search tries several candidate alpha values and keeps the one that minimizes post-SVD reconstruction error, using only a handful of cached activations so it stays cheap.\n\n```\nalgo_config=[SVDQuantConfig(\n    svd_rank=32,\n    search_alpha=True,                          # per-layer alpha search, driven by the calib activations\n    alpha_candidates=[0.1, 0.3, 0.5, 0.7, 0.9], # optional; defaults to a ~0.05-0.95 sweep\n    alpha_search_max_samples=8,                 # cached activations per layer used for the search\n    min_layer_size=256,\n    exclude_patterns=SVD_EXCLUDE,\n)]\n```\n\nThe search runs inside the same `ModelQuantizer(qconfig).quantize_model(pipe.transformer, dataloader)`\n\ncall — the dataloader from `get_calib_dataloader`\n\nsupplies the activations, so no extra setup is needed. To sweep more broadly, `examples/torch/diffusers/svdquant_calibrate.py`\n\nautomates a grid search over the smoothing alpha, GPTQ on/off, and calibration-sample count, scores each configuration against a high-precision reference, and reports the best; `testSVDQuant.py`\n\ncovers SDXL / FLUX / SD3 across `w4a16`\n\n, `w4a4`\n\n, and `mxfp4`\n\n.\n\n### 3. Native FP4 Inference on AMD Instinct[#](#native-fp4-inference-on-amd-instinct)\n\nQuantizing the model reduces its memory footprint immediately, but to turn low precision into *latency* wins you want real low-bit GEMM kernels rather than the emulation (QDQ) path. On MI300 / MI350 GPUs, `enable_native_inference`\n\nmoves the low-bit residual GEMM (and, for SVDQuant, the low-rank correction branch) to AMD AITER matrix-core kernels:\n\n``` python\nfrom quark.torch import enable_native_inference, RuntimeOptions\n\nn = enable_native_inference(\n    pipe.transformer,\n    runtime_options=RuntimeOptions(native_linear_mode=\"mxfp4\"),\n)\nprint(f\"Native inference enabled for {n} layers\")\n\nimage = pipe(\n    \"A cat on a windowsill\", num_inference_steps=50,\n    height=1024, width=1024, guidance_scale=3.5, max_sequence_length=512,\n).images[0]\n```\n\nNative inference is a **runtime mode re-enabled after loading**, not a save format — the on-disk checkpoint is identical whether or not you later run natively, so you save once and choose the execution path per deployment GPU. The SVDQuant native path — the AITER MXFP4 residual GEMM plus the separate low-rank correction branch — is part of AMD Quark’s native-inference support.\n\n## Summary[#](#summary)\n\nIn this blog, you learned how to take a diffusion model down to 4 bits with AMD Quark and run it on AMD Instinct GPUs without leaving the Hugging Face Diffusers workflow you already use. Specifically, you explored:\n\n**Why 4-bit activation diffusion is hard, and how SVDQuant answers it.** Outlier channels in both weights and activations force a naive 4-bit grid to stretch until the bulk of the values lose resolution. SVDQuant pairs SmoothQuant-style smoothing with a high-precision, low-rank correction branch, and that combination is what makes 4-bit*activation*quantization viable rather than weight-only compression. On FLUX.1-dev you saw the W4A4, MXFP4, and NVFP4 variants all maintain CLIP scores within about half a point of the FP16 reference.**How to quantize, save, and reload through the standard Diffusers APIs.** A single`import quark.integrations.diffusers`\n\nstatement registers Quark as a Diffusers quantizer, which makes a quantized checkpoint self-describing:`export_safetensors`\n\nembeds the`QConfig`\n\nin`config.json`\n\n, and a plain`from_pretrained`\n\nrebuilds the quantized layers with no`QConfig`\n\nneeded at the call site. You can also skip the round-trip entirely and quantize online at load time — the same capability we previously offered through xDiT, now available directly in Diffusers.**How to calibrate an activation-aware scheme.** Because a diffusion submodule’s inputs are intermediate latents and conditioning rather than text or images, calibration means running the pipeline.`get_calib_dataloader`\n\ncaptures those inputs for you, and`search_alpha=True`\n\nreuses the very same activations to tune the smoothing strength layer by layer.**How to turn low precision into real speed.**`enable_native_inference`\n\nmoves the low-bit GEMM onto AMD AITER matrix-core kernels, where plain native FP4 reaches 1.12× the BF16 baseline on MI350 while cutting model memory by roughly a third.\n\n**What’s next.** The SVDQuant low-rank correction currently runs as a separate branch alongside the residual GEMM, which is why it trades a little speed today at ~0.92× of BF16. A fused SVDQuant kernel is planned, and it should move that latency toward the plain FP4 path while keeping the accuracy that 4-bit activations depend on. On the integration side, [huggingface/diffusers#14077](https://github.com/huggingface/diffusers/pull/14077) will add Quark to Diffusers upstream, at which point even the one-line import goes away.\n\nTry it on your own pipeline: quantize `pipe.transformer`\n\n(or `pipe.unet`\n\n), export the model with `export_safetensors`\n\n, and reload it with `from_pretrained`\n\n. The full, runnable scripts live in `examples/torch/diffusers`\n\nin the public [AMD Quark](https://github.com/amd/quark) repository.\n\n## Acknowledgements[#](#acknowledgements)\n\nThe authors thank the AMD Quark and AITER teams for their guidance and support in enabling FP4 GEMM kernels and the Diffusers integration on AMD Instinct™ GPUs.\n\n## References[#](#references)\n\n[1] Yu, X., Bao, B., Niu, X., Luo, W., Wang, K., Tiwari, S., and Sirasao, A. “Accelerating Diffusers and xDiT Image Generation with MXFP4 using AMD Quark on AMD Instinct MI350 GPUs.” *AMD ROCm Blogs*, July 2026. [https://rocm.blogs.amd.com/artificial-intelligence/quark-xdit/README.html](https://rocm.blogs.amd.com/artificial-intelligence/quark-xdit/README.html).\n\n[2] AMD Quark: cross-platform deep learning quantization toolkit. GitHub: [amd/quark](https://github.com/amd/quark). Documentation: [https://quark.docs.amd.com/latest/](https://quark.docs.amd.com/latest/).\n\n[3] Hugging Face. “Diffusers: state-of-the-art diffusion models for image, video, and audio generation in PyTorch.” GitHub: [huggingface/diffusers](https://github.com/huggingface/diffusers).\n\n[4] Black Forest Labs. “FLUX.1-dev.” Hugging Face model card. [https://huggingface.co/black-forest-labs/FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev).\n\n[5] Li, M., Lin, Y., Zhang, Z., Cai, T., Li, X., Guo, J., Xie, E., Meng, C., Zhu, J.-Y., and Han, S. “SVDQuant: Absorbing Outliers by Low-Rank Components for 4-Bit Diffusion Models.” *ICLR 2025.* arXiv:2411.05007. [https://arxiv.org/abs/2411.05007](https://arxiv.org/abs/2411.05007).\n\n[6] Xiao, G., Lin, J., Seznec, M., Wu, H., Demouth, J., and Han, S. “SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models.” *ICML 2023.* arXiv:2211.10438. [https://arxiv.org/abs/2211.10438](https://arxiv.org/abs/2211.10438).\n\n[7] Open Compute Project. “OCP Microscaling Formats (MX) Specification, Version 1.0.” September 2023. [https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf).\n\n[8] Darvish Rouhani, B., Zhao, R., More, A., Hall, M., Khodamoradi, A., Deng, S., Choudhary, D., Cornea, M., Dellinger, E., Denolf, K., et al. “Microscaling Data Formats for Deep Learning.” arXiv:2310.10537, 2023. [https://arxiv.org/abs/2310.10537](https://arxiv.org/abs/2310.10537).\n\n[9] NVIDIA. “Introducing NVFP4 for Efficient and Accurate Low-Precision Inference.” *NVIDIA Technical Blog*, June 2025. [https://developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference/](https://developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference/).\n\n[10] AITER: AI Tensor Engine for ROCm. GitHub: [ROCm/aiter](https://github.com/ROCm/aiter).\n\n[11] Radford, A., Kim, J. W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., Sastry, G., Askell, A., Mishkin, P., Clark, J., Krueger, G., and Sutskever, I. “Learning Transferable Visual Models From Natural Language Supervision.” *ICML 2021.* arXiv:2103.00020. [https://arxiv.org/abs/2103.00020](https://arxiv.org/abs/2103.00020).\n\n[12] Li, D., Kamko, A., Akhgari, E., Sabet, A., Xu, L., and Doshi, S. “Playground v2.5: Three Insights towards Enhancing Aesthetic Quality in Text-to-Image Generation.” arXiv:2402.17245, 2024. [https://arxiv.org/abs/2402.17245](https://arxiv.org/abs/2402.17245). MJHQ-30K benchmark: [https://huggingface.co/datasets/playgroundai/MJHQ-30K](https://huggingface.co/datasets/playgroundai/MJHQ-30K).\n\n[13] Frantar, E., Ashkboos, S., Hoefler, T., and Alistarh, D. “GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers.” *ICLR 2023.* arXiv:2210.17323. [https://arxiv.org/abs/2210.17323](https://arxiv.org/abs/2210.17323).\n\n[14] Podell, D., English, Z., Lacey, K., Blattmann, A., Dockhorn, T., Müller, J., Penna, J., and Rombach, R. “SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis.” *ICLR 2024.* arXiv:2307.01952. [https://arxiv.org/abs/2307.01952](https://arxiv.org/abs/2307.01952).\n\n[15] Rombach, R., Blattmann, A., Lorenz, D., Esser, P., and Ommer, B. “High-Resolution Image Synthesis with Latent Diffusion Models.” *CVPR 2022.* arXiv:2112.10752. [https://arxiv.org/abs/2112.10752](https://arxiv.org/abs/2112.10752).\n\n[16] Esser, P., Kulal, S., Blattmann, A., Entezari, R., Müller, J., Saini, H., Levi, Y., Lorenz, D., Sauer, A., Boesel, F., et al. “Scaling Rectified Flow Transformers for High-Resolution Image Synthesis.” *ICML 2024.* arXiv:2403.03206. [https://arxiv.org/abs/2403.03206](https://arxiv.org/abs/2403.03206).\n\n[17] Chen, J., Yu, J., Ge, C., Yao, L., Xie, E., Wu, Y., Wang, Z., Kwok, J., Luo, P., Lu, H., and Li, Z. “PixArt-α: Fast Training of Diffusion Transformer for Photorealistic Text-to-Image Synthesis.” *ICLR 2024.* arXiv:2310.00426. [https://arxiv.org/abs/2310.00426](https://arxiv.org/abs/2310.00426).\n\n## Disclaimers[#](#disclaimers)\n\nThe information presented in this document is for informational purposes only and may contain technical inaccuracies, omissions, and typographical errors. The information contained herein is subject to change and may be rendered inaccurate for many reasons, including but not limited to product and roadmap changes, component and motherboard version changes, new model and/or product releases, product differences between differing manufacturers, software changes, BIOS flashes, firmware upgrades, or the like. Any computer system has risks of security vulnerabilities that cannot be completely prevented or mitigated. AMD assumes no obligation to update or otherwise correct or revise this information. However, AMD reserves the right to revise this information and to make changes from time to time to the content hereof without obligation of AMD to notify any person of such revisions or changes. THIS INFORMATION IS PROVIDED ‘AS IS.” AMD MAKES NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE CONTENTS HEREOF AND ASSUMES NO RESPONSIBILITY FOR ANY INACCURACIES, ERRORS, OR OMISSIONS THAT MAY APPEAR IN THIS INFORMATION. AMD SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT WILL AMD BE LIABLE TO ANY PERSON FOR ANY RELIANCE, DIRECT, INDIRECT, SPECIAL, OR OTHER CONSEQUENTIAL DAMAGES ARISING FROM THE USE OF ANY INFORMATION CONTAINED HEREIN, EVEN IF AMD IS EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. AMD, the AMD Arrow logo, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies. © 2026 Advanced Micro Devices, Inc. All rights reserved", "url": "https://wpnews.pro/news/quark-support-for-huggingface-diffusers-and-svdquant", "canonical_source": "https://rocm.blogs.amd.com/software-tools-optimization/quark-diffusers/README.html", "published_at": "2026-08-06 00:00:00+00:00", "updated_at": "2026-08-09 09:43:53.466652+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "generative-ai", "ai-tools"], "entities": ["AMD Quark", "Hugging Face Diffusers", "SVDQuant", "FLUX.1-dev", "AMD Instinct MI350", "AMD AITER"], "alternates": {"html": "https://wpnews.pro/news/quark-support-for-huggingface-diffusers-and-svdquant", "markdown": "https://wpnews.pro/news/quark-support-for-huggingface-diffusers-and-svdquant.md", "text": "https://wpnews.pro/news/quark-support-for-huggingface-diffusers-and-svdquant.txt", "jsonld": "https://wpnews.pro/news/quark-support-for-huggingface-diffusers-and-svdquant.jsonld"}}