OrbitQuant: Data-Agnostic Quantization for Image and Video Diffusion Transformers

Donghyun Lee, Jitesh Chavan, Duy Nguyen, Sam Huang, Liming Jiang, Priyadarshini Panda, Timo Mertens, Saurabh Shukla

OrbitQuant uses a shared, rotated basis to enable calibration-free, low-bit quantization for diffusion transformers.

How can we quantize diffusion transformers without needing input-dependent calibration, which fails due to the high variance of activations across sampling steps and guidance scales?

Diffusion transformers (DiTs) are compute-intensive, but their activations shift unpredictably across timesteps and prompts, forcing existing quantization methods to rely on expensive, per-model calibration data. OrbitQuant bypasses this by rotating activations into a normalized basis where they follow a fixed, known distribution, allowing a single, precomputed codebook to quantize all layers and timesteps without any input-dependent calibration. This approach sets the state of the art for post-training quantization on image and video benchmarks, remaining functional at 2-bit weights where prior methods collapse to noise.

Paper Primer

The core mechanism is a Randomized Permuted Block-Hadamard (RPBH) rotation that maps activations to a stable marginal distribution. By folding this rotation into the weights offline, the transformation cancels out during the matrix product, leaving only a lightweight forward rotation on the activations at runtime.

OrbitQuant achieves usable generation quality at W2A4 bit-widths where prior calibration-based methods fail.

Performance on GenEval and VBench benchmarks across FLUX.1, Wan 2.1, and CogVideoX models. Maintains functional image and video generation at 2-bit weights, outperforming baselines that collapse to near-zero scores.

The method is data-agnostic and transfers across modalities without tuning.

The same Lloyd-Max codebook and RPBH rotation recipe are applied to both image and video DiTs without re-fitting. Sets state-of-the-art PTQ results on GenEval and VBench without requiring any calibration data.

Why does this approach avoid the calibration step required by other quantization methods?

Because the RPBH rotation forces activation coordinates into a fixed, known distribution regardless of the input, the quantizer can use a single, precomputed Lloyd-Max codebook that is valid for all timesteps and prompts.

What is the primary trade-off of using a rotation-based quantizer?

The method introduces a forward rotation on activations at inference time, though the RPBH structure allows this to be computed efficiently using a Fast Walsh-Hadamard Transform.

Introduction and Motivation

We expose why input‑dependent calibration destabilizes diffusion transformers and outline OrbitQuant’s data‑agnostic fix.

Diffusion Transformers (DiTs) have become the dominant backbone for high‑fidelity image and video generation, yet their inference cost is prohibitive. Each denoising step re‑evaluates the full transformer stack, and because the workload is compute‑bound even for a single batch, quantizing only the weights brings no speedup. Moreover, DiT activations drift dramatically across timesteps, prompts, and guidance branches, breaking the assumption of a fixed activation range that PTQ methods rely on.

DiT activations do not settle into a single, predictable distribution; instead they wander as the diffusion process progresses, as prompts change, and as classifier‑free guidance is applied.

OrbitQuant sidesteps the moving‑target problem by rotating activations into a data‑agnostic basis where each coordinate follows a fixed, known marginal. In this rotated space $a$ single Lloyd–Max codebook—learned offline—covers all timesteps, prompts, and layers, and the rotation can be folded into the weight rows so that only a forward RPBH rotation remains at inference.

The instability of input‑dependent calibration in diffusion models makes traditional PTQ ineffective.

Related Work

Key prior quantization approaches for diffusion transformers and their design trade‑offs.

LLM quantization splits into weight‑only schemes, which suit memory‑bound decoding, and activation‑aware schemes that must tame outlier channels.

QuaRot rotates activation vectors into a basis where their marginal distribution is nearly isotropic, making a single scalar quantizer effective for all channels.

ViDiT‑Q couples per‑channel calibration with mixed‑precision quantization across both image and video diffusion transformers.

