{"id":"18f35356-407f-44a5-ab5b-ec111d8784fb","arxiv_id":"2510.18784","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"CAGE, a curvature-aware correction that adds the quantization error to the gradient, reduces loss in low-bit quantization-aware training, letting 3-bit CAGE-trained models match 4-bit baseline-trained models.","lead":"A new training trick called CAGE adds a quantization error term to the gradient updates, and this consistently improves accuracy when training neural networks with very low-precision numbers (2–4 bits). This matters because low-bit models run faster and use less memory, and CAGE narrows the accuracy gap.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 1's Assumption 3 (smooth potential for quantization error) is false for the actual Hadamard round-to-nearest quantizer; the convergence guarantee therefore does not cover the implemented CAGE algorithm.","rationale":"The reader's weakest-assumption analysis correctly identifies the central theoretical vulnerability: Theorem 1's Assumption 3 is not satisfied by the quantizer used in all experiments. The paper itself flags this condition in §3.1 ('under the smoothness assumption of Q'), but never explains how the theory connects to the actual round-to-nearest Hadamard quantizer of §4. The proof in Appendix A explicitly relies on path independence of the quantization-error field, which fails for discontinuous Q. Therefore the convergence and Pareto-optimality claims are formally unsupported for the method as implemented. This is a correctness risk for the theoretical narrative, but it does not undermine the empirical core: the paper reports extensive, multi-scale experiments (synthetic, fine-tuning, pretraining up to 800M, multiple optimizers) showing consistent gains. Those gains may be explained by the simple 'pull toward the quantized set' effect rather than by the curvature-aware regularizer story, but they are still credibly measured. The reader's CONDITIONAL verdict—accepting the empirical contribution while conditioning the theoretical claims on fixing the assumption gap—is the appropriate one, and no change is needed.","tokens_in":17042,"tokens_out":4445,"duration_ms":39868,"concrete_test":"Use the exact §4 quantizer (Hadamard rotation z=Hx, symmetric clip, round-to-nearest, inverse rotation) in d=2 and numerically evaluate the closed-loop line integral ∮(x−Q(x))·dx around a small square crossing a rounding boundary. If the integral is nonzero (order grid spacing^2), e is not a conservative vector field, so Assumption 3 is violated and Theorem 1 cannot govern the implemented CAGE. A complementary check: replace Q by a smooth soft-round surrogate that satisfies Assumption 3 and rerun the §4.1 quadratic experiments; if CAGE's advantage persists unchanged, the empirical gains do not depend on the theoretical premise.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing gap is between Theorem 1 and the algorithm actually evaluated. Theorem 1 (and its proof in Appendix A) requires Assumption 3: existence of an Lφ-smooth φ with x−Q(x)=∇φ(x). The proof then bounds φ(x0)−φ(xT) via a path-independent line integral of I−Q. The quantizer used in §4 is the row-wise Hadamard transform followed by symmetric clip and round-to-nearest. For such Q, the error e(x)=x−Q(x) is discontinuous at every rounding boundary (and on the clipping boundary), so e cannot be the gradient of an L-smooth (or even continuous) potential. Hence the convergence result—'strong ergodic convergence to a Pareto-optimal point'—does not apply to the implementation. What remains is a heuristic: adding λ_t e_t to the AdamW update reduces quantization error empirically. That may be a good heuristic, but the paper's central theoretical claim and the 'curvature-aware/principled' narrative are not supported for the reported experiments. Additionally, even granting Assumption 3, the theorem bounds stationarity of f+λφ at the full-precision iterates, not the loss of the quantized model Q(x_T); the link between the Pareto condition and the W3A3-vs-W4A4 accuracy result is not made.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes CAGE, a quantization-aware training (QAT) method that augments the straight-through estimator (STE) gradient with a correction term proportional to the instantaneous quantization error e_t = x_t − Q(x_t), either inside or outside the base optimizer's preconditioner. The authors motivate the correction through a multi-objective reformulation of QAT, introduce a λ-Pareto optimality condition, and prove an ergodic convergence theorem (Theorem 1) for an SGD variant under an assumption that the quantization error is the gradient of a smooth potential. Empirically, they report that CAGE improves over the QuEST baseline in synthetic quadratic tasks, MXFP4 fine-tuning of Llama-3.2-3B, and pre-training of Llama-style models from 30M to 800M parameters across W2A2, W3A3, and W4A4, including the headline claim that W3A3 CAGE pre-training matches or beats W4A4 QuEST. The paper also includes scaling-law analysis and comparisons across AdamW, Muon, Shampoo, and SOAP.","tokens_in":17445,"tokens_out":6724,"duration_ms":55774,"significance":"If the empirical results hold, CAGE is a practically valuable and remarkably simple addition to QAT: it consistently lowers validation loss across model sizes, precisions, and optimizers, and the paper provides an official implementation. The extensive pre-training evaluation (up to 800M parameters, multiple seeds, several optimizers) is a real strength, as is the explicit reporting of hyperparameters and ablations. However, the theoretical contribution as stated does not cover the implemented algorithm. Theorem 1 relies on Assumption 3, which is false for the Hadamard round-to-nearest quantizer used in all experiments; the theorem is also only for SGD, not the AdamW algorithm actually evaluated. Thus the paper currently offers a well-engineered heuristic with strong empirical evidence, but the advertised convergence guarantees and the 'curvature-aware' derivation do not apply to the tested method. The gap is central rather than cosmetic, and the authors should either repair the theory or substantially reframe the paper's claims.","major_comments":[{"comment":"Assumption 3 requires existence of an Lφ-smooth φ with x−Q(x)=∇φ(x). This forces Q to be continuous (indeed (1+Lφ)-Lipschitz). The quantizer used in §4 — row-wise Hadamard transform followed by symmetric clipping and round-to-nearest — produces an error x−Q(x) that is discontinuous at every rounding and clipping boundary. Hence no such smooth potential exists, and Theorem 1, whose proof (Appendix A) uses φ and the path-independent line integral of I−Q, does not apply to the experiments. The sentence claiming Assumption 3 is 'essentially equivalent to Lipschitz continuity of Q' is also incorrect, since round-to-nearest is not continuous. The paper must either analyze a genuinely smooth surrogate quantizer, prove a version with non-vanishing quantization-error terms, or explicitly label the practical method as heuristic.","section":"§3.2, Assumption 3; §4, Quantization pipeline"},{"comment":"Theorem 1 is stated for the SGD update in Eq. (3), but the algorithm evaluated throughout §4 is Algorithm 1: AdamW with decoupled weight decay, a decoupled CAGE correction, a silence period, and a time-varying λ_t. None of these elements appear in the convergence analysis. Even granting Assumption 3, the theorem does not cover the method whose results are reported. The paper should either extend the analysis to AdamW/decoupled updates or explicitly restrict the theoretical claims to the SGD variant and state that the practical AdamW version is not covered.","section":"§3.2, Theorem 1 vs §3.3, Algorithm 1"},{"comment":"Even if Assumption 3 held, Theorem 1 controls E∥∇f(x̂)+λ(x̂−Q(x̂))∥² at a full-precision iterate x̂. This is a stationarity condition for the weighted-sum surrogate f+λφ, not for the quantized-model objective f(Q(x)) or for the validation loss reported in Figures 3–5 and Table 1. A small Pareto gradient does not imply that Q(x_T) has low loss, especially since Q is discontinuous. The logical link between the convergence theorem and the headline W3A3-vs-W4A4 accuracy result is therefore missing; the authors should state precisely what quantity the theorem controls and argue why it is relevant to QAT accuracy.","section":"§3.1, Eq. (2); §3.2, Theorem 1"},{"comment":"The method is called 'curvature-aware' and the introduction says the correction 'leverages local second-order information about the loss landscape (i.e., the Hessian).' But the decoupled update used in most experiments (Algorithm 1, line 17) adds only αλ_t e_t, with no Hessian or curvature term. Curvature enters only through the coupled-Adam variant via the preconditioner, which is not the default. The paper should either demonstrate a concrete sense in which λ_t e_t incorporates curvature without Assumption 3, or change the terminology/narrative to match what the algorithm actually computes.","section":"§1, §3.3, Algorithm 1"}],"minor_comments":[{"comment":"Typos and small errors: the abstract has 'can be found over https' instead of 'at'; Assumption 2 has 'F or all iterates'; §3.1 writes 'f(Q(x)' with a missing closing parenthesis. Please proofread.","section":"Abstract, §3.1, Assumption 2"},{"comment":"The table caption says 'final validation perplexity' while the surrounding text says 'validation loss'. These are different metrics; please use consistent terminology and state which quantity is plotted in Figure 5.","section":"Table 1 and §4.3"},{"comment":"The line-integral representation is written as φ(x)=∫_{x0}^{x}(I−Q)·dr. This omits the integration constant φ(x0); the correct statement is φ(xT)−φ(x0)=∫_{x0}^{xT}(I−Q)·dr, and the subsequent bound should be justified with an absolute value. As written, the equation is false.","section":"Appendix A, proof of Theorem 1"},{"comment":"The eff(P) fits introduce separate free parameters per method and bit-width, and the conclusion that CAGE 'improves parameter efficiency' largely restates the lower validation losses in Table 1. A held-out validation of the scaling-law form or a model-selection comparison would strengthen this claim; otherwise it should be presented as a descriptive summary rather than independent evidence.","section":"§4.3, Precision Scaling Law"},{"comment":"The LOTION comparison is based on the authors' reimplementation, not the official code, and the paper acknowledges this. This is acceptable as a preliminary comparison, but the claim that CAGE outperforms LOTION should be marked as provisional until verified with the official implementation.","section":"§4.3, Comparison to LOTION"}],"recommendation":"major_revision","confidential_remarks":"The empirical contribution is substantial and likely of high practical value, but the paper's theoretical framing is currently disconnected from the evaluated algorithm. The stress-test concern about Assumption 3 is valid and load-bearing: the convergence theorem does not apply to the implemented quantizer or to the AdamW algorithm used in the experiments. I recommend major revision rather than reject because the empirical results are extensive and the theory could be repaired by either restricting claims to smooth surrogates or by explicitly reframing the paper as an empirical method with heuristic motivation. The authors should be encouraged to make the gap between theory and practice explicit and to avoid overclaiming the 'curvature-aware' and 'principled' narrative."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"You should know this paper before the weekend: the empirical results are real and substantial, but the theory section is a paperweight. The core algorithm — add the instantaneous quantization error e_t = x_t - Q(x_t) to the AdamW update, after a silence period, with a linear ramp — consistently improves QAT loss across fine-tuning, pretraining up to 800M params, and several optimizers. The W3A3 vs W4A4 comparison in Figure 5 is striking, and the scaling-law analysis (eff(P)) supports the claim of improved capacity per bit. Code is public, experiments are thorough, and the paper is honest about the tuned hyperparameters (λ, s). This is a legitimately useful contribution to QAT practice.\n\nThe soft spot is exactly where the reader says: Theorem 1 requires Assumption 3, which posits a smooth potential φ with x - Q(x) = ∇φ(x). The actual quantizer is Hadamard + clip + round-to-nearest — discontinuous, so it cannot be the gradient of an L-smooth function. The proof's path-independent line integral is valid only for a gradient field, which we don't have. So the 'strong ergodic convergence to a Pareto-optimal point' does not apply to the implemented algorithm. The paper is not deceptive here — it explicitly says 'under the smoothness assumption of Q' — but it never tells the reader that the real quantizer fails that assumption, and the abstract/contribution list presents the convergence guarantee as covering CAGE. That mismatch should be fixed in revision, either by weakening the claim or by analyzing a smoothed surrogate quantizer.\n\nAlso worth noting: the 'curvature-aware' label is doing more work than the algorithm. The correction term uses e_t, not any Hessian information; the connection to curvature is motivational via LOTION-style reasoning, not operational. And the LOTION comparison is against their own reimplementation, which they caveat. Those are minor relative to the theory mismatch.\n\nNet: the empirical findings are credible and reproducible enough to deserve a serious referee. I'd send this to review, but the theory section should be rewritten as a heuristic derivation with the convergence result explicitly qualified to smooth approximations, not presented as a guarantee for the method that was actually evaluated.\n\nWould I bring it to reading group? Maybe, mainly to discuss the gap between optimization theory and practice in QAT. I'd cite it for the empirical method.","headline":"Good empirical QAT paper with a theory that doesn't cover the actual algorithm; worth refereeing for the experiments.","tokens_in":17892,"tokens_out":1304,"would_cite":true,"duration_ms":13278,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"CAGE claims that adding the instantaneous quantization error to the optimizer update, with a curvature-aware scaling, makes quantization-aware training converge to a Pareto-optimal point and substantially closes the low-bit accuracy gap.","keywords":["quantization-aware training","straight-through estimator","gradient estimation","multi-objective optimization","Pareto optimality","low-bit language models","convergence guarantees","quantization error correction"],"falsifier":"On the paper's own toy quadratic f(x) = ½(x − ½)² with Q(x) = ⌊x⌋, compute the Pareto residual ∇f(x) + λ(x − Q(x)) at the point CAGE converges to for a fixed λ. If it does not approach zero, the implemented update does not satisfy the claimed Pareto convergence; if it does, then the smoothness assumption is not necessary on this example.","tokens_in":16925,"feed_emoji":"🧮","tokens_out":5331,"duration_ms":44939,"temperature":0.7,"pith_summary":"The paper tries to establish that quantization-aware training can be understood as balancing two objectives: minimizing the task loss and satisfying the quantization constraint. It proposes updating parameters not only with the usual straight-through gradient but also with the current quantization error, scaled by a coefficient, so the training dynamics pull the model toward the quantized set while still minimizing loss. If correct, this closes most of the remaining accuracy gap between low-bit quantized models and full-precision training, with 3-bit pretrained models matching what previously required 4 bits.","feed_headline":"Quantization-error fix makes 3-bit models match 4-bit training","feed_subtitle":"Adding each step's rounding error to the update roughly halves the accuracy loss in low-bit language models.","key_machinery":"The machinery is the instantaneous quantization error e_t = x_t − Q(x_t), added to the update as a correction term. It is grounded in a Pareto-optimality condition ∇f(x) + λ(x − Q(x)) = 0, where λ balances loss minimization against quantized-set satisfaction; the error term acts as a stand-in for the gradient of a regularizer that would otherwise require an infeasible proximal step.","core_discovery":"The central claim is that the quantization error x_t − Q(x_t), which the straight-through estimator normally discards, is exactly the information needed to regularize quantized training. CAGE's update is x_{t+1} = x̃_{t+1} − α λ_t e_t, applied after the base optimizer step, and the paper proves that this dynamics converges ergodically to a λ-Pareto-optimal point, where no small update can improve the loss without hurting the quantization objective. The same correction is shown empirically to roughly halve the quantization-induced accuracy loss in fine-tuning and to make W3A3 pre-training match W4A4 accuracy of the prior best method.","pith_inferences":["The correction term can be read as a cheap, diagonal approximation to a second-order regularizer; if that read is right, the same term should transfer to other nondifferentiable constraints such as sparsity or vector quantization.","If the empirical gains persist at larger scale, QAT could move from a deployment-time step to the default training procedure, since the method's extra cost is one elementwise addition per parameter per step.","The paper's proof assumes a smooth quantizer, while the experiments use a discontinuous round-to-nearest one; a meaningful test is whether replacing the abrupt quantizer with a smooth surrogate preserves the gains, or whether the discontinuity itself is doing the work.","A simpler control—adding the quantization error with a fixed size rather than scaling with curvature—would isolate whether the 'curvature-aware' interpretation is necessary or incidental to the observed improvements."],"forward_implications":["Compression accuracy loss in QAT fine-tuning is roughly halved relative to the prior best method at similar compute.","Pretraining with 3-bit weights and activations reaches the loss that 4-bit training achieved with the prior best method, so low-bit models become a more practical training target.","Gains transfer across different optimizer update rules, so the correction behaves as an optimizer-agnostic plug-in.","Fitted scaling laws show effective parameter efficiency improves by more than 10% at 4-bit and more than 20% at 2-bit over the prior best QAT method.","The convergence result gives an O(1/√T) ergodic rate to a Pareto-optimal point with no non-vanishing quantization-error term, a formal guarantee of a kind previous QAT heuristics lacked."],"fun_headline_variants":["Quantization error becomes the gradient fix: 3-bit matches 4-bit","CAGE: use quantization error to correct gradients, halves loss gap","3-bit models now match 4-bit accuracy with CAGE's gradient fix","Rounding error is the missing ingredient for better quantization-aware training","Quantization error is the key to closing the low-bit accuracy gap"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The convergence proof relies on the assumption that the quantization error x − Q(x) is the gradient of some smooth function, but the round-to-nearest quantizer used in the experiments is discontinuous, so this assumption does not hold for the implemented algorithm.","fun_headline_variants_meta":{"raw":{"variants":["Quantization error becomes the gradient fix: 3-bit matches 4-bit","CAGE: use quantization error to correct gradients, halves loss gap","3-bit models now match 4-bit accuracy with CAGE's gradient fix","Rounding error is the missing ingredient for better quantization-aware training","Quantization error is the key to closing the low-bit accuracy gap"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000801,"raw_usage":{"total_tokens":3376,"prompt_tokens":783,"completion_tokens":2593,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":527,"completion_tokens_details":{"reasoning_tokens":2500}},"tokens_in":527,"tokens_out":2593,"duration_ms":16083,"temperature":1.0,"reasoning_tokens":2500,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-04T08:46:29.961016+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"On the paper's own toy quadratic f(x) = ½(x − ½)² with Q(x) = ⌊x⌋, compute the Pareto residual ∇f(x) + λ(x − Q(x)) at the point CAGE converges to for a fixed λ. If it does not approach zero, the implemented update does not satisfy the claimed Pareto convergence; if it does, then the smoothness assumption is not necessary on this example.","supporting_citations":[],"review_version":1}