Release calibrated Image2.1 NVFP4 transformer with dynamic scaling and BF16 rank correction, native SM120 runtime, quality evidence and real-time demo

.gitattributes

@@ -33,3 +33,52 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/00.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/01.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/02.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/03.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/04.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/05.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/06.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/07.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/08.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/09.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/11.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/12.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/14.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/15.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/edit-0.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/evaluation-dynamic/edit-1.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/heldout-nvfp4/00.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/heldout-nvfp4/02.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/heldout-nvfp4/03.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/heldout-nvfp4/04.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/heldout-nvfp4/05.jpg filter=lfs diff=lfs merge=lfs -text
+comparisons/heldout-nvfp4/07.jpg filter=lfs diff=lfs merge=lfs -text
+demo/realtime-30s.mp4 filter=lfs diff=lfs merge=lfs -text
+samples/heldout/00.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/01.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/02.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/03.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/04.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/05.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/06.png filter=lfs diff=lfs merge=lfs -text
+samples/heldout/07.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/00.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/01.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/02.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/03.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/04.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/05.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/06.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/07.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/08.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/09.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/10.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/11.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/12.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/13.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/14.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/15.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/edit-0.png filter=lfs diff=lfs merge=lfs -text
+samples/validation/edit-1.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,55 @@
+Qwen RESEARCH LICENSE AGREEMENT
+
+Qwen RESEARCH LICENSE AGREEMENT Release Date: September 20, 2026
+
+By clicking to agree or by using or distributing any portion or element of the Qwen Materials, you will be deemed to have recognized and accepted the content of this Agreement, which is effective immediately.
+
+1. Definitions
+    a. This Qwen RESEARCH LICENSE AGREEMENT (this "Agreement") shall mean the terms and conditions for use, reproduction, distribution and modification of the Materials as defined by this Agreement.
+    b. "We" (or "Us") shall mean Hangzhou Tongyi Laboratory Technology Co., Ltd.
+    c. "You" (or "Your") shall mean a natural person or legal entity exercising the rights granted by this Agreement and/or using the Materials for any purpose and in any field of use.
+    d. "Third Parties" shall mean individuals or legal entities that are not under common control with us or you.
+    e. "Qwen" shall mean the large language models, diffusion models, and software and algorithms, consisting of trained model weights, parameters (including optimizer states), machine-learning model code, inference-enabling code, training-enabling code, fine-tuning enabling code and other elements of the foregoing distributed by us.
+    f. "Materials" shall mean, collectively, our proprietary Qwen and Documentation (and any portion thereof) made available under this Agreement.
+    g. "Source" form shall mean the preferred form for making modifications, including but not limited to model source code, documentation source, and configuration files.
+    h. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+    i. "Non-Commercial" shall mean for research or evaluation purposes only.
+
+2. Grant of Rights
+    a. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under our intellectual property or other rights owned by us embodied in the Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Materials FOR NON-COMMERCIAL PURPOSES ONLY. 
+    b. You shall not use the Materials for any commercial purpose without obtaining a separate commercial license from us. If you wish to use the Materials commercially, you shall request a license from us at model-business@notice.qwencloud.com.
+
+3. Redistribution
+Subject to Section 2 (Grant of Rights), you may distribute copies or make the Materials, or derivative works thereof, available as part of a product or service that contains any of them, with or without modifications, and in Source or Object form, provided that you meet the following conditions:
+    a. You shall give any other recipients of the Materials or derivative works a copy of this Agreement;
+    b. You shall cause any modified files to carry prominent notices stating that you changed the files;
+    c. You shall retain in all copies of the Materials that you distribute the following attribution notices within a "Notice" text file distributed as a part of such copies: "Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c) 2026 Hangzhou Tongyi Laboratory Technology Co., Ltd. All Rights Reserved."; and
+    d. You may add your own copyright statement to your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of your modifications, or for any such derivative works as a whole, provided your use, reproduction, and distribution of the work otherwise complies with the terms and conditions of this Agreement.
+
+4. Rules of use
+    a. The Materials may be subject to export controls or restrictions in China, the United States or other countries or regions. You shall comply with applicable laws and regulations in your use of the Materials.
+    b. If you use the Materials or any outputs or results therefrom to create, train, fine-tune, or improve an AI model that is distributed or made available, you shall prominently display “Built with Qwen” or “Improved using Qwen” in the related product documentation.
+    c. You shall not use "Qwen" as the primary name or identifier of any derivative works or products; reasonable descriptive use (e.g., "fine-tuned from Qwen Image") is permitted.
+
+5. Intellectual Property
+    a. We retain ownership of all intellectual property rights in and to the Materials and derivatives made by or for us. Conditioned upon compliance with the terms and conditions of this Agreement, with respect to any derivative works and modifications of the Materials that are made by you, you are and will be the owner of such derivative works and modifications.
+    b. No trademark license is granted to use the trade names, trademarks, service marks, or product names of us, except as required to fulfill notice requirements under this Agreement or as required for reasonable and customary use in describing and redistributing the Materials.
+    c. If you commence a lawsuit or other proceedings (including a cross-claim or counterclaim in a lawsuit) against us or any entity alleging that the Materials or any output therefrom, or any part of the foregoing, infringe any intellectual property or other right owned or licensable by you, then all licenses granted to you under this Agreement shall terminate as of the date such lawsuit or other proceeding is commenced or brought.
+
+6. Disclaimer of Warranty and Limitation of Liability
+    a. We are not obligated to support, update, provide training for, or develop any further version of the Qwen Materials or to grant any license thereto.
+    b. THE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY OF ANY KIND INCLUDING WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. WE MAKE NO WARRANTY AND ASSUME NO RESPONSIBILITY FOR THE SAFETY OR STABILITY OF THE MATERIALS AND ANY OUTPUT THEREFROM.
+    c. IN NO EVENT SHALL WE BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE MATERIALS OR ANY OUTPUT OF IT, NO MATTER HOW IT’S CAUSED.
+    d. You will defend, indemnify and hold harmless us from and against any claim by any third party arising out of or related to your use or distribution of the Materials.
+
+7. Survival and Termination.
+    a. The term of this Agreement shall commence upon your acceptance of this Agreement or access to the Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein.
+    b. We may terminate this Agreement if you breach any of the terms or conditions of this Agreement. Upon termination of this Agreement, you must delete and cease use of the Materials. Sections 6 and 8 shall survive the termination of this Agreement.
+
+8. Governing Law and Jurisdiction.
+    a. This Agreement and any dispute arising out of or relating to it will be governed by the laws of China, without regard to conflict of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement.
+    b. The People's Courts in Hangzhou City shall have exclusive jurisdiction over any dispute arising out of this Agreement.
+
+9. Other Terms and Conditions.
+    a. Any arrangements, understandings, or agreements regarding the Material not stated herein are separate from and independent of the terms and conditions of this Agreement. You shall request a separate license from us, if you use the Materials in ways not expressly agreed to in this Agreement. 
+    b. We shall not be bound by any additional or different terms or conditions communicated by you unless expressly agreed.

Notice

@@ -0,0 +1,4 @@
+Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c) 2026 Hangzhou Tongyi Laboratory Technology Co., Ltd. All Rights Reserved.
+
+Built with Qwen.
+ProCreations modified the original BF16 transformer through calibrated NVFP4 quantization with BF16 low-rank corrections and dynamic activation scaling on 2026-09-20. The custom runtime and calibration/evaluation scripts were added by ProCreations. Non-commercial research and evaluation under the included upstream license.

README.md