Methods that embed a fixed orthogonal transform (Hadamard or learned) into the weight matrix so that activations become easier to quantize.

Orders channels by outlier magnitude before quantization, reducing the impact of extreme values.

Fits a permutation that balances per‑block mass, thereby suppressing block‑Hadamard outliers.

Quantizes key‑value embeddings in polar coordinates after a random rotation, using an analytically derived angular codebook.

Transforms the polar codebook back to Cartesian space with a dense Haar rotation and a Beta‑marginal Lloyd–Max codebook.

Applies a rotation‑plus‑codebook scheme inside DiT projections, using an efficient RPBH rotation and a uniformly random permutation.

Absorbs activation outliers with a high‑precision low‑rank branch fitted on a calibration set.

Balances salient channels using block reconstruction during post‑training quantization of diffusion transformers.

Fits per‑channel scales with timestep‑sensitive precision allocation for diffusion sampling.

Adds calibrated DuQuant‑style rotations on outlier‑heavy layers of diffusion transformers.

Calibrates channel reordering for per‑group quantization, improving uniformity within groups.

Selects calibration data via Hessian‑aware saliency and applies token‑level distillation for video diffusion transformers.

Quantization‑aware training (QAT) approach that jointly learns weights and quantizer parameters.

QAT method that reaches ternary weight representations on ImageNet diffusion transformers.

Data‑free rotated quantizer paired with grid refinement and adaptive bit allocation, specialized for video diffusion transformers.

Combines calibration‑free group‑wise Hadamard rotations with a uniform grid on the FLUX model.

Foundations

Defines notation and introduces the TurboQuant rotation‑based quantizer.

We first fix the notation used throughout and recap the two ingredients inherited from TurboQuant [51]: a Haar‑random orthogonal rotation and a Lloyd–Max scalar codebook.

TurboQuant quantizes a vector without any calibration data by rotating it into a basis where each coordinate follows a known distribution, then snapping each coordinate to the nearest entry of a pre‑computed codebook.

Compute the norm $\|\mathbf{x}\|_2=\sqrt{3^2+4^2}=5$ and obtain the unit direction $\tilde{\mathbf{x}}=(0.6,\,0.8,\,0,\,0)$.

Apply an identity rotation (for illustration) $\Phi_4\tilde{\mathbf{x}}=\tilde{\mathbf{x}}$; each coordinate now follows $f_4(t)$.

Quantize each coordinate: $0.6\to 0.5$, $0.8\to 1$, $0\to 0$, $0\to 0$ using $\hat{q}_{4,2}$.

Reconstruct the quantized vector $\hat{\mathbf{u}}=(0.5,\,1,\,0,\,0)$, rotate back (identity) and rescale by the stored norm $5$: $\hat{\mathbf{x}}=5\cdot\hat{\mathbf{u}}=(2.5,\,5,\,0,\,0)$.

This toy example shows how a data‑agnostic rotation lets a single, tiny codebook approximate the distribution of any activation, regardless of its original scale.

How does TurboQuant differ from a naïve per‑layer scalar quantizer?

Naïve quantizers learn a separate scale and zero‑point for each layer, tying the codebook to the layer’s statistics. TurboQuant instead uses a data‑agnostic rotation to force every coordinate into a fixed distribution, allowing one pre‑computed Lloyd–Max codebook to be shared across all layers and dimensions.

Methodology Overview

OrbitQuant’s core trick: a shared random rotation lets a single quantizer work for all inputs.

Diffusion transformers’ activations drift wildly across sampling steps and classifier‑free guidance scales, so a calibration computed on one input fails on the next.

RPBH scrambles each activation vector with a random permutation and then applies a block‑Hadamard transform, producing an orthogonal basis that looks statistically identical for every weight row.

Input vector $v=[v_0,v_1,v_2,v_3]$ is permuted to $v^{(p)}=[v_2,v_0,v_3,v_1]$.

