PTQ Configuration Pricing: Predicting the Quantization Price Before You Build the Model

A September 2026 paper attacks a sequencing problem at the heart of weight-space post-training quantization (PTQ): every consequential decision — finite format, granularity, quantizer family, pre-quantization transformation, bitwidth — must be made before the completed quantized model exists to reveal its output-distribution drift¹. Predicting Quantization Price for Selecting PTQ Configurations Before Deployment (Qiu, Mu, Zhang and Shu, arXiv:2609.28270, cs.CL, submitted September 23, 2026) responds by constructing a price: each admissible layer configuration is an error generator that induces a layer-output error covariance, and the full-precision (FP) reference model prices that covariance by its downstream curvature,

ρ̂_l(α_l) = 1/2 · Tr(Ĥ_l · Σ̂_l(α_l)),

the first retained term of a forward-KL expansion whose linear term cancels exactly at the reference model¹.

The critical framing matters more than the formula. This is not a new quantizer — the paper builds no rounding scheme, no rotation, no codebook. It is a pre-deployment pricing model: a common currency in which an integer 4-bit scalar format, a group-64 granularity, a Hadamard rotation, and a vector codebook can be ranked against each other before any of them is deployed, with a deployment-cost constraint attached¹. Like HAWQ's Hessian-aware allocation lineage before it, it prices sensitivity rather than fixing weights². The honest scope is equally central: the price is first-order (quadratic) in the injected error, priced per layer against a block-diagonal curvature surrogate, and valid only where higher-order effects and cross-layer coupling stay small — which is precisely where the paper's own evidence is collected and where its selectors win¹.

This guide decomposes the pricing chain — target drift, the cancellation theorem, the proxy reductions it subsumes, the trace-score shortcut — reproduces the trace structure in a runnable Python toy where two candidates with identical reconstruction error differ nine-fold in priced cost, and then prices the boundaries: what first order can and cannot buy.

1. The decision: rank configurations you have not built

The paper's setup makes the deployment stack, not the researcher, the supplier of choices. A layer l has an admissible set A_l of configurations α_l — bitwidth, granularity, quantizer family, hardware format, pre-quantization transformation, or a supported combination — and a deployment cost κ_l(α_l) that decomposes into bits, metadata, and kernel terms (κ_bits + κ_meta + κ_kernel). A full configuration α = (α_1, …, α_L) produces the quantized model with output distribution π_α(·|x), and the quantity to control is the FP-to-quantized forward KL drift, averaged over the calibration distribution:

J(α) = E_x[ KL( π_0(·|x) ‖ π_α(·|x) ) ].

The ideal decision is a constrained program: minimize J(α) subject to Σ_l κ_l(α_l) ≤ B. But evaluating J(α) requires the completed quantized model — which is exactly what has not been built. Exhaustive deployment trials are usually impossible, and the paper's diagnosis of prior work is that each family scores only the piece it controls: reconstruction methods (GPTQ, OBQ, BRECQ, QuIP and friends) reduce local weight error after the geometry is fixed; Hessian-sensitivity methods allocate precision under fixed geometry; transformation methods (SmoothQuant, AWQ, QuaRot, SpinQuant, QuaRot-style rotations) each reshape their own coordinate; end-loss methods (GuidedQuant, YAQA) bring in downstream loss but inside their own loop¹. What is missing is one pre-deployment price comparing bits, granularities, codebooks, and transformations as instances of the same decision¹.

Two structural choices deserve emphasis. First, transformations enter as equivalent coordinate changes: the candidate coordinate satisfies W(α)X(α) = WX exactly in floating point, so a rotation or scaling changes where finite-format error is generated, not what the FP layer computes. Second, cost is not accuracy: κ records only deployability (storage, metadata overhead, online kernels), and the budget constraint decides which priced candidates are reachable at all¹.

2. The price: what cancels, and why

The derivation starts from the forward KL viewed as a function of a single layer's output z_l, with the rest of the network at the FP reference. Quantization at layer l produces a replacement weight Ŵ_l(α_l) = W_l(α_l) + Δ_l(α_l), which injects the error Δ_l(α_l) x_l(α_l) at the layer output. Two statistics price it¹:

• Curvature (reference side): H_l is the expectation over the calibration distribution of the Hessian of the per-sample forward-KL drift with respect to the layer output, evaluated at the reference output z_l = W_l x_l.
• Error covariance (candidate side): Σ_l(α_l) = Δ_l(α_l) C_l(α_l) Δ_l(α_l)⊤, where C_l is the input covariance of the (possibly transformed) candidate coordinate.

Theorem 3.1 then states that under three-times differentiability of the KL objective along the weight segment from the reference to the candidate, the drift decomposes as J(α) = ρ(α) + r(α), with the quadratic price ρ(α) = Σ_l ρ_l(α_l) and ρ_l = 1/2 Tr(H_l Σ_l(α_l)), and the remainder r(α) bounded relative to the price by a term η(α) built from the gap between the exact and retained block-diagonal Hessian plus a third-derivative bound along the perturbation segment¹.

The cancellation deserves to be stated plainly, because it is the whole trick. The forward KL from the FP model to any perturbed model vanishes at the reference — π_0 against π_0 is zero — and so does its first derivative along the perturbation direction: the FP model is a stationary point of the KL to itself. Taylor expansion around the reference therefore has no linear term, and the first contribution that survives is the quadratic one. That quadratic, assembled per layer, is exactly 1/2 Tr(H_l Σ_l): the candidate supplies the covariance, the reference supplies the curvature that makes some error directions expensive. In implementation, a PSD Gauss-Newton surrogate can replace H_l — the formal object priced stays the covariance¹.

This is the same structural insight that powered HAWQ-style mixed precision — second-order sensitivity of the loss surface picks which layers can afford coarse formats² — generalized from one fixed geometry to the whole configuration menu.

3. What the paper buys with the price: proxy reductions as siblings, not competitors

The price formula's most corrosive move is against proxies, and it is worth quoting as a decomposition rather than a competition. The full layer price is 1/2 Tr(H Δ_W C Δ_W⊤). Substitutions generate familiar scores¹:

• Reconstruction score (H → I): ρ_rec = 1/2N ‖Δ_W X‖²_F — exactly the layer-output squared error that GPTQ-family objectives minimize. It is the price with downstream output curvature dropped.
• Diagonal score (also C → diag(C)): an input-column-weighted squared weight error. It additionally drops cross-channel input covariance.

The paper's own characterization: these reductions preserve candidate rankings only when the dropped factors are effectively constant over the candidate set being compared¹. Compare two bitwidths of the same uniform format in the same coordinate, and the curvature factor is constant — reconstruction is fine. Compare a scaling against a rotation against a codebook, and the dropped factors move with the candidates; the reduced scores are then silent precisely where a configuration selector needs them. The runnable toy in Section 5 makes this concrete: two candidates with identical reconstruction score whose priced costs differ by a factor of nine.

For finite formats, the paper converts formats into the moments being priced rather than treating the 4^-b bit law as fundamental. Under the usual zero-mean uniform rounding envelope, the expected price obeys E[ρ̂_l(α_l)] ≤ 1/2 h_l⊤ V_l(α_l) c_l — diagonals of curvature and input covariance sandwiching the perturbation moment envelope V_l — and for a per-layer uniform range r_l this specializes to E[ρ̂_l(b)] ≤ r_l² / (6 L_b²) · Tr(H_l) Tr(C_l) with L_b = 2^b − 1. The 4^-b decay "is not a standalone allocation law"; it appears only after the format has been converted into the perturbation moment being priced¹.

For transformations, the coordinate change P acts on both factors the candidate controls: the quantization residual of W P⁻¹ and the transformed input covariance P C P⊤. A clean structural result (Theorem 3.3) prices what fully-optimized affine preprocessing can do: among determinant-preserving input transformations, the smallest achievable worst-direction variance of P C P⊤ is (det C)^(1/n), attained exactly by whitening¹. And its twin negative result explains rotations: orthogonal R C R⊤ preserves the eigenvalues of C, so rotations cannot flatten the input metric — they help through the transformed-weight residual, range, or coherence instead. The reference-side H never moves.

4. The shortcut: two scalars and a cached trace

The covariance-level price is the definition; the deployed statistic is cheaper. When a candidate's coordinate and perturbation moment are close to isotropic (as after effective transformations), the price reduces to ρ_l ≈ 1/2 σ_l²(α_l) ω_l(α_l) Tr(H_l), where σ² is the average input variance in the candidate coordinate, ω the average perturbation scale of Δ_l, and Tr(H_l) a reference-side quantity cached once per layer — in large models estimated directly by a Hutchinson-type PSD Gauss-Newton trace estimator rather than by forming Ĥ_l at all¹.