@@ -0,0 +1,86 @@
+---
+license: other
+license_name: qwen-research
+license_link: LICENSE
+base_model: Qwen/Qwen-Image-2.1
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- nvfp4
+- svdquant
+- blackwell
+- sm120
+- image-editing
+---
+# Image 2.1 Calibrated NVFP4
+
+Built with Qwen. A calibrated NVFP4 transformer derived from `Qwen/Qwen-Image-2.1` at revision `b3179ad355be050328e483a9dfdd9e60cd62adfa`.
+
+**4.87 GB transformer; native SM120 W4A4 Tensor Core kernels; all 40 denoising steps.** Encoder, VAE, attention, conditioning and small projections retain BF16. Each of 224 large projections uses NVFP4 plus a BF16 rank-128 correction, accumulated together in FP32. This is a custom Diffusers/FlashInfer format and requires the included loader.
+
+## Measured speed
+
+RTX PRO 6000 Blackwell Workstation 96 GB, batch 1, CFG 1, prefix KV cache. Mean CUDA-synchronized wall time includes text encoding, all denoising and VAE decoding. Loading, one full warmup per resolution, compilation and PNG writing are excluded. NVFP4 uses five measured 1024 runs and three 2048 runs; fresh FP8 controls use two per resolution in the same clean environment.
+
+| Resolution | This NVFP4 | Fresh optimized FP8 control | Speedup |
+|---|---:|---:|---:|
+| 1024 × 1024 | 4.589 s/image | 5.910 s/image | 1.29× |
+| 2048 × 2048 | 32.658 s/image | 37.214 s/image | 1.14× |
+
+Earlier BF16 measurements on this workstation with the same generation settings were 9.792 and 55.169 seconds respectively. These are historical controls from the same project, not newly timed in this release. First-use loading and compilation cost extra; full warmup times are in [benchmark.json](reports/benchmark.json). Performance depends on resolution and prompt. No steps are skipped, no approximate feature reuse is used, and attention is not quantized.
+
+The [30-second real-time video](demo/realtime-30s.mp4) has no text, overlays or audio. It begins with one completed warmup image, then displays actual newly completed generations with all waits preserved. The [capture log](demo/capture_receipt.json) records every display update and frame timestamp.
+
+## Quality and calibration
+
+Calibration uses 64 original BF16 trajectories: 56 text-to-image and eight edits, with 1024, 2048 and alternate aspect ratios. Each projection has 1,536 sampled activation rows across six denoising timesteps; 384 stratified fit rows and 384 disjoint diagnostic rows. Five smoothing exponents and two weight-scale methods are searched using native FP4 kernels. Weight-scale refinement searches 15 per-block scale factors, weighted by activation second moments. Rank-128 SVD corrections absorb dominant weight components. Original BF16 weights are the source; this is not a requantization of FP8.
+
+Activations use a **fresh actual tensor-wide amax on every call**, followed by dynamic E4M3 scales per 16 values. Sparse calibration alone missed rare large activations; static activation ranges caused clipping and visible texture degradation, so that candidate was rejected. The final runtime recalibrates and evaluates with dynamic scaling. BF16 correction weights are rescaled consistently when the activation global scale changes.
+
+The 18-case development validation set includes 16 generation prompts and two edits. Against BF16, mean LPIPS(AlexNet,512px) is **0.122970**, SSIM **0.897363**, and full-latent cosine **0.976903**. Eight additional prompts were frozen after candidate selection; their mean LPIPS is **0.124012** and SSIM **0.871713**. Full images, paired comparisons and individual measurements are included.
+
+**This is lossy quantization, not a zero-quality-loss guarantee.** All 26 pairs were visually reviewed. The corrected candidate preserves readable primary English/Chinese text, transparency, image editing, fine felt/fur textures and plausible hands in these tests. Same-seed composition, poses, decorative marks, geometry and fine detail can change; the largest validation differences are the pottery and train scenes. The prior calibrated FP8 release is closer to BF16 numerically (original 18-case mean LPIPS 0.03447). Fidelity metrics do not establish broad human preference or guarantee every prompt.
+
+## Native FP4 evidence
+
+An actual denoising-step profile records **224 SM120 block-scaled `f4E2M1FN` GEMM launches**, 32 native BF16 FlashAttention launches and 40 transformer calls per 40-step generation. Packed E2M1 values and E4M3 scale layouts were independently decoded and checked against FP32 matrix products. See [kernel evidence](reports/kernel_evidence.json) and [numerical verification](reports/native-math-verification.json).
+
+The engine uses [FlashInfer NVFP4 SVDQuant](https://docs.flashinfer.ai/generated/flashinfer.gemm.mm_nvfp4_svdquant.html), pinned to commit `975f90583d9ac8896db14cf0f26e99a853c2f136`. PyPI 0.6.18 lacked the SM120 fusion shown in the online documentation during development, so use the pinned source revision. Generic Transformers FP8/FP4 loading does not select this custom runtime.
+
+## Install and generate
+
+Tested on Linux x86_64, Python 3.12, Torch 2.14.0+cu130, CUDA toolkit 13.3, driver 615.71.09, compute capability 12.0. Other hardware is unverified. Download this repository, then run `bash install.sh` from its directory. The script installs pinned dependencies and the pinned FlashInfer source; a recent NVIDIA driver and CUDA toolkit must already be available.
+
+```bash
+.venv/bin/python generate.py --prompt 'A kingfisher on a mossy branch, detailed feathers, no text' --width 1024 --height 1024 --steps 40 --warmup --output kingfisher.png
+```
+
+`--base /path/to/local/original-model` reuses a local upstream checkpoint. Otherwise the loader downloads the pinned upstream components. `--image input.png` enables editing. `--prompts-json prompts.json` accepts a JSON list and reuses the loaded pipeline. `--eager` disables block compilation. Warmup and loading costs are reported separately; without warmup the reported generation time includes any compilation on that call.
+
+```python
+from nvfp4_runtime import load_pipeline
+from acceleration import accelerate_pipeline
+pipe = accelerate_pipeline(load_pipeline('Qwen/Qwen-Image-2.1', './transformer'))
+image = pipe(prompt='A detailed watercolor garden', width=1024, height=1024, num_inference_steps=40).images[0]
+image.save('garden.png')
+```
+
+Do not cast the loaded quantized transformer with `.to(dtype=...)`; packed values and FP32 scales must retain their stored types. The normal loader handles device placement. The checkpoint is not a generic Transformers, ComfyUI, TensorRT or Nunchaku checkpoint.
+
+## Reproduce calibration
+
+Download the exact BF16 upstream revision to a local directory first. The generation runtime environment also supports calibration. From this release directory:
+
+```bash
+export IMAGE21_BASE=/absolute/path/to/original-model
+export IMAGE21_WORK_DIR="$PWD/rebuild"
+export PYTHONPATH="$PWD"
+.venv/bin/python source/collect_calibration.py
+.venv/bin/python source/quantize_dynamic.py
+```
+
+The first command collects the published 64-case calibration manifest; the second reconstructs the NVFP4 transformer under `rebuild/release/transformer`. Original fitting activations are retained on the build workstation and can be regenerated with these scripts. Evaluation additionally needs LPIPS, scikit-image and SciPy; video capture uses imageio-ffmpeg. [Environment versions](reports/environment.json), source, calibration search, manifests and timing records are included. Earlier static-range, mixed-precision, ridge-correction, kernel-autotuning and CUDA-graph experiments were rejected or provided no useful gain; they are not enabled in this runtime.
+
+## License and modification notice
+
+Built with Qwen. ProCreations modified the original transformer through calibrated NVFP4 quantization and supplied this custom inference runtime on 2026-09-20. This derivative is distributed under the included [Qwen Research License](LICENSE) and [Notice](Notice), for non-commercial research/evaluation. Preserve those files and the upstream terms when redistributing. This is an independent derivative, not an official Qwen release.

acceleration.py

@@ -0,0 +1,91 @@
+"""Full-compute acceleration for Image 2.1 Calibrated NVFP4. Built with Qwen.
+
+Keeps every denoising step, BF16 attention, calibrated native FP4 GEMMs with BF16 rank correction and
+FP32 accumulation/scales. No approximate residual cache or attention quantization.
+Only cached-prefix decode blocks compile; prefill keeps upstream behavior.
+"""
+import types
+import torch
+from diffusers.models.transformers.transformer_qwenimage21 import (
+    QwenImage21AttnProcessor, QwenImage21TransformerBlock,
+)
+
+_ORIGINAL_BLOCK_FORWARD = QwenImage21TransformerBlock.forward
+
+
+def _real_rope(x, frequencies):
+    paired = x.float().unflatten(-1, (-1, 2))
+    cosine = frequencies.real[None, :, None, :]
+    sine = frequencies.imag[None, :, None, :]
+    return torch.stack((
+        paired[..., 0] * cosine - paired[..., 1] * sine,
+        paired[..., 0] * sine + paired[..., 1] * cosine,
+    ), dim=-1).flatten(-2).to(x.dtype)
+
+
+class NativeAttentionProcessor(QwenImage21AttnProcessor):
+    def __call__(self, attn, hidden_states, attention_mask=None, rotary_emb=None,
+                 layer_cache=None, kv_cache_mode=None, cache_write_slice=None,
+                 segments=None, key_valid=None):
+        if kv_cache_mode != 'cached' or attention_mask is not None:
+            return super().__call__(attn, hidden_states, attention_mask, rotary_emb,
+                                    layer_cache, kv_cache_mode, cache_write_slice,
+                                    segments, key_valid)
+        query = attn.to_q(hidden_states).unflatten(-1, (attn.heads, -1))
+        key = attn.to_k(hidden_states).unflatten(-1, (attn.heads, -1))
+        value = attn.to_v(hidden_states).unflatten(-1, (attn.heads, -1))
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+        if rotary_emb is not None:
+            query = _real_rope(query, rotary_emb)
+            key = _real_rope(key, rotary_emb)
+        cached_key, cached_value = layer_cache.get()
+        key = torch.cat((cached_key, key), dim=1)
+        value = torch.cat((cached_value, value), dim=1)
+        output = torch.nn.functional.scaled_dot_product_attention(
+            query.transpose(1, 2), key.transpose(1, 2), value.transpose(1, 2)
+        ).transpose(1, 2)
+        return attn.to_out[1](attn.to_out[0](output.flatten(2, 3)))
+
+
+def _decode_block(self, hidden_states, modulation, rotary_emb=None,
+                  attention_mask=None, target_token_mask=None, layer_cache=None,
+                  kv_cache_mode=None, cache_write_slice=None, segments=None,
+                  key_valid=None):
+    # Cached decode contains only target image tokens. The final t=0 modulation
+    # row belongs to the prefix, which was already evaluated during prefill.
+    if kv_cache_mode == 'cached':
+        modulation = modulation[:-1]
+        target_token_mask = None
+    return _ORIGINAL_BLOCK_FORWARD(
+        self, hidden_states, modulation, rotary_emb, attention_mask,
+        target_token_mask, layer_cache, kv_cache_mode, cache_write_slice,
+        segments, key_valid,
+    )
+
+
+def _dispatch_block(self, **kwargs):
+    if kwargs.get('kv_cache_mode') == 'cached':
+        return self._image21_compiled(**kwargs)
+    return _ORIGINAL_BLOCK_FORWARD(self, **kwargs)
+
+
+def accelerate_pipeline(pipe):
+    """Enable once after loading. Initial compilation is excluded from warm timings.
+
+    Dynamic sequence lengths reduce recompilation across prompts/resolutions.
+    emulate_precision_casts preserves the upstream intermediate BF16 rounding
+    boundaries in fused code; GPU reduction ordering can still differ.
+    """
+    if getattr(pipe, '_image21_accelerated', False):
+        return pipe
+    torch._dynamo.config.recompile_limit = max(torch._dynamo.config.recompile_limit, 64)
+    for block in pipe.transformer.transformer_blocks:
+        block.attn.set_processor(NativeAttentionProcessor())
+        block._image21_compiled = torch.compile(
+            types.MethodType(_decode_block, block), fullgraph=True, dynamic=True,
+            options={'emulate_precision_casts': True},
+        )
+        block.forward = types.MethodType(_dispatch_block, block)
+    pipe._image21_accelerated = True
+    return pipe

demo/realtime-30s.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7585d0c1e7618d2fb710ebf08f70541d36d88ac49152bfcbd4f10d093ae9ca94
+size 2301594

dynamic_scale.py

@@ -0,0 +1,29 @@
+"""Dynamic tensor-wide NVFP4 range, with FP32 reductions and correction rescaling."""
+import torch,triton
+import triton.language as tl
+@triton.jit
+def _partials(X,P,T,COUNT:tl.constexpr,K:tl.constexpr,B:tl.constexpr):
+ i=tl.program_id(0)*B+tl.arange(0,B)
+ x=tl.load(X+i,i<COUNT,0).to(tl.float32)
+ p=tl.load(P+i%K).to(tl.float32)
+ tl.store(T+tl.program_id(0),tl.max(tl.abs(x*p),0))
+@triton.jit
+def _finish(T,OLDG,OLDA,G,A,R,N:tl.constexpr,B:tl.constexpr):
+ i=tl.arange(0,B);v=tl.load(T+i,i<N,0)
+ g=2688./tl.maximum(tl.max(v,0),1.e-12)
+ oldg=tl.load(OLDG);olda=tl.load(OLDA)
+ tl.store(G,g);tl.store(A,olda*oldg/g);tl.store(R,g/oldg)
+@triton.jit
+def _upscale(U,R,V,N:tl.constexpr,B:tl.constexpr):
+ i=tl.program_id(0)*B+tl.arange(0,B)
+ u=tl.load(U+i,i<N,0).to(tl.float32);r=tl.load(R)
+ tl.store(V+i,u*r,i<N)
+def scale(x,pre,gx,alpha,up):
+ count=x.numel();blocks=triton.cdiv(count,16384)
+ partial=torch.empty(blocks,device=x.device,dtype=torch.float32)
+ g=torch.empty_like(gx);a=torch.empty_like(alpha);r=torch.empty_like(gx)
+ _partials[(blocks,)](x,pre,partial,count,x.shape[-1],16384,num_warps=8)
+ _finish[(1,)](partial,gx,alpha,g,a,r,blocks,triton.next_power_of_2(blocks),num_warps=8)
+ u=torch.empty_like(up)
+ _upscale[(triton.cdiv(up.numel(),1024),)](up,r,u,up.numel(),1024)
+ return g,a,u

fp8_runtime.py

@@ -0,0 +1,104 @@
+"""Calibrated W8A8 E4M3 inference using native CUTLASS SM120 scaled GEMMs.
+
+Built with Qwen. Quantization modifications by ProCreations, 2026.
+The upstream model is subject to the included Qwen Research License.
+"""
+import json
+from pathlib import Path
+import torch
+from torch import nn
+import triton
+import triton.language as tl
+from safetensors.torch import load_file
+
+
+@triton.jit
+def _quantize_rows(X, SMOOTH, Q, SCALE, K: tl.constexpr, BLOCK: tl.constexpr):
+    row = tl.program_id(0)
+    cols = tl.arange(0, BLOCK)
+    x = tl.load(X + row * K + cols, cols < K, 0).to(tl.float32)
+    s = tl.load(SMOOTH + cols, cols < K, 1).to(tl.float32)
+    z = x / s
+    scale = tl.maximum(tl.max(tl.abs(z), 0) / 448.0, 1.e-12)
+    tl.store(Q + row * K + cols, z / scale, cols < K)
+    tl.store(SCALE + row, scale)
+
+
+def quantize_activation(x, smooth):
+    x = x.reshape(-1, x.shape[-1]).contiguous()
+    q = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    scale = torch.empty((x.shape[0], 1), device=x.device, dtype=torch.float32)
+    _quantize_rows[(x.shape[0],)](x, smooth, q, scale, x.shape[1],
+                                triton.next_power_of_2(x.shape[1]), num_warps=8)
+    return q, scale
+
+
+class CalibratedFP8Linear(nn.Module):
+    def __init__(self, weight, scale, smooth):
+        super().__init__()
+        self.register_buffer("weight", weight)
+        self.register_buffer("weight_scale", scale.float())
+        self.register_buffer("smooth", smooth.float())
+        self.in_features = weight.shape[1]
+        self.out_features = weight.shape[0]
+        self.bias = None
+
+    def forward(self, x):
+        shape = x.shape[:-1]
+        q, scale = quantize_activation(x, self.smooth)
+        y = torch._scaled_mm(q, self.weight.t(), scale_a=scale,
+                             scale_b=self.weight_scale.t(),
+                             out_dtype=torch.bfloat16, use_fast_accum=False)
+        return y.reshape(*shape, self.out_features)
+
+
+def eligible_modules(model):
+    return {n:m for n,m in model.named_modules()
+            if isinstance(m, nn.Linear) and n.startswith("transformer_blocks.")
+            and m.bias is None}
+
+
+def replace_module(root, name, replacement):
+    parent_name, leaf = name.rsplit(".", 1)
+    setattr(root.get_submodule(parent_name), leaf, replacement)
+
+
+def load_fp8_transformer(directory, device="cuda"):
+    from diffusers import QwenImage21Transformer2DModel
+    directory = Path(directory)
+    config = json.loads((directory / "config.json").read_text())
+    meta = json.loads((directory / "quantization_config.json").read_text())
+    # Construct without allocating an intermediate BF16 model.
+    with torch.device("meta"):
+        model = QwenImage21Transformer2DModel.from_config(config)
+        for n, spec in meta["quantized_modules"].items():
+            out_f, in_f = spec["shape"]
+            replace_module(model, n, CalibratedFP8Linear(
+                torch.empty((out_f,in_f),dtype=torch.float8_e4m3fn),
+                torch.empty((out_f,1),dtype=torch.float32),
+                torch.empty(in_f,dtype=torch.float32)))
+    state = {}
+    for path in sorted(directory.glob("model-*.safetensors")):
+        state.update(load_file(str(path), device="cpu"))
+    model.load_state_dict(state, strict=True, assign=True)
+    # The original rotary module has nonpersistent buffers / Python tensor lists.
+    # Reconstruct these by creating a lightweight ordinary position module.
+    from diffusers.models.transformers.transformer_qwenimage21 import QwenImage21Rope
+    model.pos_embed = QwenImage21Rope(theta=10000, axes_dim=list(model.config.axes_dims_rope))
+    from diffusers.models.transformers.transformer_qwenimage21 import QwenImage21TemporalTimesteps
+    model.time_text_embed.time_proj = QwenImage21TemporalTimesteps(timestep_dim=256)
+    return model.eval().to(device=device)
+
+
+def load_pipeline(base, quant=None):
+    from diffusers import QwenImage21Pipeline
+    args = {}
+    if not Path(base).exists():
+        args["revision"] = "b3179ad355be050328e483a9dfdd9e60cd62adfa"
+    if quant:
+        args["transformer"] = load_fp8_transformer(quant, device="cuda")
+    pipe = QwenImage21Pipeline.from_pretrained(base, torch_dtype=torch.bfloat16, **args)
+    # Do not call pipe.to(dtype=...) after FP8 loading; scales are FP32.
+    pipe.to(device="cuda")
+    pipe.set_progress_bar_config(disable=True)
+    return pipe

generate.py

@@ -0,0 +1,54 @@
+"""Generate with Image 2.1 Calibrated NVFP4. Built with Qwen."""
+import argparse, json, time
+from pathlib import Path
+import torch
+from nvfp4_runtime import load_pipeline
+
+@torch.inference_mode()
+def main():
+    ap=argparse.ArgumentParser()
+    inputs=ap.add_mutually_exclusive_group(required=True)
+    inputs.add_argument('--prompt')
+    inputs.add_argument('--prompts-json', help='JSON list of prompt strings; one loaded pipeline serves the whole list')
+    ap.add_argument('--base',default='Qwen/Qwen-Image-2.1')
+    ap.add_argument('--quant',default=str(Path(__file__).parent/'transformer'))
+    ap.add_argument('--width',type=int,default=2048)
+    ap.add_argument('--height',type=int,default=2048)
+    ap.add_argument('--steps',type=int,default=40)
+    ap.add_argument('--seed',type=int,default=42)
+    ap.add_argument('--output',default='output.png')
+    ap.add_argument('--image')
+    ap.add_argument('--eager', action='store_true', help='Use the original uncompiled runtime')
+    ap.add_argument('--warmup', action='store_true', help='Run a full untimed warmup; report its cost separately')
+    args=ap.parse_args()
+    prompts=json.loads(Path(args.prompts_json).read_text()) if args.prompts_json else [args.prompt]
+    if not isinstance(prompts,list) or not prompts or not all(isinstance(p,str) and p for p in prompts):
+        ap.error('prompts-json must contain a nonempty list of prompt strings')
+    start=time.perf_counter();pipe=load_pipeline(args.base,args.quant)
+    if not args.eager:
+        from acceleration import accelerate_pipeline
+        accelerate_pipeline(pipe)
+    torch.cuda.synchronize();load_seconds=time.perf_counter()-start
+    kw={}
+    if args.image:
+        from PIL import Image
+        kw['image']=Image.open(args.image)
+    def run(prompt,seed):
+        return pipe(prompt=prompt,width=args.width,height=args.height,num_inference_steps=args.steps,
+                    generator=torch.Generator('cuda').manual_seed(seed),**kw).images[0]
+    warmup_seconds=0
+    if args.warmup:
+        start=time.perf_counter();run(prompts[0],args.seed);torch.cuda.synchronize()
+        warmup_seconds=time.perf_counter()-start
+    path=Path(args.output);path.parent.mkdir(parents=True,exist_ok=True)
+    for i,prompt in enumerate(prompts):
+        torch.cuda.synchronize();start=time.perf_counter();result=run(prompt,args.seed+i)
+        torch.cuda.synchronize();seconds=time.perf_counter()-start
+        destination=path if len(prompts)==1 else path.with_name(f'{path.stem}-{i:03d}{path.suffix or ".png"}')
+        result.save(destination)
+        print(json.dumps({'seconds':seconds,'output':str(destination),'width':result.width,'height':result.height,
+                          'steps':args.steps,'eager':args.eager,'load_seconds':load_seconds,
+                          'warmup_seconds':warmup_seconds,
+                          'timing_note':'Generation includes any compilation on this call; excludes model load and PNG writing.'}),flush=True)
+
+if __name__=='__main__':main()

install.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Run from the downloaded release directory on Linux x86_64 / SM120.
+set -euo pipefail
+python3.12 -m venv .venv
+.venv/bin/python -m pip install --upgrade pip
+.venv/bin/python -m pip install torch==2.14.0 torchvision==0.29.0 --index-url https://download.pytorch.org/whl/cu130
+.venv/bin/python -m pip install -r requirements.txt
+git clone https://github.com/flashinfer-ai/flashinfer.git flashinfer-src
+git -C flashinfer-src checkout 975f90583d9ac8896db14cf0f26e99a853c2f136
+git -C flashinfer-src submodule update --init --depth 1 3rdparty/cutlass 3rdparty/cccl 3rdparty/spdlog
+BUILD_NVEP=0 .venv/bin/python -m pip install --no-deps ./flashinfer-src
+.venv/bin/python -m pip check

manifest.json

@@ -0,0 +1,510 @@
+{
+  "files": [
+    {
+      "path": "LICENSE",
+      "bytes": 7831,
+      "sha256": "8dc973f024ff95966bea25866efa443fd16776dcb1001e681e3d467ea572b28d"
+    },
+    {
+      "path": "Notice",
+      "bytes": 491,
+      "sha256": "c517ea86da1c4b8f3f659944f5e7b5a66128fe024af5d64655b6a1c2ade6ae65"
+    },
+    {
+      "path": "README.md",
+      "bytes": 8107,
+      "sha256": "d849e2126e39ff5d1586de3a17995afc2358b47ade44dda7dd1bdb15f91cea8f"
+    },
+    {
+      "path": "acceleration.py",
+      "bytes": 4157,
+      "sha256": "a5a43f98da091fb81fed8f493a736f68820d4cd1b5dc2f30e8a3f8f65659b3c8"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/00.jpg",
+      "bytes": 176056,
+      "sha256": "801c01744c1a1c5d33b5e06b9503e92cf9df1bff52e530e65bb062713f442162"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/01.jpg",
+      "bytes": 179746,
+      "sha256": "b0423321243e0f5b210ce6e32c4565f993294aa8fd89583699a3caebeded99a1"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/02.jpg",
+      "bytes": 180435,
+      "sha256": "e519b8431f20a90c6c619b91e7966dd7c638973f2b33b012ea3aabb991a738d8"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/03.jpg",
+      "bytes": 146351,
+      "sha256": "3a0138e1eb0eb79abe01ff768be4eccba5c2114488f840b8575c16b02af7b169"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/04.jpg",
+      "bytes": 182735,
+      "sha256": "51e0a532f9f4de9d65d14fd4edc543cf87b5bc35ea36e4697e42f2e3997afa52"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/05.jpg",
+      "bytes": 309805,
+      "sha256": "81fd3d157a7175fee7b108206fc5bdb44f6542cf06f42e7ee19e2ca1d79d3636"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/06.jpg",
+      "bytes": 104835,
+      "sha256": "626595f20c55ef0cbad9ac793180dc8f7bf84da82ec29c60d8b13244a9c64f40"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/07.jpg",
+      "bytes": 124166,
+      "sha256": "96259410bc3679ffa69cfef803b38af74974068467de97160defe7893b29930e"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/08.jpg",
+      "bytes": 113262,
+      "sha256": "dad753aef0935797375233f3c6d0b64c4360dfc45c4227c3d3cd72c58e64b8f3"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/09.jpg",
+      "bytes": 101923,
+      "sha256": "68a84e802c40234eb830362be6e9405c7c4f765a0ac12061864d2e8c6dd3b746"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/10.jpg",
+      "bytes": 60148,
+      "sha256": "434f2e92839951456722954e64c66f35a287a75b4416d1aad33a6362c89c15f6"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/11.jpg",
+      "bytes": 260028,
+      "sha256": "a57d36f2e4bd995fa540234dce491f209fa4524700b1ebdb0cbb8966bbbc5778"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/12.jpg",
+      "bytes": 276643,
+      "sha256": "9b35d184b7efa4ff9a3bc7abef9e4cf50d6ed99bf6967724312038e52f8e2672"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/13.jpg",
+      "bytes": 86912,
+      "sha256": "84f4bbe544f92623675f448e01710fdf8e799dbc8ed2af4674c1c6c94b00eb22"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/14.jpg",
+      "bytes": 189569,
+      "sha256": "ccdb2b7222304c5049c324750433dfa0f4862dfc3833864e90030a1a0e03d1a7"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/15.jpg",
+      "bytes": 203642,
+      "sha256": "e3586ffca8d68cebde081ef42c4e7fab7fd5c8cbe1b2531a54ee8474a07bc7a0"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/edit-0.jpg",
+      "bytes": 239945,
+      "sha256": "5747ce5f80fd014383a89ad06d0b31209612bbbe2981e5082b086819c8db720f"
+    },
+    {
+      "path": "comparisons/evaluation-dynamic/edit-1.jpg",
+      "bytes": 140013,
+      "sha256": "e93f685092a7f8729a135df81d8fc91d2f7f446e6857d03d36055e4926c820b2"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/00.jpg",
+      "bytes": 144117,
+      "sha256": "fef99d1fed7bec5ca673bf94aae5f0f534db77d474e45f04a8c6b52798b20801"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/01.jpg",
+      "bytes": 95024,
+      "sha256": "bf3c15a3f9acaaaac7deb73d89501a73a5bfe6d3dd402107deff0bef5218651f"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/02.jpg",
+      "bytes": 137218,
+      "sha256": "16c8ab16fe20d594d46ad396ed4c415690f2c3082ac4287b080806a435d82fb3"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/03.jpg",
+      "bytes": 105496,
+      "sha256": "907a7a68a36afc83d506442e84a538e0bab1af77582fb76b067809685df15e20"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/04.jpg",
+      "bytes": 142102,
+      "sha256": "7abc30394201e4f7e1456f06df38ab6b492ffbf3a869ab5d9decc70231312667"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/05.jpg",
+      "bytes": 203606,
+      "sha256": "db68b9fa5e5ce3453fbe74d569b051274f300106d6c3aecd60996418f52ed86b"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/06.jpg",
+      "bytes": 95263,
+      "sha256": "194e2d5bafe9ef00fae0f62f891125169c4b79f379bb582b72af82eae51a351b"
+    },
+    {
+      "path": "comparisons/heldout-nvfp4/07.jpg",
+      "bytes": 134634,
+      "sha256": "9f625acf906a08a69543723a8af7254ecd4e0837101c152fb2140d894ea41371"
+    },
+    {
+      "path": "demo/capture_receipt.json",
+      "bytes": 131978,
+      "sha256": "b9e7e82391fd38f7536bc48a1ab1f0cc711a715a04b9e634679bdc4da89ab17c"
+    },
+    {
+      "path": "demo/realtime-30s.mp4",
+      "bytes": 2301594,
+      "sha256": "7585d0c1e7618d2fb710ebf08f70541d36d88ac49152bfcbd4f10d093ae9ca94"
+    },
+    {
+      "path": "dynamic_scale.py",
+      "bytes": 1288,
+      "sha256": "d908cd50c73cbdf40133775460fe599278fd6d2e7d10648782798d6dfbbbbd7b"
+    },
+    {
+      "path": "fp8_runtime.py",
+      "bytes": 4376,
+      "sha256": "5892e8b5963f66fee67c16dd3996e05b4b64297e570f3115630a19b224d69413"
+    },
+    {
+      "path": "generate.py",
+      "bytes": 3007,
+      "sha256": "b383aa9a93d7980ba1b2b74eb6bd7f1accb9c1651c4e468c319fd48608ac42ea"
+    },
+    {
+      "path": "install.sh",
+      "bytes": 697,
+      "sha256": "8fff3b147208b3651fcc71d7b09ded4674769e4321d840a7871a412298d0be7a"
+    },
+    {
+      "path": "nvfp4_runtime.py",
+      "bytes": 3972,
+      "sha256": "86fbf7003b755f824b35bf2370feab2f360c79ee4683e4f79267fb7db1e307d7"
+    },
+    {
+      "path": "reports/benchmark.json",
+      "bytes": 1158,
+      "sha256": "c0ef7fbedaf7b976dab4fc623130fe8e09838b1b0f7147d27d9b367524172c98"
+    },
+    {
+      "path": "reports/calibration_manifest.json",
+      "bytes": 29336,
+      "sha256": "e067532fc1e6779e22cac2c2beb2bbf4840cd4252aba0da142c5b37f5f97024a"
+    },
+    {
+      "path": "reports/calibration_search.json",
+      "bytes": 378392,
+      "sha256": "8b71f8e6d43303f3341b4c08e10652dad8c1585f31bf0d0a77dee9a55db8381b"
+    },
+    {
+      "path": "reports/correction-probe.json",
+      "bytes": 2835,
+      "sha256": "5a3f2d003e8c7c5ab928260b56b12add38bc94d7f7e25ab00fb3b3fddcafcdce"
+    },
+    {
+      "path": "reports/cudagraph-trial.json",
+      "bytes": 218,
+      "sha256": "9e16d5dc46a1a580ea2dac0e7eec8655c18a8a313870a160e6b091b56a96b4d2"
+    },
+    {
+      "path": "reports/earlier-bf16-benchmark.json",
+      "bytes": 1031,
+      "sha256": "640be194397d85b94022b5a960141c92e3f65de30d98d2586bc466b5df8beb7c"
+    },
+    {
+      "path": "reports/environment.json",
+      "bytes": 2884,
+      "sha256": "c375ec1b13547ee0ee2ff0f9a67a9de1d2fd8c47aaa92f3f6de31731c5994af7"
+    },
+    {
+      "path": "reports/evaluation-environment.json",
+      "bytes": 161,
+      "sha256": "727e74ca45de746f0efa9f78dec96ac8ebc925b92dfddaf1e7e4da812b9cd583"
+    },
+    {
+      "path": "reports/fresh-fp8-benchmark.json",
+      "bytes": 913,
+      "sha256": "4194b2a3b646711daa393474b9bb911900d65cf2d792fe224e5ab619ff5470fb"
+    },
+    {
+      "path": "reports/heldout-manifest.json",
+      "bytes": 2446,
+      "sha256": "ec71f7211480de9bc445c9c44649c5811ff20b51b568c4132915bea2ac2c7f91"
+    },
+    {
+      "path": "reports/kernel_evidence.json",
+      "bytes": 24824,
+      "sha256": "1b622cd32d8e9c6524a27421a3d077d1a0df2c5512f4ff1914e336178e189e2b"
+    },
+    {
+      "path": "reports/native-math-verification.json",
+      "bytes": 765,
+      "sha256": "3ed24479ca50f9dabe5bfaa57931a6711d4a47c4eb9b493db854d35bc0495be7"
+    },
+    {
+      "path": "reports/qa-review.json",
+      "bytes": 817,
+      "sha256": "2fc1a5a431daf87ea5e3e3ff2bdcc85239dc2d08ce1ecc18b903815846d8deb3"
+    },
+    {
+      "path": "reports/quality_metrics-bf16.json",
+      "bytes": 5502,
+      "sha256": "bb644a0dd2aef533c0d9896c52e5a0fcaf376fb4acb433474c62a0367f9e126c"
+    },
+    {
+      "path": "reports/quality_metrics-fp8.json",
+      "bytes": 5501,
+      "sha256": "99ba88af5444d308e278e94a207ee3c4443faff1e8f321d4e0f304270faa8678"
+    },
+    {
+      "path": "reports/quality_metrics-heldout-bf16.json",
+      "bytes": 2880,
+      "sha256": "849cfd94a16b602554644bbae1b569111527be909f0004bc16e64e07a107f5cc"
+    },
+    {
+      "path": "reports/quantization_summary.json",
+      "bytes": 715,
+      "sha256": "ece079fec55b6864a777541a5d959ace269f2a366963890cea957d87b9291c91"
+    },
+    {
+      "path": "reports/release-cli-smoke.json",
+      "bytes": 319,
+      "sha256": "a0c67c3e7f108714c9be3dd33e5bc66dc8896a792ed900fd45e4766d75cb74ac"
+    },
+    {
+      "path": "reports/tuning-results.json",
+      "bytes": 1035,
+      "sha256": "bc3e79a8cc7cc99759e58cd9640f1b3eb9c39cbdbd96b44dfc8d269435d8c0e2"
+    },
+    {
+      "path": "reports/video-verification.json",
+      "bytes": 1981,
+      "sha256": "45a15cb8d97bd795cf7e3bb62143d5725feb9a362d75cb5d28f9907320898cb3"
+    },
+    {
+      "path": "requirements.txt",
+      "bytes": 488,
+      "sha256": "8687c948b6aeeaf3e20a013f3073f51c4235a5459767afb487191699075369cc"
+    },
+    {
+      "path": "samples/heldout/00.png",
+      "bytes": 1470245,
+      "sha256": "2ecc7ba864f3065c98c0d256fd92b74c0b068cc391f66ed0c548a3143d2191c1"
+    },
+    {
+      "path": "samples/heldout/01.png",
+      "bytes": 1144635,
+      "sha256": "298853daf5abb029ba7d715b052392c872301aa934e6482c08f0ea6a00757000"
+    },
+    {
+      "path": "samples/heldout/02.png",
+      "bytes": 1593770,
+      "sha256": "20312fb53fc29ad2c92ddfb3b2b2583dccb0b42678077dcfc4fa6613fbf35bf6"
+    },
+    {
+      "path": "samples/heldout/03.png",
+      "bytes": 1128454,
+      "sha256": "86148823326a6a8426f8317a73a2437c6eed1e665b9be9962140a065d7710694"
+    },
+    {
+      "path": "samples/heldout/04.png",
+      "bytes": 1395649,
+      "sha256": "c0c0d4d5492f443c301925508d034b88bc6102ae197e9f79e6bc646cccc299bc"
+    },
+    {
+      "path": "samples/heldout/05.png",
+      "bytes": 7047766,
+      "sha256": "63d8d2f130ddc3ff0f8946f0a7ffcfe1302a981507f2e94dc4cb0d82e4a81154"
+    },
+    {
+      "path": "samples/heldout/06.png",
+      "bytes": 800963,
+      "sha256": "ed89a263c649b8d0b260aef08eb2a7727b9557d4e0937a6d8ef992c9f8bba3c1"
+    },
+    {
+      "path": "samples/heldout/07.png",
+      "bytes": 1670613,
+      "sha256": "9536f8a08d250dc7d9c6b273e011239e20a6b38effdee3d1c20ac672f5d33bbf"
+    },
+    {
+      "path": "samples/validation/00.png",
+      "bytes": 7025357,
+      "sha256": "c3f5df94d3b2d9c2958f4c79042ae3ceca55c8dc1a22f3737f589119be8dd6ef"
+    },
+    {
+      "path": "samples/validation/01.png",
+      "bytes": 1829665,
+      "sha256": "1f50d577a9d22baff9034ddc2cb73bd47ac835e85cf43f47965146f8d223be00"
+    },
+    {
+      "path": "samples/validation/02.png",
+      "bytes": 1692847,
+      "sha256": "7d746a9909df831af3b3b6ff2de4ed76aefbdd5d9d78098d689ac0648732ff60"
+    },
+    {
+      "path": "samples/validation/03.png",
+      "bytes": 1648591,
+      "sha256": "b17cf4fd884cfe6a9c04357e170766a34c6029dcf6b1e81eae9f3fec500e5adb"
+    },
+    {
+      "path": "samples/validation/04.png",
+      "bytes": 6420433,
+      "sha256": "5be7d5c89e014c10907613f6872385d189e4a1352c4bab892130bb8745660e85"
+    },
+    {
+      "path": "samples/validation/05.png",
+      "bytes": 2458939,
+      "sha256": "317896f85a6606473ef1f7e18ae448829eb73a6bbeadda477d31ea092ca301e5"
+    },
+    {
+      "path": "samples/validation/06.png",
+      "bytes": 1341617,
+      "sha256": "1e5c2554f35b7934b0a8b27f2d85388a2316dc4307fdbd978debd22a1edeff93"
+    },
+    {
+      "path": "samples/validation/07.png",
+      "bytes": 1497363,
+      "sha256": "7dc3aec9e5bde92189dc9888658b410f44ee9a377d62f8f1be8c7b7c5b6d6418"
+    },
+    {
+      "path": "samples/validation/08.png",
+      "bytes": 3343177,
+      "sha256": "73f41a041094d8d800b37d0649a1a898fd8ebeaa0cfff3cfabcb98bab43de9c6"
+    },
+    {
+      "path": "samples/validation/09.png",
+      "bytes": 1183289,
+      "sha256": "7a1ba8598fed1f8909ae14d2e59bfc966a8a62d79933c35075abf9b4548ad3f1"
+    },
+    {
+      "path": "samples/validation/10.png",
+      "bytes": 552063,
+      "sha256": "1d571a6cc024720f63a966cc8a3105d72b3f933c7569978686b11ce3734fc3a3"
+    },
+    {
+      "path": "samples/validation/11.png",
+      "bytes": 2181491,
+      "sha256": "9cb287b21ca746a11fa9aebc2667f984e81fc8dfe95ffc5e980e68c68f3521ee"
+    },
+    {
+      "path": "samples/validation/12.png",
+      "bytes": 3164193,
+      "sha256": "96f8f77f8062b940f2300470c96b6c62663d988978a9d6cd153288e476b9f45b"
+    },
+    {
+      "path": "samples/validation/13.png",
+      "bytes": 1426920,
+      "sha256": "a66963ce46511705e0c7ad521068814fa6ae80d6dc555388c9ac860aad47cd1b"
+    },
+    {
+      "path": "samples/validation/14.png",
+      "bytes": 1772462,
+      "sha256": "74ac4c13e7adcf2bbcf595fa11699790bb233727fcd655cf3bfb0b8e3757a493"
+    },
+    {
+      "path": "samples/validation/15.png",
+      "bytes": 2000815,
+      "sha256": "2a3614b3f7c39e04c6c9c9840adfc5b60aea8823b437376421b784841618078a"
+    },
+    {
+      "path": "samples/validation/edit-0.png",
+      "bytes": 2070198,
+      "sha256": "c7f1845565b14c01e651e3b0561ec8b50b2461818754c009421d56d9d29d2e35"
+    },
+    {
+      "path": "samples/validation/edit-1.png",
+      "bytes": 1575594,
+      "sha256": "d6784ec61e127873fc3deed239b0c258887d0e99069d9df8323f4431e4245ad6"
+    },
+    {
+      "path": "source/benchmark.py",
+      "bytes": 3838,
+      "sha256": "ea305538d5bd04efb6163960ff729ab95a3e1a347dbc2ee356ddda23a24c19de"
+    },
+    {
+      "path": "source/collect_calibration.py",
+      "bytes": 3259,
+      "sha256": "41a518464980d92dab2dab9a7281a103a7baac765466f96b879319b83f24609f"
+    },
+    {
+      "path": "source/dynamic_scale.py",
+      "bytes": 1288,
+      "sha256": "d908cd50c73cbdf40133775460fe599278fd6d2e7d10648782798d6dfbbbbd7b"
+    },
+    {
+      "path": "source/evaluate.py",
+      "bytes": 2361,
+      "sha256": "d499fe31851e3898f72ff30d41b244e7a59697b77cf72231464c1311c1ac89c1"
+    },
+    {
+      "path": "source/heldout.py",
+      "bytes": 2872,
+      "sha256": "075ee0c597d32a24c5eef42cecef0f2adca404009b86162c9c2940e45a5de4c6"
+    },
+    {
+      "path": "source/probe_dynamic.py",
+      "bytes": 3484,
+      "sha256": "581b458d0bc3dd9e0cc4bdc212d7b46382094467feb2f8de24cb51eb5dc05045"
+    },
+    {
+      "path": "source/prompts.py",
+      "bytes": 9671,
+      "sha256": "626db2851c9d6266a9f397e73a5ffd04d9a8389c011860e925c0396ccf2a274f"
+    },
+    {
+      "path": "source/quality_metrics.py",
+      "bytes": 3325,
+      "sha256": "2d59b3f9e596dd111f0864ef7ea48111d66f942ec9d0e5e87f849db0cf566d9f"
+    },
+    {
+      "path": "source/quantize_dynamic.py",
+      "bytes": 4971,
+      "sha256": "7c98c0c2637e08274c4998c7379d72ff4736fbce4a961249c9a13136784807cf"
+    },
+    {
+      "path": "source/verify_native.py",
+      "bytes": 1969,
+      "sha256": "1e7743563bf25b437971fc8ef98a1e1211e95f22b96198b93b8194fe6d5dc95b"
+    },
+    {
+      "path": "source/verify_video.py",
+      "bytes": 2562,
+      "sha256": "afe6a1a2b059b015f245d6ad7de6903440415f056f44020cbb9e736ee3fb7439"
+    },
+    {
+      "path": "source/video.py",
+      "bytes": 3931,
+      "sha256": "5448b3118fd5d4dcd2a6f50afc5294cf694c6cc6e9e62177afea2de38da52f09"
+    },
+    {
+      "path": "source/weight_quant.py",
+      "bytes": 1819,
+      "sha256": "74eb0257e09065ceec838d5ec966f9038a2f4001736ba833270680dcd70faa71"
+    },
+    {
+      "path": "transformer/config.json",
+      "bytes": 370,
+      "sha256": "56ae3281c4e6c2d1aa3658252d187488071815fd79bef15808bb0205fc1a2241"
+    },
+    {
+      "path": "transformer/model-00001-of-00002.safetensors",
+      "bytes": 2977392992,
+      "sha256": "9fa418cbe2610486997bf5f251db26f98e1f2fcb53d291992a63e16660268afb"
+    },
+    {
+      "path": "transformer/model-00002-of-00002.safetensors",
+      "bytes": 1893707392,
+      "sha256": "a820829d3b2d89a09c99bda3f32b1340b37779ad3072d22e7ec6232f71ed83da"
+    },
+    {
+      "path": "transformer/quantization_config.json",
+      "bytes": 42776,
+      "sha256": "87565b07b201f5171baf85a4f109302ea8414c5e0c8910d5afd0a630907fdb16"
+    }
+  ],
+  "total_bytes": 4937691362
+}

nvfp4_runtime.py

@@ -0,0 +1,81 @@
+"""Calibrated NVFP4 W4A4 with BF16 rank-128 correction on SM120.
+
+Built with Qwen. Quantization modifications by ProCreations, 2026.
+Requires the pinned FlashInfer source revision shipped in requirements.
+"""
+import json
+from pathlib import Path
+import torch
+from torch import nn
+from safetensors.torch import load_file
+
+@torch.library.custom_op('image21_nvfp4::linear',mutates_args=())
+def _linear(x:torch.Tensor,weight:torch.Tensor,sf:torch.Tensor,pre:torch.Tensor,
+            gx:torch.Tensor,alpha:torch.Tensor,down:torch.Tensor,up:torch.Tensor)->torch.Tensor:
+    from flashinfer.gemm import nvfp4_quantize_smooth,mm_nvfp4_svdquant
+    from dynamic_scale import scale
+    x=x.contiguous()
+    gx,alpha,up=scale(x,pre,gx,alpha,up)
+    q,sc=nvfp4_quantize_smooth(x,pre,gx,backend='cute-dsl')
+    d=torch.mm(x,down)
+    return mm_nvfp4_svdquant(q,weight,sc,sf,alpha,d,up,backend='cute-dsl')
+
+@_linear.register_fake
+def _linear_fake(x,weight,sf,pre,gx,alpha,down,up):
+    return x.new_empty((x.shape[0],weight.shape[0]),dtype=torch.bfloat16)
+
+class CalibratedNVFP4Linear(nn.Module):
+    def __init__(self,state):
+        super().__init__()
+        for key in ['weight','sf','pre','gx','alpha','down','up']:
+            self.register_buffer(key,state[key])
+        self.out_features,self.in_features=self.weight.shape[0],self.weight.shape[1]*2
+        self.bias=None
+    def forward(self,x):
+        shape=x.shape[:-1]
+        return _linear(x.reshape(-1,self.in_features),self.weight,self.sf,self.pre,
+                       self.gx,self.alpha,self.down,self.up).reshape(*shape,self.out_features)
+
+def replace_module(model,name,replacement):
+    parent,leaf=name.rsplit('.',1)
+    setattr(model.get_submodule(parent),leaf,replacement)
+
+def load_nvfp4_transformer(directory,device='cuda'):
+    from diffusers import QwenImage21Transformer2DModel
+    directory=Path(directory)
+    config=json.loads((directory/'config.json').read_text())
+    meta=json.loads((directory/'quantization_config.json').read_text())
+    with torch.device('meta'):
+        model=QwenImage21Transformer2DModel.from_config(config)
+        for name,spec in meta['quantized_modules'].items():
+            n,k=spec['shape'];r=spec['rank']
+            state={
+                'weight':torch.empty((n,k//2),dtype=torch.uint8),
+                'sf':torch.empty(n*k//16,dtype=torch.uint8),
+                'pre':torch.empty(k,dtype=torch.bfloat16),
+                'gx':torch.empty(1,dtype=torch.float32),
+                'alpha':torch.empty(1,dtype=torch.float32),
+                'down':torch.empty((k,r),dtype=torch.bfloat16),
+                'up':torch.empty((n,r),dtype=torch.bfloat16),
+            }
+            replace_module(model,name,CalibratedNVFP4Linear(state))
+        for name,spec in meta.get('fp8_modules',{}).items():
+            from fp8_runtime import CalibratedFP8Linear
+            n,k=spec['shape']
+            replace_module(model,name,CalibratedFP8Linear(
+                torch.empty((n,k),dtype=torch.float8_e4m3fn),
+                torch.empty((n,1),dtype=torch.float32),torch.empty(k,dtype=torch.float32)))
+    state={}
+    for p in sorted(directory.glob('model-*.safetensors')):state.update(load_file(str(p)))
+    model.load_state_dict(state,strict=True,assign=True)
+    from diffusers.models.transformers.transformer_qwenimage21 import QwenImage21Rope,QwenImage21TemporalTimesteps
+    model.pos_embed=QwenImage21Rope(theta=10000,axes_dim=list(model.config.axes_dims_rope))
+    model.time_text_embed.time_proj=QwenImage21TemporalTimesteps(timestep_dim=256)
+    return model.eval().to(device=device)
+
+def load_pipeline(base,quant):
+    from diffusers import QwenImage21Pipeline
+    kwargs={} if Path(base).exists() else {'revision':'b3179ad355be050328e483a9dfdd9e60cd62adfa'}
+    p=QwenImage21Pipeline.from_pretrained(base,transformer=load_nvfp4_transformer(quant),torch_dtype=torch.bfloat16,**kwargs)
+    p.to(device='cuda');p.set_progress_bar_config(disable=True)
+    return p

reports/benchmark.json

@@ -0,0 +1,36 @@
+{
+  "load_seconds": 2.297096138005145,
+  "torch": "2.14.0+cu130",
+  "gpu": "NVIDIA RTX PRO 6000 Blackwell Workstation Edition",
+  "nvfp4_linears": 224,
+  "steps": 40,
+  "cfg": 1,
+  "bf16_rank": 128,
+  "attention_dtype": "bfloat16",
+  "approximate_cache": false,
+  "timing": {
+    "1024": {
+      "seconds": [
+        4.547408219019417,
+        4.571850906999316,
+        4.592371508013457,
+        4.610020697989967,
+        4.624509044981096
+      ],
+      "mean": 4.58923207540065,
+      "warmup_seconds": 8.535866206977516,
+      "peak_gb": 30.255306752
+    },
+    "2048": {
+      "seconds": [
+        32.58121982298326,
+        32.67262674000813,
+        32.71958359400742
+      ],
+      "mean": 32.657810052332934,
+      "warmup_seconds": 35.41050831298344,
+      "peak_gb": 51.385951232
+    }
+  },
+  "protocol": "CUDA synchronized; batch1; full40steps; includes encoder, denoising and VAE; excludes model load, resolution warmup and file writes. Prefix KV cache enabled. All large projections use either native NVFP4 with BF16 rank128 correction or explicitly listed calibrated FP8 safety layers. Compiled mode emulates intermediate precision casts."
+}

reports/calibration_manifest.json

@@ -0,0 +1,881 @@
+{
+  "source_revision": "b3179ad355be050328e483a9dfdd9e60cd62adfa",
+  "rows_per_layer": 1536,
+  "sampled_steps": [
+    0,
+    3,
+    9,
+    19,
+    29,
+    39
+  ],
+  "modules": [
+    "transformer_blocks.0.attn.to_q",
+    "transformer_blocks.0.attn.to_k",
+    "transformer_blocks.0.attn.to_v",
+    "transformer_blocks.0.attn.to_out.0",
+    "transformer_blocks.0.img_mlp.proj",
+    "transformer_blocks.0.img_mlp.out",
+    "transformer_blocks.0.img_mlp.gate_layer",
+    "transformer_blocks.1.attn.to_q",
+    "transformer_blocks.1.attn.to_k",
+    "transformer_blocks.1.attn.to_v",
+    "transformer_blocks.1.attn.to_out.0",
+    "transformer_blocks.1.img_mlp.proj",
+    "transformer_blocks.1.img_mlp.out",
+    "transformer_blocks.1.img_mlp.gate_layer",
+    "transformer_blocks.2.attn.to_q",
+    "transformer_blocks.2.attn.to_k",
+    "transformer_blocks.2.attn.to_v",
+    "transformer_blocks.2.attn.to_out.0",
+    "transformer_blocks.2.img_mlp.proj",
+    "transformer_blocks.2.img_mlp.out",
+    "transformer_blocks.2.img_mlp.gate_layer",
+    "transformer_blocks.3.attn.to_q",
+    "transformer_blocks.3.attn.to_k",
+    "transformer_blocks.3.attn.to_v",
+    "transformer_blocks.3.attn.to_out.0",
+    "transformer_blocks.3.img_mlp.proj",
+    "transformer_blocks.3.img_mlp.out",
+    "transformer_blocks.3.img_mlp.gate_layer",
+    "transformer_blocks.4.attn.to_q",
+    "transformer_blocks.4.attn.to_k",
+    "transformer_blocks.4.attn.to_v",
+    "transformer_blocks.4.attn.to_out.0",
+    "transformer_blocks.4.img_mlp.proj",
+    "transformer_blocks.4.img_mlp.out",
+    "transformer_blocks.4.img_mlp.gate_layer",
+    "transformer_blocks.5.attn.to_q",
+    "transformer_blocks.5.attn.to_k",
+    "transformer_blocks.5.attn.to_v",
+    "transformer_blocks.5.attn.to_out.0",
+    "transformer_blocks.5.img_mlp.proj",
+    "transformer_blocks.5.img_mlp.out",
+    "transformer_blocks.5.img_mlp.gate_layer",
+    "transformer_blocks.6.attn.to_q",
+    "transformer_blocks.6.attn.to_k",
+    "transformer_blocks.6.attn.to_v",
+    "transformer_blocks.6.attn.to_out.0",
+    "transformer_blocks.6.img_mlp.proj",
+    "transformer_blocks.6.img_mlp.out",
+    "transformer_blocks.6.img_mlp.gate_layer",
+    "transformer_blocks.7.attn.to_q",
+    "transformer_blocks.7.attn.to_k",
+    "transformer_blocks.7.attn.to_v",
+    "transformer_blocks.7.attn.to_out.0",
+    "transformer_blocks.7.img_mlp.proj",
+    "transformer_blocks.7.img_mlp.out",
+    "transformer_blocks.7.img_mlp.gate_layer",
+    "transformer_blocks.8.attn.to_q",
+    "transformer_blocks.8.attn.to_k",
+    "transformer_blocks.8.attn.to_v",
+    "transformer_blocks.8.attn.to_out.0",
+    "transformer_blocks.8.img_mlp.proj",
+    "transformer_blocks.8.img_mlp.out",
+    "transformer_blocks.8.img_mlp.gate_layer",
+    "transformer_blocks.9.attn.to_q",
+    "transformer_blocks.9.attn.to_k",
+    "transformer_blocks.9.attn.to_v",
+    "transformer_blocks.9.attn.to_out.0",
+    "transformer_blocks.9.img_mlp.proj",
+    "transformer_blocks.9.img_mlp.out",
+    "transformer_blocks.9.img_mlp.gate_layer",
+    "transformer_blocks.10.attn.to_q",
+    "transformer_blocks.10.attn.to_k",
+    "transformer_blocks.10.attn.to_v",
+    "transformer_blocks.10.attn.to_out.0",
+    "transformer_blocks.10.img_mlp.proj",
+    "transformer_blocks.10.img_mlp.out",
+    "transformer_blocks.10.img_mlp.gate_layer",
+    "transformer_blocks.11.attn.to_q",
+    "transformer_blocks.11.attn.to_k",
+    "transformer_blocks.11.attn.to_v",
+    "transformer_blocks.11.attn.to_out.0",
+    "transformer_blocks.11.img_mlp.proj",
+    "transformer_blocks.11.img_mlp.out",
+    "transformer_blocks.11.img_mlp.gate_layer",
+    "transformer_blocks.12.attn.to_q",
+    "transformer_blocks.12.attn.to_k",
+    "transformer_blocks.12.attn.to_v",
+    "transformer_blocks.12.attn.to_out.0",
+    "transformer_blocks.12.img_mlp.proj",
+    "transformer_blocks.12.img_mlp.out",
+    "transformer_blocks.12.img_mlp.gate_layer",
+    "transformer_blocks.13.attn.to_q",
+    "transformer_blocks.13.attn.to_k",
+    "transformer_blocks.13.attn.to_v",
+    "transformer_blocks.13.attn.to_out.0",
+    "transformer_blocks.13.img_mlp.proj",
+    "transformer_blocks.13.img_mlp.out",
+    "transformer_blocks.13.img_mlp.gate_layer",
+    "transformer_blocks.14.attn.to_q",
+    "transformer_blocks.14.attn.to_k",
+    "transformer_blocks.14.attn.to_v",
+    "transformer_blocks.14.attn.to_out.0",
+    "transformer_blocks.14.img_mlp.proj",
+    "transformer_blocks.14.img_mlp.out",
+    "transformer_blocks.14.img_mlp.gate_layer",
+    "transformer_blocks.15.attn.to_q",
+    "transformer_blocks.15.attn.to_k",
+    "transformer_blocks.15.attn.to_v",
+    "transformer_blocks.15.attn.to_out.0",
+    "transformer_blocks.15.img_mlp.proj",
+    "transformer_blocks.15.img_mlp.out",
+    "transformer_blocks.15.img_mlp.gate_layer",
+    "transformer_blocks.16.attn.to_q",
+    "transformer_blocks.16.attn.to_k",
+    "transformer_blocks.16.attn.to_v",
+    "transformer_blocks.16.attn.to_out.0",
+    "transformer_blocks.16.img_mlp.proj",
+    "transformer_blocks.16.img_mlp.out",
+    "transformer_blocks.16.img_mlp.gate_layer",
+    "transformer_blocks.17.attn.to_q",
+    "transformer_blocks.17.attn.to_k",
+    "transformer_blocks.17.attn.to_v",
+    "transformer_blocks.17.attn.to_out.0",
+    "transformer_blocks.17.img_mlp.proj",
+    "transformer_blocks.17.img_mlp.out",
+    "transformer_blocks.17.img_mlp.gate_layer",
+    "transformer_blocks.18.attn.to_q",
+    "transformer_blocks.18.attn.to_k",
+    "transformer_blocks.18.attn.to_v",
+    "transformer_blocks.18.attn.to_out.0",
+    "transformer_blocks.18.img_mlp.proj",
+    "transformer_blocks.18.img_mlp.out",
+    "transformer_blocks.18.img_mlp.gate_layer",
+    "transformer_blocks.19.attn.to_q",
+    "transformer_blocks.19.attn.to_k",
+    "transformer_blocks.19.attn.to_v",
+    "transformer_blocks.19.attn.to_out.0",
+    "transformer_blocks.19.img_mlp.proj",
+    "transformer_blocks.19.img_mlp.out",
+    "transformer_blocks.19.img_mlp.gate_layer",
+    "transformer_blocks.20.attn.to_q",
+    "transformer_blocks.20.attn.to_k",
+    "transformer_blocks.20.attn.to_v",
+    "transformer_blocks.20.attn.to_out.0",
+    "transformer_blocks.20.img_mlp.proj",
+    "transformer_blocks.20.img_mlp.out",
+    "transformer_blocks.20.img_mlp.gate_layer",
+    "transformer_blocks.21.attn.to_q",
+    "transformer_blocks.21.attn.to_k",
+    "transformer_blocks.21.attn.to_v",
+    "transformer_blocks.21.attn.to_out.0",
+    "transformer_blocks.21.img_mlp.proj",
+    "transformer_blocks.21.img_mlp.out",
+    "transformer_blocks.21.img_mlp.gate_layer",
+    "transformer_blocks.22.attn.to_q",
+    "transformer_blocks.22.attn.to_k",
+    "transformer_blocks.22.attn.to_v",
+    "transformer_blocks.22.attn.to_out.0",
+    "transformer_blocks.22.img_mlp.proj",
+    "transformer_blocks.22.img_mlp.out",
+    "transformer_blocks.22.img_mlp.gate_layer",
+    "transformer_blocks.23.attn.to_q",
+    "transformer_blocks.23.attn.to_k",
+    "transformer_blocks.23.attn.to_v",
+    "transformer_blocks.23.attn.to_out.0",
+    "transformer_blocks.23.img_mlp.proj",
+    "transformer_blocks.23.img_mlp.out",
+    "transformer_blocks.23.img_mlp.gate_layer",
+    "transformer_blocks.24.attn.to_q",
+    "transformer_blocks.24.attn.to_k",
+    "transformer_blocks.24.attn.to_v",
+    "transformer_blocks.24.attn.to_out.0",
+    "transformer_blocks.24.img_mlp.proj",
+    "transformer_blocks.24.img_mlp.out",
+    "transformer_blocks.24.img_mlp.gate_layer",
+    "transformer_blocks.25.attn.to_q",
+    "transformer_blocks.25.attn.to_k",
+    "transformer_blocks.25.attn.to_v",
+    "transformer_blocks.25.attn.to_out.0",
+    "transformer_blocks.25.img_mlp.proj",
+    "transformer_blocks.25.img_mlp.out",
+    "transformer_blocks.25.img_mlp.gate_layer",
+    "transformer_blocks.26.attn.to_q",
+    "transformer_blocks.26.attn.to_k",
+    "transformer_blocks.26.attn.to_v",
+    "transformer_blocks.26.attn.to_out.0",
+    "transformer_blocks.26.img_mlp.proj",
+    "transformer_blocks.26.img_mlp.out",
+    "transformer_blocks.26.img_mlp.gate_layer",
+    "transformer_blocks.27.attn.to_q",
+    "transformer_blocks.27.attn.to_k",
+    "transformer_blocks.27.attn.to_v",
+    "transformer_blocks.27.attn.to_out.0",
+    "transformer_blocks.27.img_mlp.proj",
+    "transformer_blocks.27.img_mlp.out",
+    "transformer_blocks.27.img_mlp.gate_layer",
+    "transformer_blocks.28.attn.to_q",
+    "transformer_blocks.28.attn.to_k",
+    "transformer_blocks.28.attn.to_v",
+    "transformer_blocks.28.attn.to_out.0",
+    "transformer_blocks.28.img_mlp.proj",
+    "transformer_blocks.28.img_mlp.out",
+    "transformer_blocks.28.img_mlp.gate_layer",
+    "transformer_blocks.29.attn.to_q",
+    "transformer_blocks.29.attn.to_k",
+    "transformer_blocks.29.attn.to_v",
+    "transformer_blocks.29.attn.to_out.0",
+    "transformer_blocks.29.img_mlp.proj",
+    "transformer_blocks.29.img_mlp.out",
+    "transformer_blocks.29.img_mlp.gate_layer",
+    "transformer_blocks.30.attn.to_q",
+    "transformer_blocks.30.attn.to_k",
+    "transformer_blocks.30.attn.to_v",
+    "transformer_blocks.30.attn.to_out.0",
+    "transformer_blocks.30.img_mlp.proj",
+    "transformer_blocks.30.img_mlp.out",
+    "transformer_blocks.30.img_mlp.gate_layer",
+    "transformer_blocks.31.attn.to_q",
+    "transformer_blocks.31.attn.to_k",
+    "transformer_blocks.31.attn.to_v",
+    "transformer_blocks.31.attn.to_out.0",
+    "transformer_blocks.31.img_mlp.proj",
+    "transformer_blocks.31.img_mlp.out",
+    "transformer_blocks.31.img_mlp.gate_layer"
+  ],
+  "records": [
+    {
+      "index": 0,
+      "prompt": "A documentary photograph of an elderly fisherman repairing a blue net on a wooden pier, overcast daylight, realistic hands and skin.",
+      "seed": 10000,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.55586172902258,
+      "editing": false
+    },
+    {
+      "index": 1,
+      "prompt": "A studio portrait of a woman with curly black hair wearing a green wool sweater, soft side lighting, natural skin texture.",
+      "seed": 10001,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.916995454987045,
+      "editing": false
+    },
+    {
+      "index": 2,
+      "prompt": "A red panda resting on a mossy branch in a misty bamboo forest, wildlife photography, intricate fur.",
+      "seed": 10002,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.919777019997127,
+      "editing": false
+    },
+    {
+      "index": 3,
+      "prompt": "An aerial photograph of turquoise river channels winding through a dark volcanic plain at sunrise.",
+      "seed": 10003,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.944503634003922,
+      "editing": false
+    },
+    {
+      "index": 4,
+      "prompt": "A macro photograph of dew on a purple iris, shallow depth of field, intricate translucent petals.",
+      "seed": 10004,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.75184188003186,
+      "editing": false
+    },
+    {
+      "index": 5,
+      "prompt": "An architectural photograph of a quiet concrete library with tall windows and warm wooden furniture.",
+      "seed": 10005,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.009491505974438,
+      "editing": false
+    },
+    {
+      "index": 6,
+      "prompt": "A still life of three ceramic bowls, a linen cloth, two pears and a glass of water in window light.",
+      "seed": 10006,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.987017144041602,
+      "editing": false
+    },
+    {
+      "index": 7,
+      "prompt": "A cinematic photograph of a wet narrow street in Kyoto at dusk, umbrellas and reflected shop lights.",
+      "seed": 10007,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.978878663969226,
+      "editing": false
+    },
+    {
+      "index": 8,
+      "prompt": "A wide desert landscape with rippling dunes and a lone acacia tree beneath a star-filled sky.",
+      "seed": 10008,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.9559129459667,
+      "editing": false
+    },
+    {
+      "index": 9,
+      "prompt": "An underwater photograph of a green sea turtle above a colorful coral reef, sunlight shafts.",
+      "seed": 10009,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.959987735957839,
+      "editing": false
+    },
+    {
+      "index": 10,
+      "prompt": "A watercolor illustration of a small cottage surrounded by wildflowers, delicate washes on textured paper.",
+      "seed": 10010,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.016518865944818,
+      "editing": false
+    },
+    {
+      "index": 11,
+      "prompt": "A detailed oil painting of a stormy ocean and a distant lighthouse, dramatic layered clouds.",
+      "seed": 10011,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.014705530018546,
+      "editing": false
+    },
+    {
+      "index": 12,
+      "prompt": "An isometric clay render of a miniature bakery with croissants and copper baking trays, pastel colors.",
+      "seed": 10012,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.98055850400124,
+      "editing": false
+    },
+    {
+      "index": 13,
+      "prompt": "A black and white ink drawing of an old oak tree with twisted roots, intricate crosshatching.",
+      "seed": 10013,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.911684828985017,
+      "editing": false
+    },
+    {
+      "index": 14,
+      "prompt": "A friendly orange robot tending a greenhouse full of tropical plants, polished 3D animation style.",
+      "seed": 10014,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.013557444966864,
+      "editing": false
+    },
+    {
+      "index": 15,
+      "prompt": "A crisp product photograph of a translucent blue perfume bottle on pale stone, precise reflections.",
+      "seed": 10015,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.004387759021483,
+      "editing": false
+    },
+    {
+      "index": 16,
+      "prompt": "A close-up of a mechanical wristwatch with brushed steel and visible gears, luxury product lighting.",
+      "seed": 10016,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 56.012295930995606,
+      "editing": false
+    },
+    {
+      "index": 17,
+      "prompt": "A photograph of a chef pulling a pizza from a brick oven, flour dust and warm firelight.",
+      "seed": 10017,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.00824662600644,
+      "editing": false
+    },
+    {
+      "index": 18,
+      "prompt": "A handmade paper collage of mountains, a winding river and a yellow sun, visible cut edges.",
+      "seed": 10018,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.993421372026205,
+      "editing": false
+    },
+    {
+      "index": 19,
+      "prompt": "A charcoal portrait of an elderly violinist, expressive eyes and detailed instrument strings.",
+      "seed": 10019,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.94143287598854,
+      "editing": false
+    },
+    {
+      "index": 20,
+      "prompt": "A ceramic teapot shaped like a sleeping cat, clean product photography on a cream background.",
+      "seed": 10020,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.824732757988386,
+      "editing": false
+    },
+    {
+      "index": 21,
+      "prompt": "A cozy reading nook in an attic with a round window, books and a sleeping dog, morning light.",
+      "seed": 10021,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.017206886026543,
+      "editing": false
+    },
+    {
+      "index": 22,
+      "prompt": "A vibrant science fiction city built inside a giant glass dome on a rocky moon, cinematic wide shot.",
+      "seed": 10022,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.905753094004467,
+      "editing": false
+    },
+    {
+      "index": 23,
+      "prompt": "A botanical illustration of a sunflower showing leaves, roots and flower head, clean ivory paper.",
+      "seed": 10023,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.950438202009536,
+      "editing": false
+    },
+    {
+      "index": 24,
+      "prompt": "A photograph of two dancers in flowing red and white costumes on a dark stage, frozen movement.",
+      "seed": 10024,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.87080749304732,
+      "editing": false
+    },
+    {
+      "index": 25,
+      "prompt": "A bowl of ramen with noodles, mushrooms, eggs and scallions, overhead food photography.",
+      "seed": 10025,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.003536691016052,
+      "editing": false
+    },
+    {
+      "index": 26,
+      "prompt": "A snowy alpine village reflected in a still lake, blue hour, high detail.",
+      "seed": 10026,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.961158728983719,
+      "editing": false
+    },
+    {
+      "index": 27,
+      "prompt": "A glass sculpture of a hummingbird with rainbow refractions, black studio background.",
+      "seed": 10027,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.926164573989809,
+      "editing": false
+    },
+    {
+      "index": 28,
+      "prompt": "A poster with the exact large words \"SPRING GARDEN\" and small text \"OPEN SATURDAY\", flowers and green borders.",
+      "seed": 10028,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.95907588303089,
+      "editing": false
+    },
+    {
+      "index": 29,
+      "prompt": "A neatly designed cafe menu with the headings \"COFFEE\", \"TEA\" and \"PASTRIES\", black typography on cream paper.",
+      "seed": 10029,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.982229411019944,
+      "editing": false
+    },
+    {
+      "index": 30,
+      "prompt": "一张精美的海报，标题为“山水之间”，画面是清晨薄雾中的青山和湖泊，优雅的中文排版。",
+      "seed": 10030,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.996177694993094,
+      "editing": false
+    },
+    {
+      "index": 31,
+      "prompt": "一只橘猫坐在木窗边，窗外下着细雨，室内有温暖的灯光，真实摄影风格。",
+      "seed": 10031,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.037701113033108,
+      "editing": false
+    },
+    {
+      "index": 32,
+      "prompt": "Une photographie réaliste de lavande dans la campagne française, une petite maison en pierre au loin.",
+      "seed": 10032,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.914367380028125,
+      "editing": false
+    },
+    {
+      "index": 33,
+      "prompt": "Un mercado de frutas al amanecer, naranjas, limones y flores, fotografía documental con colores naturales.",
+      "seed": 10033,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.030677798960824,
+      "editing": false
+    },
+    {
+      "index": 34,
+      "prompt": "日本の静かな庭園、石灯籠と池、秋の赤いもみじ、柔らかい朝の光、写真。",
+      "seed": 10034,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.955376817961223,
+      "editing": false
+    },
+    {
+      "index": 35,
+      "prompt": "صورة فوتوغرافية لقارب خشبي على بحيرة هادئة عند شروق الشمس، جبال في الخلفية.",
+      "seed": 10035,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.00634750595782,
+      "editing": false
+    },
+    {
+      "index": 36,
+      "prompt": "A group photograph of four friends seated at a picnic table, diverse appearances, natural candid expressions.",
+      "seed": 10036,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 56.10474174999399,
+      "editing": false
+    },
+    {
+      "index": 37,
+      "prompt": "A close photograph of a hand holding a delicate seashell, realistic fingers and softly blurred beach.",
+      "seed": 10037,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.005634397966787,
+      "editing": false
+    },
+    {
+      "index": 38,
+      "prompt": "Three distinct colored cubes: a red cube left, a green cube center and a blue cube right, clean studio photograph.",
+      "seed": 10038,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.967702204012312,
+      "editing": false
+    },
+    {
+      "index": 39,
+      "prompt": "A tiny astronaut standing on an enormous open book, imaginative photorealistic diorama, soft light.",
+      "seed": 10039,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.009398482972756,
+      "editing": false
+    },
+    {
+      "index": 40,
+      "prompt": "This is an RGBA image with transparency. A cute cartoon dragon sticker. The image has alpha channel and the background is transparent.",
+      "seed": 10040,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 55.86863625398837,
+      "editing": false
+    },
+    {
+      "index": 41,
+      "prompt": "This is an RGBA image with transparency. A realistic pink rose with green leaves. The image has alpha channel and the background is transparent.",
+      "seed": 10041,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.862337956030387,
+      "editing": false
+    },
+    {
+      "index": 42,
+      "prompt": "This is an RGBA image with transparency. A polished golden compass seen from above. The image has alpha channel and the background is transparent.",
+      "seed": 10042,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.913998158997856,
+      "editing": false
+    },
+    {
+      "index": 43,
+      "prompt": "This is an RGBA image with transparency. A fluffy white puppy sitting with its paws visible. The image has alpha channel and the background is transparent.",
+      "seed": 10043,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.922774217964616,
+      "editing": false
+    },
+    {
+      "index": 44,
+      "prompt": "A sunlit photograph of a waterfall pouring through a lush rocky ravine, long exposure water.",
+      "seed": 10044,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 56.01795354997739,
+      "editing": false
+    },
+    {
+      "index": 45,
+      "prompt": "A close-up of iridescent soap bubbles against dark velvet, fine colorful interference patterns.",
+      "seed": 10045,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.013371845008805,
+      "editing": false
+    },
+    {
+      "index": 46,
+      "prompt": "A handwoven basket filled with apples, walnuts and autumn leaves, rustic still life photograph.",
+      "seed": 10046,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.028369715961162,
+      "editing": false
+    },
+    {
+      "index": 47,
+      "prompt": "A minimalist geometric illustration with overlapping indigo circles and coral triangles on cream.",
+      "seed": 10047,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.945206430973485,
+      "editing": false
+    },
+    {
+      "index": 48,
+      "prompt": "A double exposure portrait combining a human silhouette with a pine forest, subtle photographic artwork.",
+      "seed": 10048,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 56.25246442400385,
+      "editing": false
+    },
+    {
+      "index": 49,
+      "prompt": "An elegant silver spaceship orbiting a blue planet, realistic cinematic lighting and star field.",
+      "seed": 10049,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.991588920995127,
+      "editing": false
+    },
+    {
+      "index": 50,
+      "prompt": "A photorealistic brown horse galloping across a green meadow, detailed muscles and flowing mane.",
+      "seed": 10050,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 10.032783773029223,
+      "editing": false
+    },
+    {
+      "index": 51,
+      "prompt": "A richly detailed mosaic of tropical fish made from small colored glass tiles, museum lighting.",
+      "seed": 10051,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.938231437001377,
+      "editing": false
+    },
+    {
+      "index": 52,
+      "prompt": "A long horizontal panorama of a rocky seashore under dramatic sunset clouds, realistic photograph.",
+      "seed": 10052,
+      "width": 1536,
+      "height": 864,
+      "steps": 40,
+      "seconds_with_collection": 13.22676891402807,
+      "editing": false
+    },
+    {
+      "index": 53,
+      "prompt": "A vertical photograph looking up through a spiral staircase with repeating white railings.",
+      "seed": 10053,
+      "width": 864,
+      "height": 1536,
+      "steps": 40,
+      "seconds_with_collection": 13.226088834984694,
+      "editing": false
+    },
+    {
+      "index": 54,
+      "prompt": "A warm sepia photograph of an antique bicycle leaning against a brick wall, climbing roses.",
+      "seed": 10054,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.979204855044372,
+      "editing": false
+    },
+    {
+      "index": 55,
+      "prompt": "A quiet winter forest of birch trees and soft falling snow, monochromatic fine art photography.",
+      "seed": 10055,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 9.959185037005227,
+      "editing": false
+    },
+    {
+      "index": 56,
+      "prompt": "Change the scene to warm sunset lighting while preserving the main subject.",
+      "seed": 10056,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 61.76318650902249,
+      "editing": true
+    },
+    {
+      "index": 57,
+      "prompt": "Make the background a lush green garden while preserving the main subject.",
+      "seed": 10057,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 11.710096635040827,
+      "editing": true
+    },
+    {
+      "index": 58,
+      "prompt": "Convert this image to a delicate watercolor painting, preserving its composition.",
+      "seed": 10058,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 11.703723802987952,
+      "editing": true
+    },
+    {
+      "index": 59,
+      "prompt": "Add gently falling snow and a winter atmosphere while preserving the main subject.",
+      "seed": 10059,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 11.623913866991643,
+      "editing": true
+    },
+    {
+      "index": 60,
+      "prompt": "Change the overall color palette to cool blue and silver, preserving details.",
+      "seed": 10060,
+      "width": 2048,
+      "height": 2048,
+      "steps": 40,
+      "seconds_with_collection": 60.85325455095153,
+      "editing": true
+    },
+    {
+      "index": 61,
+      "prompt": "Convert the image to a detailed pencil drawing on white paper.",
+      "seed": 10061,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 11.702045002020895,
+      "editing": true
+    },
+    {
+      "index": 62,
+      "prompt": "Place a small red flower in the foreground and preserve the rest of the scene.",
+      "seed": 10062,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 11.716953598021064,
+      "editing": true
+    },
+    {
+      "index": 63,
+      "prompt": "Give the scene soft cinematic moonlight while preserving its composition.",
+      "seed": 10063,
+      "width": 1024,
+      "height": 1024,
+      "steps": 40,
+      "seconds_with_collection": 11.728258827002719,
+      "editing": true
+    }
+  ],
+  "collection": "BF16 teacher trajectories, 4 token rows at each sampled timestep"
+}

reports/correction-probe.json

@@ -0,0 +1,122 @@
+[
+  {
+    "name": "transformer_blocks.0.attn.to_q",
+    "reg": "original",
+    "fit": 0.012696055695414543,
+    "check": 0.0126740587875247
+  },
+  {
+    "name": "transformer_blocks.0.attn.to_q",
+    "reg": 0.01,
+    "fit": 0.008233755826950073,
+    "check": 0.012077884748578072
+  },
+  {
+    "name": "transformer_blocks.0.attn.to_q",
+    "reg": 0.1,
+    "fit": 0.008387493900954723,
+    "check": 0.011893227696418762
+  },
+  {
+    "name": "transformer_blocks.0.attn.to_q",
+    "reg": 1.0,
+    "fit": 0.00852095615118742,
+    "check": 0.01182559598237276
+  },
+  {
+    "name": "transformer_blocks.8.attn.to_v",
+    "reg": "original",
+    "fit": 0.08148191124200821,
+    "check": 0.08202973008155823
+  },
+  {
+    "name": "transformer_blocks.8.attn.to_v",
+    "reg": 0.01,
+    "fit": 0.0604797899723053,
+    "check": 0.0942867323756218
+  },
+  {
+    "name": "transformer_blocks.8.attn.to_v",
+    "reg": 0.1,
+    "fit": 0.06049658730626106,
+    "check": 0.09427530318498611
+  },
+  {
+    "name": "transformer_blocks.8.attn.to_v",
+    "reg": 1.0,
+    "fit": 0.06077614054083824,
+    "check": 0.094297856092453
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.proj",
+    "reg": "original",
+    "fit": 0.05309119075536728,
+    "check": 0.05289224535226822
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.proj",
+    "reg": 0.01,
+    "fit": 0.040202125906944275,
+    "check": 0.06128205358982086
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.proj",
+    "reg": 0.1,
+    "fit": 0.04021118953824043,
+    "check": 0.06127419322729111
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.proj",
+    "reg": 1.0,
+    "fit": 0.040364813059568405,
+    "check": 0.061265550553798676
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.gate_layer",
+    "reg": "original",
+    "fit": 0.05491224303841591,
+    "check": 0.05476883798837662
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.gate_layer",
+    "reg": 0.01,
+    "fit": 0.04161699116230011,
+    "check": 0.0634395033121109
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.gate_layer",
+    "reg": 0.1,
+    "fit": 0.0416269451379776,
+    "check": 0.06343034654855728
+  },
+  {
+    "name": "transformer_blocks.16.img_mlp.gate_layer",
+    "reg": 1.0,
+    "fit": 0.04178332909941673,
+    "check": 0.06342266499996185
+  },
+  {
+    "name": "transformer_blocks.24.attn.to_out.0",
+    "reg": "original",
+    "fit": 0.06296917796134949,
+    "check": 0.06366930156946182
+  },
+  {
+    "name": "transformer_blocks.24.attn.to_out.0",
+    "reg": 0.01,
+    "fit": 0.04285139590501785,
+    "check": 0.071813203394413
+  },
+  {
+    "name": "transformer_blocks.24.attn.to_out.0",
+    "reg": 0.1,
+    "fit": 0.04286669194698334,
+    "check": 0.0718073919415474
+  },
+  {
+    "name": "transformer_blocks.24.attn.to_out.0",
+    "reg": 1.0,
+    "fit": 0.04305445775389671,
+    "check": 0.0718240886926651
+  }
+]

reports/cudagraph-trial.json

@@ -0,0 +1,10 @@
+{
+  "baseline_latent_only_seconds": 4.459490508015733,
+  "warmup": 12.883338742016349,
+  "candidate_latent_only_seconds": [
+    4.45742104400415,
+    4.47657939302735,
+    4.488048463012092
+  ],
+  "latent_nrmse": 0.0
+}

reports/earlier-bf16-benchmark.json

@@ -0,0 +1,41 @@
+{
+  "torch": "2.14.0+cu130",
+  "gpu": "NVIDIA RTX PRO 6000 Blackwell Workstation Edition",
+  "capability": [
+    12,
+    0
+  ],
+  "fp8_linears": 0,
+  "transformer_dtypes": {
+    "torch.bfloat16": 297
+  },
+  "resident_gb": 32.457959936,
+  "precision": "bf16",
+  "timing": {
+    "1024": {
+      "seconds": [
+        9.784915568016004,
+        9.794134593976196,
+        9.79820777400164,
+        9.79243299702648,
+        9.791788258997258
+      ],
+      "mean": 9.792295838403515,
+      "median": 9.79243299702648,
+      "min": 9.784915568016004,
+      "max": 9.79820777400164
+    },
+    "2048": {
+      "seconds": [
+        55.14897009101696,
+        55.18838875496294,
+        55.170718070003204
+      ],
+      "mean": 55.16935897199437,
+      "median": 55.170718070003204,
+      "min": 55.14897009101696,
+      "max": 55.18838875496294
+    }
+  },
+  "protocol": "Batch1;40steps;CFG1;prefixKVcache;fully GPU resident;warmup excluded;CUDA synchronized;includes text encoding, denoising and VAE decode;excludes load and PNG write."
+}

reports/environment.json

@@ -0,0 +1,95 @@
+{
+  "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]",
+  "platform": "Linux-7.0.0-31-generic-x86_64-with-glibc2.39",
+  "packages": {
+    "Jinja2": "3.1.6",
+    "MarkupSafe": "3.0.3",
+    "PyYAML": "6.0.3",
+    "Pygments": "2.21.0",
+    "accelerate": "1.15.0",
+    "annotated-doc": "0.0.5",
+    "anyio": "4.15.1",
+    "apache-tvm-ffi": "0.1.14.post0",
+    "certifi": "2026.7.22",
+    "charset-normalizer": "3.5.1",
+    "click": "8.5.0",
+    "cuda-bindings": "13.4.2",
+    "cuda-core": "1.2.0",
+    "cuda-pathfinder": "1.6.0",
+    "cuda-python": "13.4.1",
+    "cuda-tile": "1.6.0",
+    "cuda-toolkit": "13.0.3.0",
+    "diffusers": "0.41.0.dev0",
+    "einops": "0.8.2",
+    "filelock": "3.32.3",
+    "flashinfer-python": "0.7.0",
+    "fsspec": "2026.7.0",
+    "h11": "0.16.0",
+    "hf-xet": "1.6.0",
+    "httpcore": "1.0.9",
+    "httpx": "0.28.1",
+    "huggingface_hub": "1.32.0",
+    "idna": "3.20",
+    "imageio-ffmpeg": "0.6.0",
+    "importlib_metadata": "9.0.1",
+    "markdown-it-py": "4.2.0",
+    "mdurl": "0.1.2",
+    "mpmath": "1.3.0",
+    "nccl-extensions": "0.1.0",
+    "nccl4py": "0.5.0",
+    "networkx": "3.6.1",
+    "ninja": "1.13.2",
+    "numpy": "2.5.2",
+    "nvidia-cublas": "13.1.1.3",
+    "nvidia-cuda-cupti": "13.0.85",
+    "nvidia-cuda-nvdisasm": "13.4.92",
+    "nvidia-cuda-nvrtc": "13.0.88",
+    "nvidia-cuda-runtime": "13.0.96",
+    "nvidia-cudnn-cu13": "9.24.0.43",
+    "nvidia-cudnn-frontend": "1.29.0",
+    "nvidia-cufft": "12.0.0.61",
+    "nvidia-cufile": "1.15.1.6",
+    "nvidia-curand": "10.4.0.35",
+    "nvidia-cusolver": "12.0.4.66",
+    "nvidia-cusparse": "12.6.3.3",
+    "nvidia-cusparselt-cu13": "0.8.1",
+    "nvidia-cutlass-dsl": "4.7.1",
+    "nvidia-cutlass-dsl-libs-base": "4.7.1",
+    "nvidia-cutlass-dsl-libs-core": "4.7.1",
+    "nvidia-cutlass-dsl-libs-cu12": "4.7.1",
+    "nvidia-cutlass-dsl-libs-cu13": "4.7.1",
+    "nvidia-ml-py": "13.610.43",
+    "nvidia-nccl-cu13": "2.30.7",
+    "nvidia-nvjitlink": "13.3.33",
+    "nvidia-nvshmem-cu13": "3.4.5",
+    "nvidia-nvtx": "13.0.85",
+    "packaging": "26.3",
+    "pillow": "12.3.0",
+    "protobuf": "7.36.2",
+    "psutil": "7.2.2",
+    "regex": "2026.9.10",
+    "requests": "2.34.2",
+    "rich": "15.0.0",
+    "safetensors": "0.8.0",
+    "sentencepiece": "0.2.2",
+    "setuptools": "78.1.0",
+    "shellingham": "1.5.4",
+    "sympy": "1.14.0",
+    "tabulate": "0.10.0",
+    "tokenizers": "0.23.2",
+    "torch": "2.14.0+cu130",
+    "torchvision": "0.29.0+cu130",
+    "tqdm": "4.70.1",
+    "transformers": "5.17.0",
+    "triton": "3.8.0",
+    "typer": "0.27.2",
+    "typing_extensions": "4.16.0",
+    "urllib3": "2.8.0",
+    "zipp": "4.1.0"
+  },
+  "flashinfer_commit": "975f90583d9ac8896db14cf0f26e99a853c2f136",
+  "diffusers_commit": "80c7ed262aeffbeb43ef13ae04baeb9b84515a69",
+  "gpu": "RTX PRO 6000 Blackwell Workstation Edition",
+  "driver": "615.71.09",
+  "compute_capability": "12.0"
+}

reports/evaluation-environment.json

@@ -0,0 +1,9 @@
+{
+  "torch": "2.14.0",
+  "torchvision": "0.29.0",
+  "lpips": "0.1.4",
+  "scikit-image": "0.26.0",
+  "scipy": "1.18.1",
+  "numpy": "2.5.3",
+  "Pillow": "12.3.0"
+}

reports/fresh-fp8-benchmark.json

@@ -0,0 +1,31 @@
+{
+  "load_seconds": 2.801166548044421,
+  "torch": "2.14.0+cu130",
+  "gpu": "NVIDIA RTX PRO 6000 Blackwell Workstation Edition",
+  "fp8_linears": 224,
+  "steps": 40,
+  "cfg": 1,
+  "extra_quantization": false,
+  "approximate_cache": false,
+  "timing": {
+    "1024": {
+      "seconds": [
+        5.894081406004261,
+        5.925464586995076
+      ],
+      "mean": 5.909772996499669,
+      "warmup_seconds": 10.963575308967847,
+      "peak_gb": 32.590829568
+    },
+    "2048": {
+      "seconds": [
+        37.19529012899147,
+        37.23217404395109
+      ],
+      "mean": 37.21373208647128,
+      "warmup_seconds": 40.54065499798162,
+      "peak_gb": 53.722432512
+    }
+  },
+  "protocol": "CUDA synchronized; batch1; full40steps; includes encoder, denoising and VAE; excludes model load, resolution warmup and file writes. Weights and prefixKVcache unchanged. Compiled mode emulates intermediate precision casts."
+}

reports/heldout-manifest.json

@@ -0,0 +1,69 @@
+{
+  "frozen_after_candidate_selection": true,
+  "cases": [
+    {
+      "index": 0,
+      "prompt": "A transparent glass teapot filled with amber tea on a slate table beside sliced dragon fruit, soft window light, crisp reflections, studio photograph, no text.",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62000,
+      "steps": 40
+    },
+    {
+      "index": 1,
+      "prompt": "Three origami cranes arranged in a row on a pale wooden desk: a red crane on the left, a yellow crane in the center, and a blue crane on the right, precise folded paper, no text.",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62001,
+      "steps": 40
+    },
+    {
+      "index": 2,
+      "prompt": "An elderly pianist playing a black grand piano in a warmly lit room, both hands visible on the keys, realistic fingers, candid documentary photograph, no text.",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62002,
+      "steps": 40
+    },
+    {
+      "index": 3,
+      "prompt": "A minimalist travel poster with the exact large headline \"SUMMER 2026\", a golden sun above a turquoise sea, elegant bold typography.",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62003,
+      "steps": 40
+    },
+    {
+      "index": 4,
+      "prompt": "一张精美的中国山水海报，清晰准确的四字标题“山海之间”，远山、碧海和细腻的水墨纹理，优雅留白。",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62004,
+      "steps": 40
+    },
+    {
+      "index": 5,
+      "prompt": "An intricately engraved brass mechanical dragon sculpture on a dark pedestal, delicate interlocking gears, polished metal highlights, museum product photograph, no text.",
+      "width": 2048,
+      "height": 2048,
+      "seed": 62005,
+      "steps": 40
+    },
+    {
+      "index": 6,
+      "prompt": "This is an RGBA image with transparency. A charming illustrated red panda holding a small green bamboo leaf, clean outlines, fluffy striped tail. The image has alpha channel and the background is transparent.",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62006,
+      "steps": 40
+    },
+    {
+      "index": 7,
+      "prompt": "A close-up wildlife photograph of a barn owl on a weathered wooden fence, fine speckled feathers, sharp dark eyes, softly blurred spring meadow in the background, no text.",
+      "width": 1024,
+      "height": 1024,
+      "seed": 62007,
+      "steps": 40
+    }
+  ]
+}

reports/kernel_evidence.json

@@ -0,0 +1,81 @@
+{
+  "nvfp4_sm120_launches": 224,
+  "fp8_sm120_launches": 0,
+  "native_bf16_flash_attention": 32,
+  "all_kernels": {
+    "void cutlass::Kernel2<cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_128x256_32x3_tt_align8>(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_128x256_32x3_tt_align8::Params)": 1,
+    "void at::native::unrolled_elementwise_kernel<at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#7}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)": 3,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl<float, float>(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array<char*, 2ul>, false>(int, at::native::(anonymous namespace)::pow_tensor_scalar_kernel_impl<float, float>(at::TensorIteratorBase&, float)::{lambda(float)#1}, std::array<char*, 2ul>)": 1,
+    "void at::native::reduce_kernel<512, 1, at::native::ReduceOp<float, at::native::MeanOps<float, float, float, float>, unsigned int, float, 4, 4> >(at::native::ReduceOp<float, at::native::MeanOps<float, float, float, float>, unsigned int, float, 4, 4>)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnSelf_add<float>, std::array<char*, 2ul>, false>(int, at::native::CUDAFunctorOnSelf_add<float>, std::array<char*, 2ul>)": 2,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>, false>(int, at::native::rsqrt_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>)": 1,
+    "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast<at::native::BinaryFunctor<float, float, float, at::native::binary_internal::MulFunctor<float> > >(at::TensorIteratorBase&, at::native::BinaryFunctor<float, float, float, at::native::binary_internal::MulFunctor<float> > const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast<at::native::BinaryFunctor<float, float, float, at::native::binary_internal::MulFunctor<float> > >(at::TensorIteratorBase&, at::native::BinaryFunctor<float, float, float, at::native::binary_internal::MulFunctor<float> > const&)::{lambda(int)#1})": 3,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array<char*, 2ul>, false>(int, at::native::bfloat16_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda(float)#1}, std::array<char*, 2ul>)": 2,
+    "void cutlass::Kernel2<cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_128x64_32x6_tn_align8>(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_128x64_32x6_tn_align8::Params)": 2,
+    "void cublasLt::splitKreduce_kernel<32, 16, int, __nv_bfloat16, __nv_bfloat16, float, __nv_bfloat16, false, __nv_bfloat16, __nv_bfloat16, __nv_bfloat16, true, false, false, false>(cublasLt::cublasSplitKParams<float>, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, __nv_bfloat16*, float const*, float const*, __nv_bfloat16 const*, __nv_bfloat16 const*, __nv_bfloat16*, void*, long, float*, int*, float*, float*, float const*, float const*, float const*, float const*, float const*)": 227,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array<char*, 2ul>, false>(int, at::native::GeluCUDAKernelImpl(at::TensorIteratorBase&, at::native::GeluType)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(c10::BFloat16)#1}, std::array<char*, 2ul>)": 1,
+    "void at::native::vectorized_elementwise_kernel<2, at::native::FillFunctor<long>, std::array<char*, 1ul>, false>(int, at::native::FillFunctor<long>, std::array<char*, 1ul>)": 3,
+    "void at::native::elementwise_kernel<128, 2, at::native::gpu_kernel_impl_nocast<at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(bool, unsigned long, unsigned long)#1}>(at::TensorIteratorBase&, at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(bool, unsigned long, unsigned long)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast<at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(bool, unsigned long, unsigned long)#1}>(at::TensorIteratorBase&, at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(bool, unsigned long, unsigned long)#1} const&)::{lambda(int)#1})": 1,
+    "void at_cuda_detail::cub::detail::scan::DeviceScanInitKernel<at_cuda_detail::cub::ScanTileState<long, true> >(at_cuda_detail::cub::ScanTileState<long, true>, int)": 3,
+    "void at_cuda_detail::cub::detail::scan::DeviceScanKernel<at_cuda_detail::cub::detail::scan::policy_hub<long, long, long, unsigned int, std::plus<long> >::Policy1000, long const*, long*, at_cuda_detail::cub::ScanTileState<long, true>, std::plus<long>, at_cuda_detail::cub::NullType, unsigned int, long, false, at_cuda_detail::cub::NullType>(long const*, long*, at_cuda_detail::cub::ScanTileState<long, true>, int, std::plus<long>, at_cuda_detail::cub::NullType, unsigned int)": 3,
+    "Memcpy DtoH (Device -> Pinned)": 11,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::compare_scalar_kernel<long>(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array<char*, 2ul>, false>(int, at::native::compare_scalar_kernel<long>(at::TensorIteratorBase&, at::native::(anonymous namespace)::OpType, long)::{lambda(long)#1}, std::array<char*, 2ul>)": 3,
+    "void at::native::reduce_kernel<512, 1, at::native::ReduceOp<bool, at::native::func_wrapper_t<bool, at::native::and_kernel_cuda(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#12}::operator()() const::{lambda(bool, bool)#1}>, unsigned int, bool, 4, 4> >(at::native::ReduceOp<bool, at::native::func_wrapper_t<bool, at::native::and_kernel_cuda(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#12}::operator()() const::{lambda(bool, bool)#1}>, unsigned int, bool, 4, 4>)": 2,
+    "void compute_cuda_kernel<long>(long const*, long const*, long*, long, long)": 3,
+    "void at::native::_scatter_gather_elementwise_kernel<128, 8, at::native::_cuda_scatter_gather_internal_kernel<false, at::native::OpaqueType<1>, long>::operator()<at::native::TensorAssign>(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1}>(int, at::native::_cuda_scatter_gather_internal_kernel<false, at::native::OpaqueType<1>, long>::operator()<at::native::TensorAssign>(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1})": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor<c10::BFloat16>, std::array<char*, 1ul>, false>(int, at::native::FillFunctor<c10::BFloat16>, std::array<char*, 1ul>)": 2,
+    "void at::native::(anonymous namespace)::CatArrayBatchedCopy_vectorized<at::native::(anonymous namespace)::OpaqueType<2u>, unsigned int, 2, 128, 1, 16, 8>(char*, at::native::(anonymous namespace)::CatArrInputTensorMetadata<at::native::(anonymous namespace)::OpaqueType<2u>, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride<unsigned int, 4u>, int, unsigned int)": 1,
+    "void at::native::vectorized_gather_kernel<16, long>(char*, char*, long*, int, long, long, long, long, bool)": 4,
+    "void at_cuda_detail::cub::detail::reduce::DeviceReduceKernel<at_cuda_detail::cub::detail::reduce::policy_hub<int, unsigned long long, cuda::std::__4::plus<void> >::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator<at::native::(anonymous namespace)::NonZeroOp<bool>, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, unsigned long long, cuda::std::__4::plus<void>, int, cuda::std::__4::__identity>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator<at::native::(anonymous namespace)::NonZeroOp<bool>, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, int*, unsigned long long, at_cuda_detail::cub::GridEvenShare<unsigned long long>, cuda::std::__4::plus<void>, cuda::std::__4::__identity)": 4,
+    "void at_cuda_detail::cub::detail::reduce::DeviceReduceSingleTileKernel<at_cuda_detail::cub::detail::reduce::policy_hub<int, unsigned long long, cuda::std::__4::plus<void> >::Policy1000, int*, int*, int, cuda::std::__4::plus<void>, int, int, cuda::std::__4::__identity>(int*, int*, int, cuda::std::__4::plus<void>, int, cuda::std::__4::__identity)": 4,
+    "void at_cuda_detail::cub::detail::scan::DeviceCompactInitKernel<at_cuda_detail::cub::ScanTileState<int, true>, int*>(at_cuda_detail::cub::ScanTileState<int, true>, int, int*)": 4,
+    "void at_cuda_detail::cub::detail::select::DeviceSelectSweepKernel<at_cuda_detail::cub::detail::select::policy_hub<long, bool, int, false, (at_cuda_detail::cub::SelectImpl)0>::Policy1000, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator<long, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator<at::native::(anonymous namespace)::NonZeroOp<bool>, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState<int, true>, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, at_cuda_detail::cub::detail::select::streaming_context_t<long, true>, (at_cuda_detail::cub::SelectImpl)0>(thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::counting_iterator<long, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::transform_iterator<at::native::(anonymous namespace)::NonZeroOp<bool>, bool const*, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default, thrust::THRUST_300001_SM_750_800_860_900_1000_1200_NS::use_default>, long*, int*, at_cuda_detail::cub::ScanTileState<int, true>, at_cuda_detail::cub::NullType, at_cuda_detail::cub::NullType, int, int, at_cuda_detail::cub::detail::select::streaming_context_t<long, true>, at_cuda_detail::cub::detail::vsmem_t)": 4,
+    "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel<at::native::index_put_kernel_impl<at::native::OpaqueType<2> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef<long>, c10::ArrayRef<long>, at::native::index_put_kernel_impl<at::native::OpaqueType<2> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel<at::native::index_put_kernel_impl<at::native::OpaqueType<2> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef<long>, c10::ArrayRef<long>, at::native::index_put_kernel_impl<at::native::OpaqueType<2> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})": 1,
+    "Memcpy DtoH (Device -> Pageable)": 1,
+    "Memcpy HtoD (Pageable -> Device)": 5,
+    "Memcpy DtoD (Device -> Device)": 3,
+    "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel<at::native::index_put_kernel_impl<at::native::OpaqueType<8> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef<long>, c10::ArrayRef<long>, at::native::index_put_kernel_impl<at::native::OpaqueType<8> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel<at::native::index_put_kernel_impl<at::native::OpaqueType<8> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef<long>, c10::ArrayRef<long>, at::native::index_put_kernel_impl<at::native::OpaqueType<8> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})": 3,
+    "void at::native::(anonymous namespace)::CatArrayBatchedCopy_vectorized<at::native::(anonymous namespace)::OpaqueType<8u>, unsigned int, 2, 128, 1, 16, 2>(char*, at::native::(anonymous namespace)::CatArrInputTensorMetadata<at::native::(anonymous namespace)::OpaqueType<8u>, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride<unsigned int, 4u>, int, unsigned int)": 1,
+    "void (anonymous namespace)::elementwise_kernel_with_index<int, at::native::arange_cuda_out(c10::Scalar const&, c10::Scalar const&, c10::Scalar const&, at::Tensor&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}>(int, at::native::arange_cuda_out(c10::Scalar const&, c10::Scalar const&, c10::Scalar const&, at::Tensor&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, function_traits<at::native::arange_cuda_out(c10::Scalar const&, c10::Scalar const&, c10::Scalar const&, at::Tensor&)::{lambda()#1}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}>::result_type*)": 1,
+    "void at::native::_scatter_gather_elementwise_kernel<128, 8, at::native::_cuda_scatter_gather_internal_kernel<false, at::native::OpaqueType<8>, long>::operator()<at::native::TensorAssign>(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1}>(int, at::native::_cuda_scatter_gather_internal_kernel<false, at::native::OpaqueType<8>, long>::operator()<at::native::TensorAssign>(at::TensorIterator&, long, long, long, at::native::TensorAssign const&)::{lambda(int)#1})": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::FillFunctor<bool>, std::array<char*, 1ul>, false>(int, at::native::FillFunctor<bool>, std::array<char*, 1ul>)": 1,
+    "void at::native::index_elementwise_kernel<128, 4, at::native::gpu_index_kernel<at::native::index_put_kernel_impl<at::native::OpaqueType<1> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef<long>, c10::ArrayRef<long>, at::native::index_put_kernel_impl<at::native::OpaqueType<1> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1}>(long, at::native::gpu_index_kernel<at::native::index_put_kernel_impl<at::native::OpaqueType<1> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1}>(at::TensorIteratorBase&, c10::ArrayRef<long>, c10::ArrayRef<long>, at::native::index_put_kernel_impl<at::native::OpaqueType<1> >(at::TensorIterator&, c10::ArrayRef<long>, c10::ArrayRef<long>)::{lambda(char*, char const*, long)#1} const&, bool)::{lambda(int)#1})": 1,
+    "void at::native::(anonymous namespace)::CatArrayBatchedCopy_alignedK_contig<at::native::(anonymous namespace)::OpaqueType<2u>, unsigned int, 1, 128, 1, 8>(at::native::(anonymous namespace)::OpaqueType<2u>*, at::native::(anonymous namespace)::CatArrInputTensorMetadata<at::native::(anonymous namespace)::OpaqueType<2u>, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride<unsigned int, 4u>, int, unsigned int)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::AUnaryFunctor<float, float, float, at::native::binary_internal::MulFunctor<float> >, std::array<char*, 2ul>, false>(int, at::native::AUnaryFunctor<float, float, float, at::native::binary_internal::MulFunctor<float> >, std::array<char*, 2ul>)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>, false>(int, at::native::cos_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>, false>(int, at::native::sin_kernel_cuda(at::TensorIteratorBase&)::{lambda()#2}::operator()() const::{lambda()#2}::operator()() const::{lambda(float)#1}, std::array<char*, 2ul>)": 1,
+    "void at::native::(anonymous namespace)::CatArrayBatchedCopy_vectorized<at::native::(anonymous namespace)::OpaqueType<4u>, unsigned int, 2, 128, 1, 16, 4>(char*, at::native::(anonymous namespace)::CatArrInputTensorMetadata<at::native::(anonymous namespace)::OpaqueType<4u>, unsigned int, 128, 1>, at::native::(anonymous namespace)::TensorSizeStride<unsigned int, 4u>, int, unsigned int)": 1,
+    "void cutlass::Kernel2<cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_128x2_tn_align8>(cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_128x2_tn_align8::Params)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array<char*, 2ul>, false>(int, at::native::(anonymous namespace)::silu_kernel(at::TensorIteratorBase&)::{lambda()#1}::operator()() const::{lambda()#6}::operator()() const::{lambda(c10::BFloat16)#1}, std::array<char*, 2ul>)": 3,
+    "Memset (Device)": 3,
+    "void cutlass::Kernel2<cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_128x1_tn_align8>(cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_128x1_tn_align8::Params)": 2,
+    "void cutlass::Kernel2<cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_64x1_tn_align8>(cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_64x1_tn_align8::Params)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::bitwise_not_kernel_cuda(at::TensorIteratorBase&)::{lambda(bool)#1}, std::array<char*, 2ul>, false>(int, at::native::bitwise_not_kernel_cuda(at::TensorIteratorBase&)::{lambda(bool)#1}, std::array<char*, 2ul>)": 1,
+    "void at::native::unrolled_elementwise_kernel<at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array<char*, 2ul>, 4, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1> >(int, at::native::direct_copy_kernel_cuda(at::TensorIteratorBase&)::{lambda()#3}::operator()() const::{lambda()#4}::operator()() const::{lambda(long)#1}, std::array<char*, 2ul>, TrivialOffsetCalculator<1, unsigned int>, TrivialOffsetCalculator<1, unsigned int>, at::native::memory::LoadWithCast<1>, at::native::memory::StoreWithCast<1>)": 1,
+    "void at::native::reduce_kernel<512, 1, at::native::ReduceOp<long, at::native::func_wrapper_t<long, at::native::sum_functor<long, long, long>::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4> >(at::native::ReduceOp<long, at::native::func_wrapper_t<long, at::native::sum_functor<long, long, long>::operator()(at::TensorIterator&)::{lambda(long, long)#1}>, unsigned int, long, 4, 4>)": 1,
+    "triton_red_fused_add_mul_native_layer_norm_slice_split_unsqueeze_0": 32,
+    "_partials": 224,
+    "_finish": 224,
+    "_upscale": 224,
+    "kernel_cutlass_kernel_flashinferquantizationkernelsnvfp4_quantizeNVFP4QuantizeSwizzledKernel_object_at__tensorptrbf16gmemalign16o409640961_tensorptri8gmemalign16o204820481_tensorptri8gmem_0": 192,
+    "void cutlass::Kernel2<cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_128x128_32x4_nn_align8>(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_128x128_32x4_nn_align8::Params)": 224,
+    "kernel_cutlass_kernel_flashinfergemmkernelsdense_blockscaled_gemm_sm120_b12xDenseGemmKernel_object_at__CopyAtom_ThrID10_TVLayoutSrc11638401_TVLayoutDst11638401_Valuetypef4E2M1FN_tensor00o_0": 224,
+    "triton_per_fused__to_copy_mean_pow_view_1": 64,
+    "triton_poi_fused__to_copy_add_mean_mul_pow_rsqrt_select_sub_unsqueeze_view_2": 64,
+    "triton_poi_fused__scaled_dot_product_flash_attention__to_copy_cat_stack_transpose_view_3": 32,
+    "triton_poi_fused__scaled_dot_product_flash_attention__to_copy_cat_stack_transpose_view_4": 32,
+    "triton_poi_fused__scaled_dot_product_flash_attention__to_copy_cat_stack_transpose_view_5": 32,
+    "void pytorch_flash::flash_fwd_kernel<Flash_fwd_kernel_traits<128, 128, 64, 4, false, false, cutlass::bfloat16_t, Flash_kernel_traits<128, 128, 64, 4, cutlass::bfloat16_t> >, false, false, false, false, false, true, false, false>(pytorch_flash::Flash_fwd_params)": 32,
+    "triton_red_fused_add_linear_mul_native_layer_norm_slice_split_tanh_unsqueeze_view_6": 32,
+    "triton_poi_fused_linear_mul_silu_view_7": 32,
+    "kernel_cutlass_kernel_flashinferquantizationkernelsnvfp4_quantizeNVFP4QuantizeSwizzledKernel_object_at__tensorptrbf16gmemalign16o12288122881_tensorptri8gmemalign16o614461441_tensorptri8gm_0": 32,
+    "triton_poi_fused_add_mul_slice_split_tanh_unsqueeze_view_8": 32,
+    "void at::native::elementwise_kernel<128, 4, at::native::gpu_kernel_impl_nocast<at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(bool, unsigned short, unsigned short)#1}>(at::TensorIteratorBase&, at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(bool, unsigned short, unsigned short)#1} const&)::{lambda(int)#1}>(int, at::native::gpu_kernel_impl_nocast<at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(bool, unsigned short, unsigned short)#1}>(at::TensorIteratorBase&, at::native::(anonymous namespace)::where_kernel_impl(at::TensorIterator&)::{lambda()#1}::operator()() const::{lambda()#2}::operator()() const::{lambda(bool, unsigned short, unsigned short)#1} const&)::{lambda(int)#1})": 1,
+    "void at::native::(anonymous namespace)::vectorized_layer_norm_kernel<c10::BFloat16, float, false>(int, float, c10::BFloat16 const*, c10::BFloat16 const*, c10::BFloat16 const*, float*, float*, c10::BFloat16*)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::CUDAFunctorOnSelf_add<c10::BFloat16>, std::array<char*, 2ul>, false>(int, at::native::CUDAFunctorOnSelf_add<c10::BFloat16>, std::array<char*, 2ul>)": 1,
+    "void at::native::vectorized_elementwise_kernel<4, at::native::BinaryFunctor<c10::BFloat16, c10::BFloat16, c10::BFloat16, at::native::binary_internal::MulFunctor<float> >, std::array<char*, 3ul>, false>(int, at::native::BinaryFunctor<c10::BFloat16, c10::BFloat16, c10::BFloat16, at::native::binary_internal::MulFunctor<float> >, std::array<char*, 3ul>)": 1,
+    "void cutlass::Kernel2<cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_64x128_64x3_tn_align8>(cutlass_80_tensorop_bf16_s16816gemm_relu_bf16_64x128_64x3_tn_align8::Params)": 1
+  },
+  "transformer_calls": 40,
+  "full_denoising_steps": 40
+}