Apply $H_4$: $v' = H_4\,v^{(p)} = \frac{1}{2}[v_2+v_0+v_3+v_1,\;v_2-v_0+v_3-v_1,\;v_2+v_0-v_3-v_1,\;v_2-v_0-v_3+v_1]$.

Norm is preserved: $\|v'\|_2 = \|v\|_2$ because $H_4$ is orthogonal.

The random permutation decorrelates any fixed pattern in the weight rows, while the Hadamard spreads energy uniformly, yielding coordinates that behave like independent samples from $f_d$.

How does RPBH differ from a plain Hadamard transform?

A plain Hadamard applies the same fixed orthogonal matrix to every vector. RPBH first shuffles dimensions with a random permutation, then applies the Hadamard, so each row of the resulting matrix is a different random orthogonal basis. This breaks any deterministic alignment with the original weights.

After rotation, every coordinate of a weight row or activation direction follows the same marginal $f_d$, so a single scalar Lloyd‑Max codebook per dimension quantizes them all without looking at the data.

Unit direction $\tilde{w}'=[0.6,0.8]$ is projected onto the first axis: $0.6$.

Nearest centroid is $0.75$, so quantized value $q_1=0.75$.

Second axis $0.8$ → nearest centroid $0.75$, quantized value $q_2=0.75$.

Re‑assemble quantized direction $\hat{w}'=[0.75,0.75]$ and renormalize if needed.

The quantized direction is no longer the exact original unit vector, but because both axes are drawn from the same marginal, the error distribution is identical to the optimal scalar quantizer for $f_2$.

Why can a single Lloyd‑Max codebook serve all layers, timesteps, and prompts?

After the RPBH rotation every coordinate follows the same marginal $f_d$, independent of the original weight values or the diffusion step. Lloyd‑Max is optimal for that marginal, so the same codebook yields minimal MSE everywhere; no per‑layer fitting is required.

**Figure 2. Overview of OrbitQuant.** (1) DiT activations drift across timesteps and CFG branches, so calibrated scales do not transfer. (2) The RPBH rotation $\Pi_d$ maps raw activations to well-behaved coordinates. Folded into the weights, it cancels inside each layer $\hat{W}' \tilde{x}' \approx (W \Pi_d^\top)(\Pi_d x) = Wx$. (3) Rotated coordinates concentrate around one fixed marginal $f_d \approx \mathcal{N}(0, 1/d)$, so a single Lloyd-Max codebook $\mathcal{C}_{d,b}$ per dimension serves all layers, timesteps, prompts, and both image and video DiTs, with no calibration.

For each input dimension $d\in\mathcal{D}$ compute the RPBH matrix $\Pi_d$.

Rotate each target weight matrix: $W' = W\,\Pi_d^\top$.

For every row $w'_i$ of $W'$, compute its norm $r'_i=\|w'_i\|_2$ and unit direction $\tilde{w}'_i = w'_i / r'_i$.

Quantize each $\tilde{w}'_i$ with the pre‑computed Lloyd‑Max codebook $\hat{Q}(d)$.

Re‑attach the stored norm: $\hat{W}' = \operatorname{diag}(r')\;\hat{Q}(d)$.

Replace the original weight $W$ in the transformer with $\hat{W}'$.

Rotate incoming activation tokens: $x' = x\,\Pi_d^{\top}$.

Compute per‑token norm $s = \|x'\|_2$.

Normalize to unit direction $\tilde{x}' = x'/(s+\varepsilon)$ (with tiny $\varepsilon$ to avoid division by zero).

Quantize $\tilde{x}'$ using the same Lloyd‑Max codebook $\hat{Q}(d)$.

Rescale the quantized direction by the stored norm: $\hat{x}' = s \cdot \hat{Q}(d)(\tilde{x}')$.