Note what this reduction does not do: it does not substitute H with an identity, the way reconstruction does. It keeps the output metric through its trace only after the candidate side has been made nearly isotropic¹. The deployed score is then

ρ̂_l(α_l) = 1/2 · σ̂_l²(α_l) · ω̂_l(α_l) · τ̂_l, τ̂_l = Tr(Ĥ_l),

and the selector solves the budgeted problem min_α Σ_l ρ̂_l(α_l) s.t. Σ_l κ_l(α_l) ≤ B over the admissible sets — a calibration-time table of prices and costs replacing expensive model-level trials, with fixed-geometry bit allocation recovered only as the special case where transformation, family, and granularity were already frozen¹. On a per-layer trace-reduction toy below, the surrogate sits within about 30% of the full-covariance price at 4 bits — the paper's own controlled studies show the reduced statistic preserves orderings, at the price of that gap.

5. Runnable toy: the trace structure, and what reconstruction cannot see

The following self-contained Python cell (standard library only, seed fixed, locale-agnostic) builds a 4-by-3 layer, a fixed calibration input covariance C, a PSD downstream curvature H with one dominant direction, and two things: (1) uniform 2/3/4-bit prices under the full H, a diagonal-only H, and the reconstruction surrogate H → I; (2) two candidates that inject the same layer-output error magnitude — identical reconstruction scores — one aligned with the expensive curvature direction, one orthogonal to it.

import random
 
random.seed(7)
 
# --- a tiny layer: 3 input channels, 4 output channels --------------------
n, m = 3, 4
W = [[random.gauss(0, 1) for _ in range(n)] for _ in range(m)]
X = [[random.gauss(0, 1) for _ in range(200)] for _ in range(n)]  # calibration batch
N = 200
 
# input covariance C = (1/N) X X^T in the reference coordinate
C = [[sum(X[i][k] * X[j][k] for k in range(N)) / N for j in range(n)] for i in range(n)]
 
def uniform_q(bits):
    r = max(abs(w) for row in W for w in row)   # per-tensor range
    s = 2 * r / (2**bits - 1)                   # step size (Eq. 4 style)
    return [[round(W[i][j] / s) * s for j in range(n)] for i in range(m)]
 
def mat_sub(A, B): return [[A[i][j] - B[i][j] for j in range(n)] for i in range(m)]
def trace(A):      return sum(A[i][i] for i in range(len(A)))
def eye(k):        return [[1.0 if i == j else 0.0 for j in range(k)] for i in range(k)]
 
# --- downstream curvature H of the FP reference (PSD: rank-1 + shrinkage) --
d = [random.gauss(0, 1) for _ in range(m)]
H = [[d[i] * d[j] + (0.1 if i == j else 0.0) for j in range(m)] for i in range(m)]
H_diag_only = [[H[i][j] if i == j else 0.0 for j in range(m)] for i in range(m)]
dhat = [x / (sum(x * x for x in d) ** 0.5) for x in d]   # expensive direction
 
def sigma(Delta):  # Sigma_l(alpha) = Delta C Delta^T   (Eq. 7)
    DC = [[sum(Delta[i][k] * C[k][j] for k in range(n)) for j in range(n)] for i in range(m)]
    return [[sum(DC[i][k] * DC[j][k] for k in range(n)) for j in range(m)] for i in range(m)]
 
def price(Hm, Sig):  # rho = 1/2 Tr(H Sigma)  (Eq. 8, layer term)
    HS = [[sum(Hm[i][k] * Sig[k][j] for k in range(m)) for j in range(m)] for i in range(m)]
    return 0.5 * trace(HS)
 
def rec_score(Sig):  # price with H -> I  (Remark 3.2 reconstruction reduction)
    return 0.5 * trace(Sig)
 
print("config |  rho_full   rho_diagH   rho_rec")
for b in (2, 3, 4):
    Sig = sigma(mat_sub(uniform_q(b), W))
    print(f" {b} bits | {price(H, Sig):9.4f}  "
          f"{price(H_diag_only, Sig):9.4f}  {rec_score(Sig):9.4f}")
 
