{"id":"fe4c7cdd-14a0-4407-8bbe-8dd2b3cf513a","arxiv_id":"2506.22771","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"INT8 quantized training using the Forward-Forward algorithm with a look-ahead loss achieves competitive accuracy and modest resource savings on an edge device.","lead":"FF-INT8 is a proposed method for training deep networks entirely in INT8 precision on edge devices, combining the Forward-Forward algorithm with a new 'look-ahead' loss. The authors report 4.6% faster training, 8.3% lower energy, and 27.0% lower memory versus an INT8 backpropagation baseline on a Jetson Orin Nano.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Look-ahead gradient derivation in §IV-C is mathematically invalid; the claimed mechanism behind FF-INT8's accuracy is unsupported.","rationale":"The reader's weakest assumption identifies exactly the same load-bearing concern I find: the look-ahead scheme, the one novel component responsible for the accuracy gains, is derived incorrectly. The central claim of the paper is that FF-INT8 maintains accuracy within 0.4% of FP32 backpropagation, and the look-ahead scheme is what makes this plausible on ResNet-18. Without a valid gradient computation for the cross-layer loss terms, the reported accuracy improvement is unexplained. I also checked the efficiency numbers: the 27.0% memory reduction in the abstract is inconsistent with the average of the per-model reductions in Table V (~24.5%), which compounds the reproducibility problem. However, the memory discrepancy is secondary; the mathematical issue in §IV-C directly undermines the method's stated mechanism. I found no independent support, such as code, data, or formal verification, that would compensate for this gap. Therefore the reader's REJECT verdict stays appropriate, so I mark the verdict as unchanged.","tokens_in":9823,"tokens_out":6721,"duration_ms":70615,"concrete_test":"Write a minimal 2-layer MLP y1=W1x, y2=W2σ(y1), with losses L1=L(G1) and L2=L(G2). Compute the exact gradient ∂(L1+λL2)/∂W1 by automatic differentiation, then compute the update implied by Algorithm 1 in §IV-C using only G1, G2 and local quantities, with no backpropagation through W2 or σ. If the two gradients are unequal (the exact one includes W2^T diag(σ'(y1)) x^T while the local rule omits it), the look-ahead method does not optimize Equation (3). To settle the empirical claim, rerun the ResNet-18 experiment with the correct chain-rule version of look-ahead; if the accuracy does not recover approximately 93%, the reported benefit stems from an implementation detail, not the stated method.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing step is the look-ahead scheme in §IV-C, which the experiments credit for the difference between a 60% ResNet-18 accuracy (vanilla FF-INT8, Fig. 6b) and the headline 93.1% (Table V). Equation (4) requires ∂(L2+...+Lfinal)/∂W for an early-layer weight W, and the paper claims no backward chain is needed because \"the goodness function for each layer depends solely on its neuron values, and the loss function is based solely on the goodness function\" (§IV-C). This claim is false. The goodness G_j=||y_j||^2 of a later layer depends on W through the composition y_j = f_j(W_j, ..., f_{i+1}(W_{i+1}, f_i(W_i, y_{i-1}))...), so ∂L_j/∂W_i = (∂L_j/∂G_j)(∂G_j/∂y_j)(∂y_j/∂y_{j-1})...(∂y_i/∂W_i). That is precisely a backward chain, and its computation requires the very intermediate activations and Jacobians the method claims to avoid. Algorithm 1 performs one forward pass, computes all G's, and updates each layer's weights; if the updates are local (only ∂L_i/∂W_i), Equation (3) is not minimized; if they include cross-layer terms, a backward chain is silently needed. The paper provides neither a correct derivation nor code to disambiguate. For a method whose central novelty is improving accuracy through this scheme, this is a central gap in the argument. Additionally, the abstract's 27.0% memory saving is not the average of Table V, which is approximately 24.5%.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"FF-INT8 is a quantized training method that replaces backpropagation with the Forward-Forward (FF) algorithm and uses INT8 arithmetic. The paper claims that layer-wise greedy training stabilizes gradient quantization, and that a proposed 'look-ahead' scheme, which adds later-layer goodness losses to each layer's update, overcomes FF's convergence and accuracy limitations. On a Jetson Orin Nano, the authors report accuracy within 0.4% of FP32 backpropagation and 0.2% above the GDAI8 INT8 baseline, with 4.6% lower training time, 8.3% lower energy, and 27.0% lower memory footprint.","tokens_in":10150,"tokens_out":7585,"duration_ms":127076,"significance":"The empirical setting is appropriate: real edge hardware, multiple architectures, and INT8 engine measurements. If the claims were substantiated, the work would be a meaningful step for low-precision training on resource-constrained devices. However, the paper's central novelty, the look-ahead scheme, rests on an invalid derivative derivation, and the headline memory figure does not follow from the reported data. The contribution cannot be validated without fixing these points.","major_comments":[{"comment":"The derivation of the look-ahead gradient is not correct. For a layer i with weights W_i and a later layer j>i, the goodness G_j = ||y_j||^2 depends on W_i through the composition y_j = f_j(W_j, ... f_{i+1}(W_{i+1}, f_i(W_i, y_{i-1}))...). Therefore ∂L_j/∂W_i cannot be obtained without applying the chain rule through the intermediate layers. The statement that 'the goodness function for each layer depends solely on its neuron values' is true but does not eliminate the dependence of those neuron values on earlier weights; it only shifts the required chain to the neuron activations. As a result, Eq. (4) either requires a backward pass that the paper explicitly claims to avoid, or, if each layer is updated only using ∂L_i/∂W_i, it does not minimize the new loss in Eq. (3). This gap is load-bearing: Figure 6(b) attributes the ResNet-18 improvement from about 60% to 93% accuracy to this scheme, and Table IV's complexity comparison does not include any cross-layer derivative cost. The paper needs either a correct derivation or an explicit statement of the approximation used, plus code or a detailed algorithm to show which is implemented.","section":"IV-C, Eq. (3)-(4), Algorithm 1"},{"comment":"The claimed 27.0% memory savings relative to GDAI8 is not supported by the table's own numbers. The per-model memory savings in Table V are 22.9% (MLP), 24.5% (MobileNet-V2), 27.0% (EfficientNet-B0), and 23.7% (ResNet-18); the mean is 24.5%, not 27.0%. The 27.0% figure appears to be copied from the EfficientNet-B0 row. Please correct the summary statistic or explain the aggregation method.","section":"Abstract and Table V"},{"comment":"The efficiency results are reported as single measurements without standard deviations, number of independent runs, or a description of how time, energy, and memory were measured (e.g., peak memory vs. allocated tensors, whether CUDA context is included). Since the reported advantages over GDAI8 are small (4.6% time, 8.3% energy), these missing details are important for assessing whether the differences are meaningful on a real embedded device.","section":"V-A, Table V"},{"comment":"The claim that the look-ahead scheme 'maintains the computational efficiency' and keeps the total derivative computations at k×n is not justified. If the loss in Eq. (3) is minimized exactly, the gradients ∂(L_2+...+L_final)/∂W for every early layer either require a backward chain or scale as O(k^2) derivative computations. The paper's complexity table (Table IV) only counts one forward pass and does not account for this, so the per-mini-batch operation counts understate the actual cost of the proposed algorithm.","section":"IV-C, Algorithm 1"}],"minor_comments":[{"comment":"There are typos: 'hundres' should be 'hundreds' in Section V-C, and 'backpropation' should be 'backpropagation' in Section V-D.","section":"V-C, V-D"},{"comment":"The text uses 'residue blocks' instead of the standard term 'residual blocks'; please correct for consistency with the referenced literature.","section":"IV-C, V-B"},{"comment":"The paper does not report the number of epochs used for the runs in Table V, nor does it provide a sensitivity study for the threshold θ and the λ schedule. These hyperparameters are central to the look-ahead method, and their influence on the reported results should be documented.","section":"V-A, V-D"},{"comment":"The introduction claims this is the first work to combine FF with low-precision training, but the related-work section does not discuss other FF-based enhancements or any prior FF quantization studies. A more complete comparison, including at least one vanilla FF baseline in the experiments, would strengthen the claims.","section":"I, II"}],"recommendation":"reject","confidential_remarks":"The core flaw is in the mathematical derivation of the look-ahead gradient, not in the experimental hardware setup. I do not see a small revision that could fix this while preserving the stated efficiency claims; the authors would need to re-derive or reframe the method and provide supporting code. This underlies my reject recommendation."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Read FF-INT8. The core idea is sensible: train Forward-Forward layers in INT8 to avoid the error accumulation that kills direct INT8 backprop. The preliminary experiment in Section IV-A, showing accuracy degradation with depth under quantized BP, is a genuinely useful data point. The FF+INT8 combination is new, and the reported accuracies are close to FP32 baselines, which is encouraging if real.\n\nBut the central novelty, the look-ahead scheme, has a load-bearing mathematical error. Equation (4) claims the derivative of later-layer losses with respect to an early-layer weight can be computed without a backward chain, because \"the goodness function for each layer depends solely on its neuron values.\" That is false. The goodness G_j = ||y_j||^2 depends on all earlier weights through the network composition, so derivatives of later losses with respect to earlier weights require exactly the chain rule the paper says is unnecessary. Algorithm 1 does not disambiguate: if updates are local, Equation (3) is not minimized; if they include cross-layer terms, a backward pass is silently needed. The paper gives neither a correct derivation nor code. This is not a missing proof; it is a false statement about the math, and it leaves the reported accuracy gains from look-ahead unexplained.\n\nSmaller issues: the abstract's 27.0% memory saving does not match the per-model average in Table V (about 24.5%); there are no error bars or code; and the gains over GDAI8 are modest (4.6% time, 8.3% energy), possibly within noise.\n\nWhat the paper does well: it identifies a real problem and makes a plausible case that layer-wise greedy training mitigates quantization error. The hardware measurements on Jetson Orin Nano are a nice touch.\n\nOn balance, I would not take the claims at face value. The main mechanism is either wrong or so underspecified that the empirical results cannot be interpreted. I would want a corrected derivation, code, and error bars before engaging seriously. With a proper treatment of cross-layer gradients (or a clearly stated local approximation), there could be a solid paper here. As it stands, reject or major revision; for a one-shot review, reject.","headline":"The look-ahead derivation is wrong, so the paper's main novelty is unsupported, though the FF+INT8 direction is worth watching.","tokens_in":10687,"tokens_out":4130,"would_cite":false,"duration_ms":44540,"reading_group":"maybe","serious_thinker":"no","would_accept_peer_review":false},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"FF-INT8, an 8-bit Forward-Forward training method, claims accuracy within 0.4% of FP32 backpropagation on edge-device DNNs while cutting time, energy, and memory.","keywords":["Forward-Forward algorithm","INT8 training","low-precision training","gradient quantization","look-ahead scheme","edge devices","energy-efficient DNN training"],"falsifier":"For a two-hidden-layer MLP, compute the exact derivative $\\partial L_{\\mathrm{final}}/\\partial W_1$ by backpropagation and compare it with the gradient used by the look-ahead update. The exact derivative contains the product of intermediate-layer Jacobians; the look-ahead rule, as derived, omits that product. If the two gradients differ, the scheme is not actually delivering later-layer feedback to the first layer.","tokens_in":9583,"feed_emoji":"⚡","tokens_out":9178,"duration_ms":83848,"temperature":0.7,"pith_summary":"The paper proposes FF-INT8, a method for training deep networks in 8-bit integers by replacing backpropagation with the Forward-Forward algorithm, which trains one layer at a time on positive and negative samples using a goodness measure. The authors argue that this layer-wise strategy keeps quantization error from accumulating the way it does in direct INT8 backpropagation, and they add a look-ahead loss term so earlier layers receive some influence from later layers. On an NVIDIA Jetson Orin Nano, FF-INT8 reports accuracy within 0.4% of FP32 backpropagation and 0.2% above the GDAI8 INT8 baseline, while cutting training time by 4.6%, energy by 8.3%, and memory footprint by 27.0%. If these numbers hold, the method would give edge devices a practical no-backpropagation route to low-precision training.","feed_headline":"No-backprop INT8 training matches FP32 within 0.4%","feed_subtitle":"Layer-wise Forward-Forward on Jetson Orin Nano: 4.6% faster, 8.3% less energy, 27% less memory vs GDAI8.","key_machinery":"The load-bearing machinery is the goodness function together with the look-ahead loss. Goodness is defined as $G = \\|y\\|^2$, the squared norm of a layer's neuron activities; positive samples should push $G$ above a threshold $\\theta$ and negative samples below it, giving losses $L_{\\mathrm{pos}} = \\log(1 + e^{-(G-\\theta)})$ and $L_{\\mathrm{neg}} = \\log(1 + e^{G-\\theta})$. The look-ahead scheme replaces the vanilla per-layer loss with $L_{\\mathrm{new}} = L_{\\text{current}} + \\lambda \\sum_{i>\\text{current}} L_i$, and because the paper assumes each layer's goodness depends only on that layer's own neuron values, it updates all layers in one forward pass using INT8 symmetric uniform quantization with stochastic rounding. This is what lets the method keep the memory and compute advantages of a forward-only pass while still nominally coupling the layers.","core_discovery":"The central claim is that the Forward-Forward algorithm's layer-by-layer greedy training is better suited to INT8 quantization than backpropagation, because each layer's gradient is computed locally from that layer's goodness function instead of being chained through the whole network. To address Forward-Forward's known weakness, namely that early layers never receive feedback from later layers or the final output, the paper redefines the per-layer loss as the current layer's loss plus a weighted sum of all later layers' losses and updates every layer from a single forward pass. Across four architectures (an MLP, MobileNet-V2, EfficientNet-B0, and ResNet-18), the method is reported to match FP32 backpropagation within 0.4% accuracy and to beat the state-of-the-art INT8 baseline GDAI8 by 0.2%, with 4.6% less training time, 8.3% less energy, and 27.0% less memory on the Jetson Orin Nano.","pith_inferences":["Editorial inference: if the look-ahead gradient derivation is corrected to include the true chain rule, the scheme would need to store intermediate Jacobians or activations, which would erode part of the memory advantage the paper claims.","Editorial inference: the comparison runs on a single edge device; on hardware where INT8 multiply-accumulate is not specially accelerated, or where FP32 arithmetic is comparatively cheap, the reported 4.6% time saving and 8.3% energy saving against GDAI8 could shrink or reverse.","Editorial inference: a natural testable extension is scaling FF-INT8 to ImageNet-class models; if the accuracy gap stays within about one percentage point beyond CIFAR-10-scale networks, the layer-wise quantization-stabilization claim would be substantially strengthened."],"forward_implications":["FF-INT8 reaches accuracy within 0.4% of FP32 backpropagation and 0.2% above the GDAI8 INT8 baseline on the four tested networks.","Compared with GDAI8, FF-INT8 uses 4.6% less training time, 8.3% less energy, and 27.0% less memory on the Jetson Orin Nano.","Layer-by-layer training avoids the accuracy collapse that direct INT8 backpropagation shows as networks deepen, so the method is a candidate for INT8 training on architectures where BP-INT8 fails.","The look-ahead scheme reduces the epochs needed for convergence, e.g. from 180 to 130 for the two-hidden-layer MLP, and stabilizes ResNet-18 training enough to reach 93.1% accuracy.","Per mini-batch, FF-INT8 needs roughly 2.6% of the multiply-accumulate operations of backpropagation, which offsets the larger number of epochs it requires."],"supporting_citations":[{"why":"Supplies the original Forward-Forward algorithm, including the positive/negative dataset construction and the goodness-function loss that FF-INT8 quantizes.","marker":"[7]"},{"why":"Defines GDAI8, the state-of-the-art INT8 backpropagation training baseline whose accuracy, time, energy, and memory numbers are the paper's main comparison.","marker":"[15]"},{"why":"Defines UI8, the unified INT8 training baseline used as a second comparison and as evidence of the difficulty of gradient quantization in backpropagation.","marker":"[13]"},{"why":"Introduces residual networks, which the paper uses to motivate the look-ahead scheme because greedy layer-wise training cannot coordinate layers inside a residual block.","marker":"[17]"},{"why":"Provides stochastic rounding, which FF-INT8 uses in its INT8 activation quantization to avoid biased rounding.","marker":"[16]"},{"why":"Defines MobileNet-V2, one of the four benchmark architectures trained in the experiments.","marker":"[18]"},{"why":"Defines EfficientNet-B0, one of the four benchmark architectures trained in the experiments.","marker":"[19]"}],"fun_headline_variants":["INT8 Forward-Forward matches FP32 without backprop","Edge training with Forward-Forward: INT8, no backprop","Layer-wise INT8 training cuts memory 27% on edge","Forward-Forward INT8: 4.6% faster training on Jetson","No-backprop INT8 training: 27% less memory, 8.3% less energy"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The method assumes that when an early layer is updated, adding the losses of later layers to its gradient does not require passing any derivative information back through the layers in between; if that is wrong, the reported accuracy gain from the look-ahead scheme is unexplained.","fun_headline_variants_meta":{"raw":{"variants":["INT8 Forward-Forward matches FP32 without backprop","Edge training with Forward-Forward: INT8, no backprop","Layer-wise INT8 training cuts memory 27% on edge","Forward-Forward INT8: 4.6% faster training on Jetson","No-backprop INT8 training: 27% less memory, 8.3% less energy"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000249,"raw_usage":{"total_tokens":1555,"prompt_tokens":956,"completion_tokens":599,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":572,"completion_tokens_details":{"reasoning_tokens":501}},"tokens_in":572,"tokens_out":599,"duration_ms":6485,"temperature":1.0,"reasoning_tokens":501,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T21:58:20.624620+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"For a two-hidden-layer MLP, compute the exact derivative $\\partial L_{\\mathrm{final}}/\\partial W_1$ by backpropagation and compare it with the gradient used by the look-ahead update. The exact derivative contains the product of intermediate-layer Jacobians; the look-ahead rule, as derived, omits that product. If the two gradients differ, the scheme is not actually delivering later-layer feedback to the first layer.","supporting_citations":[{"cited_title":"Gradient distribution-aware int8 training for neural networks,","cited_arxiv_id":null,"evidence_quote":"Defines GDAI8, the state-of-the-art INT8 backpropagation training baseline whose accuracy, time, energy, and memory numbers are the paper's main comparison."},{"cited_title":"Towards unified int8 training for convolutional neural network,","cited_arxiv_id":null,"evidence_quote":"Defines UI8, the unified INT8 training baseline used as a second comparison and as evidence of the difficulty of gradient quantization in backpropagation."},{"cited_title":"Deep learning with limited numerical precision,","cited_arxiv_id":null,"evidence_quote":"Provides stochastic rounding, which FF-INT8 uses in its INT8 activation quantization to avoid biased rounding."}],"review_version":1}