**Algorithm 1** OrbitQuant offline weight patching and online activation quantization **Require:** Transformer $\mathcal{T}$, target layers $\mathcal{L}$, input dimensions $\mathcal{D}$, bit-widths $(b_w, b_a)$, clamp $\varepsilon$ 1: $\triangleright$ **Offline** 2: **for** $d \in \mathcal{D}$ **do** 3: $\quad \Pi_d \leftarrow \text{RPBH}(d)$ 4: $\quad \hat{Q}_{b_w}^{(d)}, \hat{Q}_{b_a}^{(d)} \leftarrow \text{LLOYDMAX}(d, b_w), \text{LLOYDMAX}(d, b_a)$ 5: **end for** 6: **for each** $\mathbf{W} \in \mathcal{L}$ with input dim $d$ **do** 7: $\quad \mathbf{W}' \leftarrow \mathbf{W}\Pi_d^\top$ 8: $\quad r_i' \leftarrow \|\mathbf{w}_i'\|_2, \quad \tilde{\mathbf{w}}_i' \leftarrow \mathbf{w}_i'/r_i' \quad \text{for } i = 1, \dots, m$ 9: $\quad \hat{\mathbf{W}}' \leftarrow \text{diag}(\mathbf{r}') \hat{Q}_{b_w}^{(d)}(\tilde{\mathbf{W}}')$ 10: $\quad \text{Replace } \mathbf{W} \text{ by } \hat{\mathbf{W}}' \text{ in } \mathcal{T}$ 11: **end for** 12: $\triangleright$ **Online** on tokens $\mathbf{x} \in \mathbb{R}^{N \times d}$ 13: $\mathbf{x}' \leftarrow \mathbf{x}\Pi_d^\top$ 14: $s \leftarrow \|\mathbf{x}'\|_2, \quad \tilde{\mathbf{x}}' \leftarrow \mathbf{x}'/(s + \varepsilon)$ 15: $\hat{\mathbf{x}}' \leftarrow s \cdot \hat{Q}_{b_a}^{(d)}(\tilde{\mathbf{x}}')$ 16: **return** $\hat{\mathbf{x}}'$

Algorithm Details

We detail the RPBH rotation, permutation, and data‑agnostic codebook that enable calibration‑free quantization.

Post‑training quantization of diffusion transformers fails because activation variances explode across sampling steps and guidance scales. This variance makes any input‑dependent calibration brittle, causing severe accuracy loss at low bit‑widths. OrbitQuant eliminates the brittleness by rotating activations into a basis whose marginal distribution is fixed by the dimension alone.

Before inference we replace each weight matrix with a rotated version that already matches the target marginal, then store a single codebook per dimension for all subsequent quantization.

How does Offline Weight Patching differ from a naïve per‑layer quantizer that learns a separate codebook for each weight matrix?

Naïve per‑layer quantizers must collect activation statistics for every layer and store many codebooks, which scales linearly with model size. Offline Weight Patching instead rotates all weights into a common marginal, allowing a single codebook $C_d$ per dimension to serve every layer, weight row, and even activation tensor.

Choose block size $h=2$ (largest power of two dividing $d_{\text{in}}$) and generate a random sign diagonal $D_1=\operatorname{diag}(+1,-1)$, $D_2=\operatorname{diag}(-1,+1)$.

Form the block‑Hadamard matrices $H_2=\begin{bmatrix}1&1\\1&-1\end{bmatrix}$ and compute each block $H_2 D_i$.

Pick a random permutation $\pi=(3,1,4,2)$ and build $P_\pi$.

Assemble $\Pi_4 = \operatorname{blkdiag}(H_2 D_1, H_2 D_2)\,P_\pi$, yielding a $4\times4$ orthogonal matrix.

Rotate the weights: $W' = W\,\Pi_4^{\!\top}$, producing a matrix whose rows now follow the marginal $f_4$.

Run Lloyd–Max on $f_4$ (e.g., 4‑centroid codebook $C_4=\{-0.6, -0.2, 0.2, 0.6\}$) and replace each entry of $W'$ with its nearest centroid, obtaining $\widetilde{W}$.