# --- two candidates with about the SAME reconstruction error -------------
# Both are 0.5 * rounding residuals along a chosen output direction:
#   D_bad  aligns its layer-output error with the dominant curvature dhat
#   D_good aligns it with an output direction orthogonal to dhat
ampl = 0.25
# one fixed input-side direction z (rows share it, so the injected error
# has identical Frobenius/C-weighted magnitude for both candidates)
z = [random.gauss(0, 1) for _ in range(n)]
z = [v / (sum(v * v for v in z) ** 0.5) for v in z]
def along(vdir):
    return [[ampl * vdir[i] * z[j] for j in range(n)] for i in range(m)]
ortho = [random.gauss(0, 1) for _ in range(m)]
ortho = [v - sum(o * dh for o, dh in zip(ortho, dhat)) * dh for v, dh in zip(ortho, dhat)]
on = sum(v * v for v in ortho) ** 0.5
ortho = [v / on for v in ortho]
 
D_bad, D_good = along(dhat), along(ortho)
Sig_bad, Sig_good = sigma(D_bad), sigma(D_good)
 
print()
print("candidate |   rho_rec    rho_full   (same-scale injected error)")
print(f"  bad      | {rec_score(Sig_bad):9.4f}  {price(H, Sig_bad):9.4f}")
print(f"  good     | {rec_score(Sig_good):9.4f}  {price(H, Sig_good):9.4f}")
print(" -> reconstruction cannot separate them; the curvature price can")
 
# --- trace reduction (Eq. 18): isotropic surrogate of Sigma at 4 bits -----
Sig4 = sigma(mat_sub(uniform_q(4), W))
rho_trace = 0.5 * (trace(Sig4) / m) * trace(H)
print(f"\n4-bit full-covariance price {price(H, Sig4):.4f} "
      f"vs trace-reduced price {rho_trace:.4f}")

Output from a real run (Python 3, seed 7):

config |  rho_full   rho_diagH   rho_rec
 2 bits |    0.1118     0.1298     0.5080
 3 bits |    0.0156     0.0141     0.0536
 4 bits |    0.0072     0.0049     0.0170
 
candidate |   rho_rec    rho_full   (same-scale injected error)
  bad      |    0.0390     0.0347
  good     |    0.0390     0.0039
 -> reconstruction cannot separate them; the curvature price can
 
4-bit full-covariance price 0.0072 vs trace-reduced price 0.0051

Three readings. First, the bit ladder compresses the full price by roughly 15x from 2 to 4 bits and the reconstruction score by roughly 30x — the ratios between nearby formats survive the proxy here because the curvature factor is constant across bitwidths, exactly the regime the paper says reductions are safe in. Second, the bad/good pair is the paper's argument in two numbers: identical reconstruction scores of 0.0390, priced costs of 0.0347 versus 0.0039 — a factor of nine that only the curvature factor can see, which is what ranking different configuration families (not just bits) requires. Third, the trace-reduction surrogate underprices the 4-bit candidate by about 30% (0.0051 vs. 0.0072) in this deliberately anisotropic toy — the exact gap class that makes the paper report the reduced statistic's alignment separately rather than assuming it.

6. The evidence: does the price rank configs correctly before deployment?

The paper tests the prediction chain in the same order it is built¹.

Price tracks KL drift (Section 4.1). On OPT-125M and Qwen3-0.6B, under controlled single-layer perturbations spanning three whitening transformation types, the no-transformation baseline, bitwidths, and granularities, the realized price (the full-covariance 1/2 Tr(H Σ)) correlates with the measured FP-to-quantized KL drift at ρ = 0.9470 (OPT-125M) and ρ = 0.9249 (Qwen3-0.6B). The implemented trace price — the two-scalars-plus-cached-trace statistic actually deployed — holds nearly the same alignment at ρ = 0.9483 and ρ = 0.9438. A two-layer variant (price summed over a perturbed layer plus a second layer with a different candidate) also tracks the drift, supporting the local decomposition across layers in the controlled regime¹.

Price-guided selection (Section 4.2, Llama-3.2-1B, WikiText2 PPL; 112 quantized linear layers). Three configuration classes, one selector¹:

