Your diagnosis is essentially correct. For normal E4M3 values, scaling changes the exponent window but barely changes relative precision: the three mantissa bits remain the bottleneck. Block scaling mainly prevents overflow, underflow and domination by outliers. This is consistent with broader FP8 evaluations finding E3M4 marginally better than E4M3 for computer-vision models. ([arXiv][1])

The best lightweight options are therefore quantizer-aware reconstruction methods, rather than more elaborate scale calibration.

### 1. Activation-weighted scale search followed by FP8-GPTQ

This would be my default.

For each weight tile (W_b), collect calibration inputs (X_b) and choose its scale using the actual output-error objective:

[
s_b^*=\arg\min_s
\left|X_b\left(W_b-s,Q_{\mathrm{E4M3}}(W_b/s)\right)^T\right|_F^2 .
]

The cheap diagonal approximation is:

[
\sum_{i,j} h_j
\left(w_{ij}-sQ_{\mathrm{E4M3}}(w_{ij}/s)\right)^2,
\qquad
h_j=\mathbb{E}[x_j^2].
]

Search a logarithmic grid of valid scales rather than using absmax. Then run GPTQ’s sequential Hessian-error compensation, replacing its integer projection with nearest-E4M3 projection. The final weights remain exactly E4M3 plus your existing block scales; only the offline quantisation procedure changes. GPTQ’s second-order error feedback is quantiser-agnostic in principle, although most implementations assume a uniform integer grid. ([arXiv][2])

For a 64×64 tile scheme:

1. Fix or search the tile scale.
2. Compute (H=X^TX+\lambda I) for its 64 input dimensions.
3. Quantise columns sequentially to E4M3.
4. Propagate each quantisation residual through (H^{-1}).
5. Optionally re-search the tile scale and repeat once.

This should provide the best accuracy-to-engineering-effort ratio.

### 2. FP8-adapted AdaRound or BRECQ

When GPTQ is insufficient, optimise the rounding decisions themselves.

For each scaled weight (z=w/s), find the adjacent E4M3 codepoints (q_{\mathrm{lo}}) and (q_{\mathrm{hi}}), then learn a soft binary choice:

[
\hat w=s\left(q_{\mathrm{lo}}+
g(\alpha)(q_{\mathrm{hi}}-q_{\mathrm{lo}})\right).
]

Optimise (g(\alpha)) against layer or transformer-block reconstruction error and harden it to either endpoint afterwards. This is the non-uniform-codebook equivalent of AdaRound. BRECQ extends that idea to block reconstruction, which is generally more appropriate for a ViT because it captures interactions between attention and MLP projections. Both methods use modest calibration data without end-to-end retraining. ([Proceedings of Machine Learning Research][3])

Implementation detail: build the finite E4M3 values as a sorted FP32 lookup table and use binary search for adjacent codepoints. Do not model FP8 rounding as a globally uniform step.

For SigLIP, reconstruct complete transformer blocks and include a loss on the final normalised image embedding, for example:

[
L=L_{\text{block-MSE}}
+\beta\left(1-\cos(e_{\mathrm{FP}},e_{\mathrm{FP8}})\right).
]

A vision-specific relative of this approach is ERQ, which combines rounding refinement and blockwise regression. Its published quantiser is uniform, but its reconstruction procedure is applicable to an E4M3 projector. ([arXiv][4])

### 3. AWQ or RepQ-style channel equalisation

Before block quantisation, apply an exact diagonal reparameterisation:

[
x'=xD^{-1},\qquad W'=WD,
]

then quantise (W'). Select (D) using activation RMS or a small grid search. This redistributes error away from highly active input channels and can make each 64×64 block more homogeneous.

AWQ uses activation statistics and equivalent channel scaling without backpropagation. RepQ-ViT is particularly relevant because it targets the severe inter-channel variation around LayerNorm in vision transformers and folds the reparameterisation into an inference-friendly model. ([arXiv][5])

This is nearly free at deployment when folded into LayerNorm affine parameters and every consumer of that LayerNorm output. It is most useful when your blocks contain channels with very different RMS values. It will not fix ordinary E4M3 mantissa noise within an already well-balanced block.

### 4. OmniQuant-style learned clipping and equivalent transforms

A middle ground between scale search and full BRECQ is to optimise only:

* one or two clipping/scale parameters per tile;
* diagonal channel transformations;
* optionally channel shifts around LayerNorm.

Use fake-E4M3 quantisation with a straight-through gradient and minimise transformer-block reconstruction loss. OmniQuant’s LWC and LET components follow exactly this small-parameter, block-at-a-time approach and introduce no additional inference parameters after folding. ([arXiv][6])

For E4M3, I would emphasise the equivalent transformations rather than clipping. Clipping only helps materially when a small number of weights force the rest of the tile towards subnormal values or zero.

### Lower-priority approaches

SmoothQuant is not the natural choice for weight-only FP8. It deliberately transfers quantisation difficulty from activations into weights; that can worsen the part you are currently struggling with. It becomes relevant when activations are also being quantised. ([arXiv][7])

QuaRot, SpinQuant, FlatQuant and OSTQuant can all precede an E4M3 projector, but their main advantage is suppressing outliers for very low-bit weight-and-activation quantisation. With E4M3 weights and 64×64 scaling, rotations generally only help if you can demonstrate significant block underflow, overflow or directional outliers. Otherwise they add model surgery or runtime fusion complexity without addressing the three-bit mantissa directly. ([arXiv][8])

My recommended progression is:

1. Activation-weighted tile-scale search.
2. FP8-GPTQ with fixed tile scales.
3. AWQ/RepQ-style equalisation where channel RMS variance is high.
4. FP8 AdaRound/BRECQ only on blocks identified as sensitive.
5. Add output-mean bias correction after each reconstructed linear layer.

That pipeline preserves E4M3 weight storage throughout and targets rounding decisions and functional error—the two areas where block scaling alone cannot recover precision.

[1]: https://arxiv.org/abs/2309.14592?utm_source=chatgpt.com "Efficient Post-training Quantization with FP8 Formats"
[2]: https://arxiv.org/abs/2210.17323?utm_source=chatgpt.com "GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers"
[3]: https://proceedings.mlr.press/v119/nagel20a.html?utm_source=chatgpt.com "Up or Down? Adaptive Rounding for Post-Training Quantization"
[4]: https://arxiv.org/abs/2407.06794 "[2407.06794] Towards Accurate Post-Training Quantization of Vision Transformers via Error Reduction"
[5]: https://arxiv.org/abs/2306.00978?utm_source=chatgpt.com "AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration"
[6]: https://arxiv.org/html/2308.13137v3 "OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models"
[7]: https://arxiv.org/abs/2211.10438?utm_source=chatgpt.com "SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models"
[8]: https://arxiv.org/abs/2404.00456?utm_source=chatgpt.com "QuaRot: Outlier-Free 4-Bit Inference in Rotated LLMs"