Because the rotation is orthogonal, the functional mapping $x\mapsto Wx$ is unchanged; only the representation of the weights is altered, enabling a single, dimension‑specific codebook to quantize every weight.

During inference each activation vector is normalized, rotated by the same $\Pi_d$, and then quantized with the pre‑computed codebook $C_d$, all without looking at the current input.

Why does Online Activation Quantization not require an inverse rotation before the next layer?

The downstream weight matrix has already been pre‑rotated by $\Pi_d^{\!\top}$ during Offline Weight Patching. Consequently, the forward rotation applied to the activation aligns it with the rotated weight, and the matrix multiplication can be performed directly on the quantized vector.

Normalize: $\|a\|_2\approx2.2$, so $\hat{a}=a/2.2\approx[0.23,-0.55,0.14,0.00,0.36,-0.18,0.50,-0.32]$.

Choose block size $h=4$, generate random signs $D_1=\operatorname{diag}(+1,-1,+1,-1)$, $D_2=\operatorname{diag}(-1,+1,-1,+1)$.

Apply permutation $\pi=(5,2,8,1,3,6,4,7)$ to obtain $P_\pi\hat{a}$.

Perform two Fast Walsh–Hadamard transforms on the permuted blocks, yielding $z\approx[0.12, -0.08, 0.45, -0.30, 0.22, -0.15, 0.38, -0.10]$.

Quantize each coordinate to the nearest centroid from a 4‑level codebook $C_8=\{-0.4,-0.1,0.1,0.4\}$, producing $\tilde{z}=[0.1,-0.1,0.4,-0.3,0.2,-0.1,0.4,-0.1]$.

The permutation spreads the original outlier (the large 1.1 component) across blocks, so no single coordinate dominates the quantization error.

Let $\Pi_d$ be the RPBH rotation of Equation (9) on $d=k\,h$ with $k$ blocks of size $h$, and let $\tilde{x}$ be any fixed unit vector with $\mu_\infty=\|\tilde{x}\|_{2}^{\infty}$. For every $\delta\in(0,1)$, with probability at least $1-\delta$ over the random permutation $\pi$, every coordinate $z_i$ of $\Pi_d\tilde{x}$ satisfies $$ \operatorname{Var}(z_i\mid\pi)\in\Bigl[\frac{1-\rho}{d},\;\frac{1+\rho}{d}\Bigr], \qquad \rho=\frac{d\,\mu_\infty}{2h\,\log\!\bigl(\tfrac{4k}{\delta}\bigr)}. $$

**Figure 3.** Rotated activation coordinates follow the dimension marginal $f_d$. For (a) an attention projection ($d=3072$) and (b) a feed-forward projection ($d=12288$) of FLUX.1-schnell, each cell plots the distribution of activation tokens with no rotation (Raw), a dense Haar rotation, and the RPBH. The dashed curve is the target $\mathcal{N}(0, 1/d)$ and the inset reports the Kolmogorov–Smirnov distance to it. The light red vertical ticks mark the bin edges of the shared Lloyd-Max $W4$ codebook, which is fit to $f_d$ and reused for both weights and activations.

Experimental Setup

Key quantitative results and the experimental configuration.

OrbitQuant attains the highest Overall scores in the W2A4 regime across all three image diffusion transformers.

Table 1 shows OrbitQuant achieving 0.481 (FLUX.1‑schnell) and 0.194 (Z‑Image‑Turbo), each exceeding every competing method at the same bit‑width.

Experiments span three image diffusion transformers (FLUX.1‑schnell, FLUX.1‑dev, Z‑Image‑Turbo) and two video transformers (Wan 2.1‑1.3B, CogVideoX‑2B) across the bit‑width configurations W4A4, W2A4 (images) and W4A6, W4A4 (videos).