• Bit allocation (bits drawn from at a 3.0-bit target average): the price-guided selector takes 579 seconds and lands at PPL 12.22 with the best average downstream score of the three 3-bit methods (51.24). HIGGS needs 813 s for 12.50 / 50.57; AMQ reaches the best PPL (11.05) but at 11,635 s — it builds and evaluates quantized models per candidate allocation. The paper is explicit that AMQ's allocation is better on PPL; the claim is competitiveness at roughly 20x lower selection cost¹.
• Transformation selection (quantizer fixed, admissible pre-quantization transformations): price guidance picks the best PPL (11.53) and best average score (49.82) in 657 s, against CALM-CKA at 12.80 PPL and random selection collapsing to 22.68¹.
• Granularity allocation (scale at which weights share quantization parameters): best PPL (11.39) and best average score (51.96) in 127 s, against fixed group-128 at 12.71 and random at 23,313 PPL¹.

Appendix C repeats the protocol on Llama-3.2-3B and Llama-3.1-8B with the picture holding at 3B (transformation-selection PPL improves from 8.81 to 8.58 over CALM-CKA, average score 58.58 to 58.96) and more mixed at 8B (PPL 6.97 to 6.86, but average score 64.18 for CALM-CKA versus 64.24 — a rounding-error margin — and AMQ stronger across the 8B bit-allocation block)¹. For scale context on the FP baselines: Llama-3.2-1B FP16 is PPL 9.75, so every deployed config pays a drift distance the price is supposed to predict before the commit.

7. Anti-hype: what first order can and cannot price

The paper is scoped to weight-space PTQ and says so; the boundaries are the useful part¹.

First-order only, and the remainder is priced as a diagnostic, not controlled. The quadratic price is exact up to the remainder r(α), bounded relative to the price by η(α) — which involves both the gap between the exact and block-diagonal Hessian and a third-derivative bound along the segment. In aggressive low-bit regimes, the paper names low-bit nonlocality and moment-model mismatch as effects that define where the predictor is valid; they do not enter the objective. Deploying the selector at 2-3 bits or on outlier-heavy layers inherits that unpriced residue.

Cross-layer interactions are a modeling choice, not an estimate. The price sums block-diagonal layer terms; cross-layer coupling appears in the same scoped-regime list. The two-layer experiment supports additivity under controlled, small perturbations — not a demonstration that interactions stay second-order when all L layers are quantized simultaneously, which is the deployed condition. The evidence that selection still works end-to-end (Section 6) is the practical answer; a per-tier accounting of interaction losses is not in the paper.

The covariance is a modeled moment, not the deployed distribution. Σ_l comes from a rounding-envelope expectation (δ²/12 per group, the moment envelope V_l for codebooks), not from the quantized model's actual outputs — which do not exist yet, by construction. If real rounding errors correlate across entries or with inputs — outlier structure, learned-transform interaction, kernel-level clipping — the priced covariance and the realized drift separate. The paper flags curvature-proxy error (GN surrogate for the true Hessian) in the same regime list.

The correlation ceiling. ρ ≈ 0.92-0.95 in controlled single-layer studies is strong surrogacy, not identity: roughly 10-19% of variance in the KL drift is not explained even by the realized price. And its scope is weight-space PTQ — activation quantization, KV-cache quantization, runtime clipping, and QAT sit outside the selector unless their effects are exposed as a pre-deployment output-error covariance plus a cost, which the paper records as a branch consequence rather than a tested extension¹.

The deployment question to ask a vendor adopting this framing: which statistic is being reported — the realized covariance price, or the trace-reduced score with its isotropy assumption — and where were the dropped factors not constant across the candidate set actually being ranked?

8. Verdict

The contribution is a decision procedure, and the paper sells it as one: a forward-KL-derived price that makes formats, granularities, families, transformations, and bits commensurable before deployment, reducible to two candidate-side scalars and one cached reference-side trace per layer, and constrained by honest deployment costs. The proxy decomposition is the intellectually durable part — reconstruction and diagonal scores become exactly-identified reductions of the price, with a crisp condition (constant dropped factors) for when they are safe. The empirical part is strong where it is controlled (single-layer perturbation alignment) and honestly mixed where it matters commercially (AMQ beats the price on PPL at 8B; the price wins on selection cost by an order of magnitude). Like every first-order pricing model, it is a cheap estimate of a drift you cannot measure yet — and the right response to that is the paper's own: state the operating regime, report the reduced statistic's alignment separately, and never confuse the price with the bill.

Footnotes