{"slug": "accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on", "title": "Accelerating Diffusers and xDiT Image Generation with MXFP4 using AMD Quark on AMD Instinct™ MI350 GPUs", "summary": "AMD Quark, a quantization library optimized for AMD Instinct MI350 GPUs, enables MXFP4 quantization for Diffusers and xDiT FLUX.1-dev image generation, achieving up to 1.92× speedup over BF16 eager and 1.41× over BF16 torch.compile while preserving CLIP quality. The integration reduces inference cost without sacrificing image quality.", "body_md": "# Accelerating Diffusers and xDiT Image Generation with MXFP4 using AMD Quark on AMD Instinct™ MI350 GPUs[#](#accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on-amd-instinct-mi350-gpus)\n\nDiffusion models such as Black Forest Labs’ FLUX.1-dev [[1]](#references) deliver stunning image quality but demand significant compute and memory bandwidth at inference time. To reduce inference cost without sacrificing image quality, precision-aware quantization techniques have become a critical optimization strategy.\n\nIn this blog, we demonstrate how **AMD Quark** [[2]](#references), a high-performance quantization library optimized for AMD Instinct™ MI350 GPUs, enables **MXFP4** quantization for Diffusers [[5]](#references) and xDiT [[3]](#references) FLUX.1-dev image generation. Starting from BF16 eager and `torch.compile`\n\nbaselines, we apply Quark native inference with AITER [[4]](#references) GEMM kernels and show that MXFP4 ASM with `torch.compile`\n\nreaches **1.92× speedup** over BF16 eager and **1.41× speedup** over BF16 `torch.compile`\n\n, while preserving CLIP quality.\n\n## Quantization with Quark[#](#quantization-with-quark)\n\nAMD Quark is a comprehensive cross-platform deep learning toolkit designed to simplify and enhance the quantization of deep learning models. For diffusion model quantization, Quark is tightly integrated with ROCm™ and optimized for matrix-core acceleration. It provides:\n\n**Multiple numeric formats**— MXFP4, MXFP6, FP8, INT8, INT4, and more** Modular quantization flows**— Post-Training Quantization (PTQ), Quantization-Aware Training (QAT), and others** Support for diffusion models**— FLUX, Stable Diffusion, and large decoder-only LLMs** Native inference acceleration**— via AMD AITER GEMM kernels on MI300/MI350 GPUs** Seamless integration**— with inference pipelines such as Diffusers[[5]](#references), vLLM, and SGLang\n\nWith Quark, users can configure per-layer quantization schemes based on layer sensitivity, enabling both uniform and mixed-precision flows. By combining this flexibility with the native FP4/FP8 matrix-core capabilities of MI350 GPUs, Quark achieves near-lossless image quality while significantly improving inference efficiency.\n\nQuark provides online quantization for xDiT to make inference more efficient. xDiT is a parallel inference engine for diffusion transformers — it shards and executes a model like FLUX.1-dev across one or more GPUs. Quark plugs into that pipeline at load time: it converts the BF16 transformer’s linear layers into FP8 or MXFP4 in-memory and routes the resulting GEMMs to native AITER matrix-core kernels on MI300 / MI350 GPUs — with no offline checkpoint conversion required.\n\n### How Quark Fits into the xDiT Stack[#](#how-quark-fits-into-the-xdit-stack)\n\nThe diagram below shows where Quark sits inside the xDiT inference stack:\n\nDiffusers exposes the standard `FluxPipeline`\n\nAPI, xDiT parallelizes the transformer across GPUs, and Quark online-quantizes each replica’s linear layers to FP8 / MXFP4 so they execute on AITER’s matrix-core GEMM kernels. The benchmarks in the rest of this blog measure the impact of this innermost swap — Quark-quantized linear layers — with the xDiT and Diffusers layers unchanged.\n\n## Preparation[#](#preparation)\n\n### Environment[#](#environment)\n\nComponent |\nVersion / Image |\n|---|---|\nHardware |\nAMD Instinct™ MI350 (gfx950) |\nDocker |\n|\nQuark Release |\n0.12 |\nPyTorch |\n|\nAITER |\n|\nModel |\n|\nResolution |\n1024 × 768, 20 inference steps, |\n\n### Docker Setup[#](#docker-setup)\n\n```\ndocker run -it \\\n    --cap-add=SYS_PTRACE \\\n    --security-opt seccomp=unconfined \\\n    --user root \\\n    --device=/dev/kfd --device=/dev/dri --device=/dev/mem \\\n    --group-add video \\\n    --ipc=host --network host --privileged \\\n    --shm-size 128G \\\n    --name flux_benchmark \\\n    -e HSA_NO_SCRATCH_RECLAIM=1 \\\n    -e CUDA_VISIBLE_DEVICES=0 \\\n    -v /shareddata/:/data \\\n    -v /home/$USER:/workspace \\\n    -w /workspace \\\n    rocm/pytorch-xdit:v26.5\n```\n\n### Install Dependencies (inside container)[#](#install-dependencies-inside-container)\n\n```\napt-get update && apt-get install -y nano python3-tk\n\npip install torchmetrics transformers hpsv2 open_clip_torch pycocotools\n\n# Install Quark from source (main branch)\ncd /workspace\ngit clone https://github.com/amd/quark.git Quark && cd Quark\npip install -e .\n\n# Verify GPU & AITER\nrocm-smi --showproductname\npython3 -c \"import torch; print(torch.cuda.get_device_name(0))\"\npython3 -c \"import aiter; print('AITER OK')\"\n```\n\n## BF16 Baseline[#](#bf16-baseline)\n\nBF16 (bfloat16) serves as the unquantized baseline configuration. It loads and runs the FLUX.1-dev model as-is in 16-bit floating point. No quantization is applied.\n\n### Benchmark Script[#](#benchmark-script)\n\n``` python\nimport torch\nfrom diffusers import FluxPipeline\n\npipe = FluxPipeline.from_pretrained(\n    \"/data/black-forest-labs/FLUX.1-dev\",\n    torch_dtype=torch.bfloat16,\n).to(\"cuda\")\n\nprompt = \"A photo of a cat sitting on a windowsill at sunset\"\nfor _ in range(3):  # warmup\n    pipe(prompt, height=768, width=1024, num_inference_steps=20, guidance_scale=3.5)\n\nimport time\nlatencies = []\nfor _ in range(10):\n    t0 = time.time()\n    pipe(prompt, height=768, width=1024, num_inference_steps=20, guidance_scale=3.5)\n    latencies.append(time.time() - t0)\nprint(f\"BF16 Mean latency: {sum(latencies)/len(latencies):.3f} s/img\")\n```\n\n## MXFP4 Quantization[#](#mxfp4-quantization)\n\nMXFP4, defined as part of the OCP Microscaling (MX) specification [[6]](#references), groups 32 elements of 4-bit floating-point values to share a common E8M0 scaling exponent. Because it uses block-level scaling with FP4 elements, MXFP4 enables substantial model compression while retaining sufficient dynamic range for diffusion-model inference.\n\nSupported natively on AMD Instinct™ MI350 and newer GPUs, MXFP4 delivers the strongest efficiency gains among all supported formats tested in this blog, achieving **up to 1.92× speedup** over the BF16 eager baseline and **1.41× speedup** over BF16 `torch.compile`\n\nwhen combined with the in-tree `torch.compile`\n\nfix that landed on Quark `main`\n\n.\n\n### MXFP4 Quantization & Benchmark Script[#](#mxfp4-quantization-benchmark-script)\n\n``` python\nimport torch\nfrom diffusers import FluxPipeline\nfrom quark.torch.quantization.api import ModelQuantizer, RuntimeOptions\nfrom quark.torch.quantization.config.config import (\n    QConfig, QLayerConfig, OCP_MXFP4Spec,\n)\n\npipe = FluxPipeline.from_pretrained(\n    \"/data/black-forest-labs/FLUX.1-dev\",\n    torch_dtype=torch.bfloat16,\n).to(\"cuda\")\n\n# Configure MXFP4 quantization with 32-element block scaling\nweight_spec = OCP_MXFP4Spec(ch_axis=-1, is_dynamic=False).to_quantization_spec()\ninput_spec  = OCP_MXFP4Spec(ch_axis=-1, is_dynamic=True).to_quantization_spec()\nlayer_config = QLayerConfig(weight=weight_spec, input_tensors=input_spec)\n\nquantizer = ModelQuantizer(QConfig(global_quant_config=layer_config))\npipe.transformer = quantizer.quantize_model(pipe.transformer)\n\n# Freeze model with MXFP4 native inference (AITER FP4 GEMM kernels)\nruntime_opts = RuntimeOptions(native_linear_mode=\"mxfp4\")\npipe.transformer = ModelQuantizer.freeze(\n    pipe.transformer, runtime_options=runtime_opts,\n)\n\n# Benchmark\nprompt = \"A photo of a cat sitting on a windowsill at sunset\"\nfor _ in range(3):\n    pipe(prompt, height=768, width=1024, num_inference_steps=20, guidance_scale=3.5)\n\nimport time\nlatencies = []\nfor _ in range(10):\n    t0 = time.time()\n    pipe(prompt, height=768, width=1024, num_inference_steps=20, guidance_scale=3.5)\n    latencies.append(time.time() - t0)\nprint(f\"MXFP4 Mean latency: {sum(latencies)/len(latencies):.3f} s/img\")\n```\n\n### MXFP4 Kernel[#](#mxfp4-kernel)\n\nOn Quark `main`\n\n, the MXFP4 native linear uses AITER’s **ASM GEMM path by default**: `per_1x32_f4_quant_hip`\n\nfor activation quantization plus `gemm_a4w4`\n\nwith `bpreshuffle=True`\n\n, with a dequantization and matrix-multiply fallback for small-K layers. No user flag is needed. Instantiating `RuntimeOptions(native_linear_mode=\"mxfp4\")`\n\nselects ASM automatically.\n\nPath |\nActivation Quantization |\nGEMM Kernel |\nEager Latency |\n|\n|---|---|---|---|---|\n|\n|\n|\n|\n|\n\n## Quality Evaluation[#](#quality-evaluation)\n\nImage quality is evaluated with **CLIP Score** [[7]](#references), a text-image alignment metric where higher is better, on 100 COCO 2017 [[8]](#references) caption prompts. We report results with `openai/clip-vit-base-patch16`\n\n, where FLUX scores land in the 30-32 range typical of FLUX papers.\n\n### Evaluation Script[#](#evaluation-script)\n\nThe CLIP evaluation helper is available as [ eval_clip.py](../../_downloads/55562cf2c53c5b6cd65bb0bd6ae2d5ff/eval_clip.py).\n\n```\npython3 eval_clip.py \\\n    --image_dir <OUTPUT_DIR>/images \\\n    --output_dir <OUTPUT_DIR>/clip \\\n    --coco_annotations /data/coco/annotations/captions_val2017.json \\\n    --num_prompts 100 \\\n    --model_name openai/clip-vit-base-patch16\n```\n\nSwitch backbones via `--model_name`\n\n, for example `openai/clip-vit-large-patch14`\n\n. Any Hugging Face CLIP ID is accepted.\n\n### Quality Results[#](#quality-results)\n\nConfiguration |\nCLIP (ViT-B/16) ↑ |\n|---|---|\n|\n30.98 |\n|\n31.38 |\n|\n31.69 |\n|\n|\n\n↑ = indicates higher is better\n\nAll quantized configurations preserve CLIP quality within the per-configuration noise floor of ±0.5 absolute points on 100 samples. MXFP4 ASM matches or slightly exceeds BF16, and `torch.compile`\n\ndoes not regress quality on any path.\n\n### Sample Images[#](#sample-images)\n\nThe samples below compare BF16 against MXFP4 ASM for the same prompt and seed. Prompt 1 is “A black Honda motorcycle parked in front of a garage.” Prompt 2 is “Two women waiting at a bench next to a street.”\n\n|\n|\n|\n|---|---|---|\n1 |\n||\n2 |\n\n## Performance Uplift[#](#performance-uplift)\n\nAll latency measurements were collected on a single AMD Instinct™ MI350 (gfx950) GPU running FLUX.1-dev at 1024×768, 20 inference steps, averaged over 100 COCO captions.\n\n### Latency Comparison[#](#latency-comparison)\n\nConfiguration |\nLatency (s/img) ↓ |\nSpeedup vs BF16 eager ↑ |\n|---|---|---|\nBF16 Eager (Baseline) |\n2.054 |\n1.00× |\n|\n1.779 |\n|\n|\n1.506 |\n|\n|\n|\n|\n\n↓ = indicates lower is better, ↑ = indicates higher is better\n\n### Eager Performance Chart[#](#eager-performance-chart)\n\n```\nSpeedup vs BF16 eager (higher is better)\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\nBF16 Eager (baseline)   ████████████████████                  1.00× (2.054s)\nMXFP4 ASM Eager         ███████████████████████               1.15× (1.779s)\n```\n\n`torch.compile`\n\nPerformance Chart[#](#torch-compile-performance-chart)\n\n```\nSpeedup vs BF16 torch.compile (higher is better)\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\nBF16 torch.compile      ████████████████████                  1.00× (1.506s)\nMXFP4 ASM Compiled      ████████████████████████████          1.41× (1.069s)\n```\n\n### Key Takeaways[#](#key-takeaways)\n\n**In eager mode, MXFP4 ASM is faster than BF16 eager**, reaching** 1.15×**speedup at** 1.779 s/img**.** In**, reducing latency from`torch.compile`\n\nmode, MXFP4 ASM is 1.41× faster than BF16`torch.compile`\n\n**1.506 s/img** to**1.069 s/img**. This is the clean same-mode comparison enabled by the in-tree opaque-op fix on Quark`main`\n\n.**MXFP4 ASM with**, making it the fastest configuration tested. This end-to-end view combines the benefits of low-precision GEMMs with compiler fusion around the BF16 operations.`torch.compile`\n\nis still 1.92× faster than BF16 eager overall\n\n## xFuser Multi-GPU Benchmarks[#](#xfuser-multi-gpu-benchmarks)\n\nWe also tested Quark MXFP4 with xFuser’s Ulysses parallelism on multiple AMD Instinct™ MI350 GPUs. This path is useful when a model or workload requires multiple GPUs. At 1024×768 with 20 inference steps, the latest 2-GPU batch sweep shows that MXFP4 improves throughput by about **1.21× to 1.23×** over BF16 with `torch.compile(mode=\"reduce-overhead\")`\n\n.\n\n### 2-GPU Ulysses Benchmark[#](#gpu-ulysses-benchmark)\n\n#### 2-GPU Benchmark Script[#](#gpu-benchmark-script)\n\nThe 2-GPU benchmark uses xFuser’s runner directly under `torchrun`\n\n. The core flow is shown below; rank 0 reports the average per-image latency after warmup.\n\nSave the benchmark as a local Python script, then launch it with two visible GPUs:\n\n```\nSCRIPT=/path/to/your_2gpu_xdit_benchmark.py\n\nCUDA_VISIBLE_DEVICES=0,1 HIP_VISIBLE_DEVICES=0,1 \\\nPRECISION=mxfp4 \\\nBATCH_SIZE=16 \\\ntorchrun --nproc_per_node 2 --master_port 29541 \"$SCRIPT\"\n```\n\nUse `PRECISION=bf16`\n\nfor the BF16 baseline and `PRECISION=mxfp4`\n\nfor the Quark MXFP4 run. Set `BATCH_SIZE=4`\n\n, `8`\n\n, or `16`\n\nto reproduce the table rows.\n\n``` python\nimport os\nimport time\n\nimport torch\nfrom xfuser.runner import xFuserModelRunner\n\nfrom quark.torch.quantization.api import ModelQuantizer\nfrom quark.torch.quantization.config.config import QConfig, QLayerConfig, OCP_MXFP4Spec\nfrom quark.torch.quantization.utils import RuntimeOptions\n\nPROMPTS = [\n    \"A photo of a city skyline at sunset with vivid orange and purple clouds\",\n    \"A close-up portrait of a tabby cat sitting on a wooden windowsill\",\n    \"An astronaut riding a horse through a snowy mountain pass at dawn\",\n]\n\ndef apply_mxfp4(transformer):\n    spec = OCP_MXFP4Spec(ch_axis=-1, is_dynamic=True).to_quantization_spec()\n    layer_config = QLayerConfig(weight=spec, input_tensors=spec)\n    quantizer = ModelQuantizer(QConfig(global_quant_config=layer_config))\n    transformer = quantizer.quantize_model(transformer)\n    return quantizer.freeze(\n        transformer,\n        runtime_options=RuntimeOptions(native_linear_mode=\"mxfp4\"),\n    )\n\ndef compile_transformer_blocks(transformer):\n    for i, block in enumerate(transformer.transformer_blocks):\n        transformer.transformer_blocks[i] = torch.compile(block, mode=\"reduce-overhead\", fullgraph=False)\n    for i, block in enumerate(transformer.single_transformer_blocks):\n        transformer.single_transformer_blocks[i] = torch.compile(block, mode=\"reduce-overhead\", fullgraph=False)\n\ndef make_prompt_batch(batch_size, offset=0):\n    return [PROMPTS[(offset + i) % len(PROMPTS)] for i in range(batch_size)]\n\ndef run_benchmark(precision=\"mxfp4\", batch_size=16, warmup=2, num_iterations=6):\n    config = {\n        \"model\": \"black-forest-labs/FLUX.1-dev\",\n        \"height\": 768,\n        \"width\": 1024,\n        \"num_inference_steps\": 20,\n        \"guidance_scale\": 3.5,\n        \"max_sequence_length\": 512,\n        \"ulysses_degree\": 2,\n        \"ring_degree\": 1,\n        \"output_directory\": f\"/tmp/flux_2gpu_{precision}\",\n        \"warmup_calls\": 0,\n        \"num_iterations\": 1,\n        \"use_torch_compile\": False,\n        \"seed\": 42,\n    }\n\n    runner = xFuserModelRunner(config)\n    input_args = runner.preprocess_args(config)\n    runner.initialize(input_args)\n    pipe = runner.model.pipe\n\n    if precision == \"mxfp4\":\n        pipe.transformer = apply_mxfp4(pipe.transformer)\n\n    torch._inductor.config.reorder_for_compute_comm_overlap = True\n    compile_transformer_blocks(pipe.transformer)\n\n    for i in range(warmup):\n        torch.compiler.cudagraph_mark_step_begin()\n        runner.model._run_pipe({**input_args, \"prompt\": make_prompt_batch(batch_size, i)})\n        torch.cuda.synchronize()\n\n    timings = []\n    for i in range(num_iterations):\n        torch.cuda.synchronize()\n        torch.compiler.cudagraph_mark_step_begin()\n        start = time.perf_counter()\n        runner.model._run_pipe({**input_args, \"prompt\": make_prompt_batch(batch_size, i)})\n        torch.cuda.synchronize()\n        timings.append(time.perf_counter() - start)\n\n    if int(os.environ.get(\"RANK\", 0)) == 0:\n        time_per_iteration = sum(timings) / len(timings)\n        print(f\"{precision} batch {batch_size}: {time_per_iteration:.3f} s/iteration, {time_per_iteration / batch_size:.3f} s/img\")\n\n    runner.cleanup()\n\nif __name__ == \"__main__\":\n    run_benchmark(\n        precision=os.environ.get(\"PRECISION\", \"mxfp4\"),\n        batch_size=int(os.environ.get(\"BATCH_SIZE\", \"16\")),\n    )\n```\n\nThe `blocks_only`\n\ncompile scope compiles the 19 dual transformer blocks and 38 single transformer blocks while leaving xFuser’s top-level wrappers in eager mode. This avoids tracing xFuser’s collective communication wrappers into the compiled graph.\n\n#### 2-GPU Performance Comparison[#](#gpu-performance-comparison)\n\nThe table below reports a 2-GPU Ulysses batch sweep on dual MI350 GPUs using `blocks_only`\n\n`torch.compile(mode=\"reduce-overhead\")`\n\n, 6 timed iterations after 2 warmup iterations, and the same FLUX.1-dev settings used above.\n\nPrecision |\nBatch |\ntime(s) / iteration ↓ |\ntime(s) / img ↓ |\nvs BF16 |\n|---|---|---|---|---|\nBF16 |\n4 |\n4.488 |\n1.122 |\n1.00× |\nBF16 |\n8 |\n8.502 |\n1.063 |\n1.00× |\nBF16 |\n16 |\n16.826 |\n1.052 |\n1.00× |\n|\n|\n|\n|\n|\n|\n|\n|\n|\n|\n|\n|\n|\n|\n|\n\nMXFP4 reaches the best 2-GPU result at batch 16: **0.855 s/img**, a **1.23×** throughput uplift over BF16 at the same batch size.\n\n## Summary[#](#summary)\n\nThis blog provides a practical, step-by-step guide to quantizing and accelerating FLUX.1-dev image generation using AMD Quark on AMD Instinct™ MI350 GPUs. On a single GPU, **MXFP4 ASM with torch.compile** delivers up to\n\n**1.92× speedup** over BF16 eager (1.069 s/img), and is also\n\n**1.41× faster** than BF16\n\n`torch.compile`\n\n, with CLIP quality matching or exceeding BF16 on both ViT-L/14 and ViT-B/16 backbones. On the 2-GPU xFuser Ulysses path, MXFP4 with `torch.compile(mode=\"reduce-overhead\")`\n\nreaches **0.855 s/img** at batch 16, a\n\n**1.23×** uplift over the BF16 2-GPU baseline.\n\nBy combining Quark’s flexible quantization workflows with the native FP4 matrix-core capabilities of MI350-class GPUs and the `torch.compile`\n\n-compatible MXFP4 ASM path on Quark `main`\n\n, developers can efficiently deploy diffusion models with significantly lower latency and reduced memory footprint while maintaining near-lossless image quality.\n\n## Acknowledgements[#](#acknowledgements)\n\nThe authors wish to thank the AMD Quark and AITER teams for their invaluable guidance and support in enabling MXFP4 GEMM kernels on AMD Instinct™ MI350 GPUs.\n\n## References[#](#references)\n\n[1] [FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev) — Black Forest Labs’ open-weights diffusion transformer for text-to-image generation\n\n[2] [AMD Quark](https://github.com/amd/quark) — A cross-platform deep learning quantization toolkit\n\n[3] [xDiT](https://github.com/xdit-project/xDiT) — Inference engine for diffusion transformers with parallelism support\n\n[4] [AITER](https://github.com/ROCm/aiter) — AI Tensor Engine for ROCm\n\n[5] [Diffusers](https://github.com/huggingface/diffusers) — Hugging Face library for state-of-the-art diffusion models\n\n[6] [OCP Microscaling Formats (MX) Specification](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf) — Open Compute Project standard for block-scaled low-precision formats\n\n[7] [CLIP Score](https://github.com/openai/CLIP) — Text-image alignment metric based on OpenAI’s CLIP model\n\n[8] [COCO 2017](https://cocodataset.org/) — Common Objects in Context image-caption dataset\n\n## Disclaimers[#](#disclaimers)\n\nThird-party content is licensed to you directly by the third party that owns the content and is not licensed to you by AMD. ALL LINKED THIRD-PARTY CONTENT IS PROVIDED “AS IS” WITHOUT A WARRANTY OF ANY KIND. USE OF SUCH THIRD-PARTY CONTENT IS DONE AT YOUR SOLE DISCRETION AND UNDER NO CIRCUMSTANCES WILL AMD BE LIABLE TO YOU FOR ANY THIRD-PARTY CONTENT. YOU ASSUME ALL RISK AND ARE SOLELY RESPONSIBLE FOR ANY DAMAGES THAT MAY ARISE FROM YOUR USE OF THIRD-PARTY CONTENT.\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.\n\nHowever, 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.\n\nTHIS 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.\n\nAMD, the AMD Arrow logo, ROCm, Instinct, 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/accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on", "canonical_source": "https://rocm.blogs.amd.com/artificial-intelligence/quark-xdit/README.html", "published_at": "2026-07-06 00:00:00+00:00", "updated_at": "2026-07-07 01:03:13.184954+00:00", "lang": "en", "topics": ["machine-learning", "ai-infrastructure", "ai-tools", "generative-ai"], "entities": ["AMD", "AMD Instinct MI350", "AMD Quark", "Diffusers", "xDiT", "FLUX.1-dev", "Black Forest Labs", "AITER"], "alternates": {"html": "https://wpnews.pro/news/accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on", "markdown": "https://wpnews.pro/news/accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on.md", "text": "https://wpnews.pro/news/accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on.txt", "jsonld": "https://wpnews.pro/news/accelerating-diffusers-and-xdit-image-generation-with-mxfp4-using-amd-quark-on.jsonld"}}