**Table 1.** GenEval results on three image diffusion transformers at W4A4 and W2A4. Values are scores on six compositional sub-tasks and Overall. Bold and underlined entries indicate the best and second-best result within each (model, bit-width) group. $\uparrow$ means higher is better. $\dagger$ represents our implementation.

Quantitative Results

OrbitQuant delivers state‑of‑the‑art quantized diffusion generation across image and video benchmarks.

Recall that OrbitQuant replaces activation‑dependent calibration with a data‑agnostic rotated basis, stabilizing quantization for diffusion transformers.

OrbitQuant sets a new state‑of‑the‑art across all GenEval image tasks and VBench video consistency, beating every PTQ baseline.

On FLUX.1‑schnell and Z‑Image‑Turbo it surpasses FP16 overall; on FLUX.1‑dev it is only 0.034 lower, while all other PTQ methods collapse near zero at low bit‑widths.

**Figure 1.** Qualitative comparison of OrbitQuant against QuaRot [2] and ViDiT-Q [53] under low-bit quantization, with the BF16 full-precision output. (a) Image generation on FLUX.1-dev at W3A4, W3A3, and W2A4. (b) Video generation on Wan 14B at W4A4.

**Figure 5.** Latency and peak memory together, with lower-left being better. The left panel is image generation on FLUX.1-dev, the right panel video on Wan 2.1-1.3B.

Qualitative Results

OrbitQuant matches full‑precision visual quality while other PTQ methods degrade.

OrbitQuant attains the highest overall consistency (98.01 %) among PTQ methods, matching the BF16 baseline.

Table 2 reports OrbitQuant’s overall consistency of 98.01 % versus lower scores for competing methods.

**Figure 4.** Qualitative comparison of OrbitQuant against QuaRot [2] and ViDiT-Q [53], with the BF16 full-precision output shown for reference. (a) Image generation at W3A3 on FLUX.1-dev, FLUX.1-schnell, and Z-Image-Turbo, with one prompt per model. (b) Video generation at W4A4 on Wan 14B, showing three sampled frames per method.

Ablations and Conclusion

Ablation studies quantify the impact of rotation choices and AdaLN precision on quantization performance.

We isolate the contribution of each design choice by removing or altering it while keeping the rest of the OrbitQuant pipeline fixed.

RPBH rotation yields the best low‑bit performance, adding only 0.070 s latency over Block‑RHT and running ~26× faster than dense Haar.

Table 3 shows RPBH dominates at W3A3 and W2A4, while dense Haar cannot be accelerated with a fast Hadamard kernel.

**Table.** Quantitative comparison of different quantization methods on video generation models.

Quantizing AdaLN weights to INT4 preserves overall quality, but lowering to W2 causes a collapse on FLUX models.

Figure 6 shows GenEval Overall remains stable at INT4, then drops sharply for FLUX‑schnell and FLUX‑dev when AdaLN weights are reduced to W2.

**Figure 6.** AdaLN bit-width ablation with the main model fixed at W4A4 and AdaLN activations in BF16. The left panel reports GenEval Overall as the AdaLN modulation weight bit drops. The right panel reports model compression on the FLUX architecture with the AdaLN weights in BF16 (2.21×) and in INT4 (4×).

Overall, the ablations confirm that the random permutation in RPBH is essential for low‑bit stability and that fixing AdaLN weights at INT4 offers the best compression‑quality balance.

Supplementary Proofs

Formal proof of the RPBH rotation’s incoherence and variance bounds.

Setup. Fix a unit vector $\tilde{x}\in\mathbb{R}^d$ and write $d = k h$. Let $y = P_{\pi}\tilde{x}$ have blocks $y^{(j)}\in\mathbb{R}^h$ with masses $M_j = \|y^{(j)}\|_2^2$ summing to 1, and outputs $z^{(j)} = H_h D_j y^{(j)}$ with $\|y^{(j)}\|_2 \le 1$ and $(H_h)_{i\ell} = \pm 1/\sqrt{h}$. Write $z = (z^{(1)},\dots,z^{(k)})$ for the full output $\Pi_d\tilde{x}$.

Proposition 1 follows by intersecting the high‑probability events of Lemmas 1 and 2; on that intersection every coordinate of $z=\Pi_d\tilde{x}$ is mean‑zero with variance $\frac{1}{d}(1\pm\rho)$, and the infinity‑norm bound (13) holds. Lemma 1 alone requires only $M_j\le1$, so it is valid with or without the permutation, whereas Lemma 2 is the only place the permutation $\pi$ matters, equalising the block masses and enabling the tight variance guarantee that the no‑permutation variant loses at low bit‑width.

Supplementary Experiments

Supplementary experimental settings, quantization details, and extended results.

Remark 2 upgrades the variance‑concentration argument to a quantitative Gaussian approximation. Conditioned on $\\pi$, each coordinate $z_i$ in block $j$ sums $h$ bounded terms with variance $M_j/h$, and the Berry–Esseen inequality bounds its Kolmogorov distance to $\\mathcal{N}(0, M_j/h) \\le C\\,\\mu_\\infty/M_j$; under Lemma 2 this is at most $C\\,\\mu_\\infty\\,k/(1-\\rho)$, so every rotated coordinate is close to $\\mathcal{N}(0,1/d)$ in distribution, not merely in variance. Figure 3 confirms this empirically.

B.1 lists the sampling configurations used for all experiments. Image models run the public checkpoints: FLUX.1‑schnell with 4 steps and guidance $0.0$, FLUX.1‑dev with 50 steps and guidance $3.5$, and Z‑Image‑Turbo with 10 steps and guidance $0.0$. Video models use Wan 2.1‑1.3B at 81 frames, $480\\times832$, 50 steps, CFG $5.0$, and CogVideoX‑2B at 49 frames, $480\\times720$, 50 steps, CFG $6.0$, all on NVIDIA H100 GPUs.

B.2 details which transformer components are quantized through the OrbitQuant path. Every linear projection—query, key, value, and output matrices in both image and text branches, as well as feed‑forward layers—receives INT4 RTN weights (group size 64) and BF16 activations, except for AdaLN modulation projections which remain in BF16 because their dynamic, timestep‑dependent scale‑and‑shift cannot be folded into neighboring weights. Embeddings, the timestep MLP, the final un‑patchify head, and the text encoder also stay in BF16.

**Table.** VBench per-dimension scores for Wan 2.1-1.3B and CogVideoX-2B models.

**Table 5.** VBench results on Wan 14B at W4A4. Per-dimension scores over eight VBench dimensions. Bold and underlined entries indicate the best and second-best PTQ result. QVGen is a QAT method, shown for reference and excluded from the PTQ ranking. $\uparrow$ means higher is better. $\dagger$ represents our implementation.

Additional Experiments

Extra low‑bit and video‑generation tests probe OrbitQuant against baselines.

Section C.1 pushes the quantization limits to 3‑bit weights and activations (W3A3) and to 2‑bit weights with 3‑bit activations (W2A3) on three diffusion transformers. At W3A3 OrbitQuant outperforms SVDQuant and AdaTSQ, keeping Overall scores close to FP16, while SVDQuant collapses on Z‑Image‑Turbo. At the harsher W2A3 setting the rotation‑ and smoothing‑baseline methods drop to near‑zero performance, and only OrbitQuant stays usable, except for a sharp degradation on Z‑Image‑Turbo.

Section C.2 evaluates OrbitQuant on two large video diffusion models (Wan 14B and HunyuanVideo) using the W4A4 setting. Table 6 reports seed‑robustness, while Table 7 presents detailed consistency scores across several visual criteria. The results show that Z‑Image‑Turbo achieves the highest overall consistency (0.767), but OrbitQuant remains competitive and notably outperforms many QAT baselines.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers