{"id":"749b9d00-a07f-4ebd-9f68-863327c4043a","arxiv_id":"2608.07974","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"high","formal_verification":"none","parameter_count":2,"one_line_summary":"ZeroLock decouples LLM fine-tuning into independently updated chunks using local objectives and a pipeline system, achieving moderate memory and throughput gains, but its convergence proof targets a surrogate objective rather than the true global loss.","lead":"The paper proposes ZeroLock, a backpropagation-free fine-tuning method that splits an LLM into chunks and updates each chunk with its own local loss, plus a pipeline system that runs these updates in parallel on GPUs or phones. The authors report 26.5% lower peak memory and 4.9% higher throughput than a PipeDream-style baseline, but the theoretical convergence guarantee only covers the constructed local objective, not the original global loss.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 1 analyzes the reverse-KL objective in Eq. (14), but the deployed local loss is cross-entropy (forward KL); the two are not equivalent, so the claimed O~(1/√T) rate does not apply to the implemented algorithm.","rationale":"The reader's weakest_assumption was Assumption 5, and I agree that the stability condition is unproven and likely too strong: a first-order inner product is generally O(‖Δp‖), not O(‖Δp‖²), unless the gradient w.r.t. p~ vanishes with the step size, which is not shown. However, I believe the more load-bearing issue is the mismatch between the analyzed objective and the implemented one. The theory in Lemma 2 and Theorem 1 uses reverse KL D_KL(p‖p_y), while the implementation uses cross-entropy, which is forward KL D_KL(p_y‖p). With one-hot labels, the reverse-KL objective is infinite for off-target support and its optimum is the one-hot target itself, so the consistency term drops out of the analyzed optimum. This is not a minor technicality: it means the convergence theorem is for a different algorithm than the one deployed. The empirical memory and throughput results can still stand, and the system contribution remains plausible, but the paper's headline 'first framework' and 'differs from BP only by polylog' claims are not supported by the current proof. The reader already reached CONDITIONAL; my concern reinforces that verdict rather than moving it, so I recommend UNCHANGED.","tokens_in":17701,"tokens_out":10013,"duration_ms":107424,"concrete_test":"Run a two-token toy check: set p_y=(1,0), p_{k−1}=(0.5,0.5), and evaluate the theoretical loss in Eq. (14) at p=(0.5,0.5). D_KL(p‖p_y) is infinite, whereas the implemented cross-entropy/forward-KL loss is finite. Then re-derive Lemma 2 with the implemented forward-KL task loss D_KL(p_y‖p) and the same consistency term; verify whether the minimizer is still the geometric mean in Eq. (15). If it is not, Theorem 1's convergence proof does not apply to the loss actually optimized in the experiments.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central convergence claim depends on Lemma 2 and Eq. (14), where the local loss is L_t_k(p;α)=α D_KL(p‖p_y)+(1−α)D_KL(p‖p_t_{k−1}). The actual implementation, per Section II-A and III-B, uses cross-entropy with one-hot targets. Minimizing D_KL(p‖p_y) is not equivalent to minimizing cross-entropy: cross-entropy is D_KL(p_y‖p) plus a constant independent of the model, i.e., the forward KL. The paper's statement that 'minimizing KL divergence is equivalent to minimizing cross-entropy' is only true for the forward direction, not the reverse direction used in the proof. Moreover, with p_y one-hot, D_KL(p‖p_y) is infinite for any p with mass outside the target token, so Eq. (14) is degenerate and cannot be the objective producing the finite training curves in Fig. 3. Eq. (15) then forces p* to be the one-hot target for every chunk and every α>0, making the consistency term irrelevant in the analyzed objective, unlike the empirical loss which clearly depends on α. Consequently, Theorem 1 is a statement about a surrogate objective that the deployed ZeroLock does not minimize; the 'first analytical framework' and the polylog-close-to-BP rate are not established for the actual algorithm. This holds even if Assumption 5 were granted, because the mismatch is at the level of the objective itself.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"ZeroLock proposes a backpropagation-free pipeline-parallel fine-tuning scheme for LLMs in which each transformer chunk is updated with a local loss formed by a frozen readout head and a consistency term, and the paper claims an O~(1/√T) convergence rate that differs from BP only by polylogarithmic factors. The paper also contributes a system design (early forwarding, stage-local checkpoints, state-only inter-stage exchange, failure recovery) and reports prototype measurements on multi-GPU and Android platforms, including a 26.5% memory reduction and 4.9% throughput improvement over PipeDream. The theoretical section maps local chunk updates to a constructed global objective R^t and proves convergence under assumptions that include a nonstandard stability condition.","tokens_in":18014,"tokens_out":12575,"duration_ms":131286,"significance":"The system contribution is concrete and useful: the anonymous repository, the memory decomposition in Fig. 4, the throughput scaling in Figs. 5–6, and the Android deployment in Section IV.D provide evidence that decoupled local-objective training can reduce activation memory and improve pipeline utilization. If the theory were valid, the paper would be the first general-chunking analysis of local-objective LLM training, going beyond the two-chunk analysis of LoPT. However, the main theoretical guarantee is currently about a surrogate objective rather than the implemented loss, so the advertised 'first analytical framework' and the BP-comparable rate are not established; the value of the paper at present rests mostly on the empirical system study.","major_comments":[{"comment":"The theorem's objective is L_t_k(p;α)=α D_KL(p∥p_y)+(1−α)D_KL(p∥p^t_{k−1}), but the implemented local loss is token-level cross-entropy with one-hot labels. For one-hot p_y, D_KL(p∥p_y) is infinite for any p with positive mass on non-target tokens, so Eq. (14) is degenerate; its minimizer is p_y for every α>0, and the consistency term in the analyzed objective is inactive. The finite training curves in Figs. 3 and 8(b) therefore cannot come from Eq. (14). Lemma 2 and Theorem 1 are derived for Eq. (14), so the O~(1/√T) claim does not apply to the implemented algorithm. Equation (4) also carries a minus sign before Dψ(p,p_y), which is inconsistent with both Eq. (14) and the statement that minimizing (4) equals minimizing cross-entropy.","section":"Section II.C, Eq. (14) vs Section III.B.1(a)"},{"comment":"The convergence theorem is stated for R^t(ω;α) in Eq. (19), the sum of per-chunk local KL divergences with time-varying targets p*^t_k(α). Lemma 3 constructs R^t so that the ZeroLock update is exactly ω^{t+1}=ω^t−η∇R^t; this is an identity by definition rather than a derivation that local updates optimize the global task loss L(p)=L_Task(p). The abstract's comparison with BP is therefore between a surrogate-objective rate and a global-objective rate. The only link to L is Proposition 1, and its error terms δ_k are not bounded or controlled in the analysis, so the final-chunk global loss decrease is not guaranteed by Theorem 1.","section":"Section II.C, Lemma 3 and Theorem 1"},{"comment":"Lemma 4's drift bound and hence Theorem 1's rate depend on the quadratic control of the first-order variation of R^t along the moving distribution, ⟨∇_{p̃^t}R(ω^t;α,p̃^t), p̃^{t+1}−p̃^t⟩_+ ≤ C_fo(α)∥p̃^{t+1}−p̃^t∥². This is a nonstandard and nontrivial condition; the paper calls it 'reasonable' but neither derives it from the transformer/LoRA architecture nor verifies it empirically. If it fails, the cumulative drift D_T(α) is no longer upper bounded by a constant times Σ η_t², so the proof's rate does not follow. The assumption needs a derivation or a numerical check, and Theorem 1 should list it explicitly as a condition that must be verified.","section":"Section II.C, Assumption 5 (Stability)"}],"minor_comments":[{"comment":"The notation p̃^t is used in Assumption 5 and Lemma 4 without a formal definition; define p̃^t=(p^t_0,...,p^t_K) and state its domain explicitly.","section":"Section II.C"},{"comment":"The statement that p*^t_k(α) is the minimizer of L^t_k(p;α) is asserted 'with proof omitted here'; since this is a short convexity argument, it should be included or referenced.","section":"Section II.C, Lemma 2"},{"comment":"The heading 'Andriod Phones' should be 'Android Phones,' and Fig. 3's 'negative-likelihood loss' should be 'negative log-likelihood loss.'","section":"Section IV.D and Table II"},{"comment":"The caption contains 'microbathch' and 'repetitively,' which should be 'microbatch' and 'respectively.'","section":"Fig. 1 caption"},{"comment":"The recovery-latency definition says 'the during between,' which should be 'the duration between.'","section":"Section IV.C"}],"recommendation":"major_revision","confidential_remarks":"The empirical system evaluation appears solid and could support a systems-oriented paper, but the advertised theoretical contribution is not supported as written. I would ask the editor to require either a full re-derivation of the convergence result for the actually deployed cross-entropy loss, or a repositioning of the paper that drops the 'first analytical framework' and BP-comparable rate claims. The nonstandard Assumption 5 also needs to be justified or verified before any convergence claim is retained."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know before you read it. First, the paper delivers a concrete BP-free pipeline system for LoRA fine-tuning on GPUs and Android phones, with real memory savings and a plausible throughput story. Second, the theoretical section—which the abstract sells as the main novelty—has a load-bearing gap: Theorem 1's O~(1/sqrt T) rate is proved for a surrogate objective that is not the loss the deployed algorithm optimizes. The stress-test note is correct, and the gap is not cosmetic.\n\nWhat is genuinely new and good: the system design is specific and practical. Early forwarding, stage-local checkpoints, state-only exchange, failure recovery, and the ExecuTorch marker trick to split forward from backward on mobile are real engineering contributions. The Android prototype is, as far as I know, the first for local-objective BP-free training. The memory reduction (26.5% peak vs PipeDream) is backed by a component-level breakdown, and the throughput gain (4.9%) is modest but honestly presented. The paper also credits its main inspiration [18] clearly and includes an AI-use disclosure.\n\nThe soft spot is the theory. The local loss used in the proof, Eq. (14), is alpha D_KL(p || p_y) + (1-alpha) D_KL(p || p_{k-1}). With p_y one-hot, D_KL(p || p_y) is infinite for any p with mass on a non-target token, so the only finite minimizer is p = p_y itself, independent of alpha. Lemma 2's geometric-mean p* collapses to the one-hot target, making the consistency term irrelevant in the analyzed objective. That is not the cross-entropy loss actually optimized in training, which is forward KL and never forces exact one-hot outputs. The paper's claim that \"minimizing KL is equivalent to minimizing cross-entropy\" confuses the forward and reverse directions. This severs the link between Theorem 1 and the algorithm, regardless of Assumption 5 (which is itself nonstandard and only loosely justified). Also, the theorem's rate is for the constructed R^t, not the global fine-tuning loss, so the abstract's \"differs from BP only by polylog\" overstates what is shown.\n\nThese problems are addressable: re-run the analysis for the actual forward-KL loss, or drop the convergence claim and keep the empirical and system contributions. The empirical memory claim and the prototype stand on their own. This paper is for systems people working on edge LLM training and BP-free methods; it deserves a serious referee because the system is real and the theoretical question matters, but I would not cite the convergence result as-is.\n\nRecommendation: send to peer review with the expectation of major revision. The theory must be reconciled with the implementation, or the theoretical claims must be scaled back to match what is proved.","headline":"Real system and Android prototype, but the convergence theorem is proved for a degenerate reverse-KL objective that the implementation doesn't actually minimize.","tokens_in":18557,"tokens_out":2880,"would_cite":false,"duration_ms":31779,"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":"The paper claims that backpropagation-free, chunk-decoupled LLM fine-tuning converges at the same rate as backpropagation and, in prototype, cuts memory by 26.5% while raising throughput by 4.9%.","keywords":["backpropagation-free training","pipeline parallelism","local objective construction","LLM fine-tuning","edge computing","convergence analysis","memory efficiency"],"falsifier":"Run ZeroLock on a real chunked LLM, recording at each iteration the readout distributions $\\tilde{p}^t$ and $\\tilde{p}^{t+1}$ and the inner product $\\langle\\nabla_{\\tilde{p}} R^t, \\tilde{p}^{t+1}-\\tilde{p}^t\\rangle$; if the positive part of this quantity ever exceeds $C_{\\mathrm{fo}}(\\alpha)\\|\\tilde{p}^{t+1}-\\tilde{p}^t\\|^2$ for the required constant, Assumption 5 is violated and the drift bound—and with it the claimed $\\tilde{\\mathcal{O}}(1/\\sqrt{T})$ rate—fails on that run.","tokens_in":17438,"feed_emoji":"⚡","tokens_out":13389,"duration_ms":131430,"temperature":0.7,"pith_summary":"ZeroLock is an algorithm and system for fine-tuning large language models at the network edge without backpropagation. The paper claims that splitting the model into chunks and giving each chunk its own local objective lets all chunks update concurrently, removing the inter-stage waiting and long-lived activation storage that backpropagation forces. It further proves that this decoupled update rule converges at $\\tilde{\\mathcal{O}}(1/\\sqrt{T})$, the same rate as standard stochastic gradient descent on a suitable surrogate objective, differing from backpropagation only by polylogarithmic factors. The paper also reports a working prototype in which ZeroLock uses 26.5% less peak memory and achieves 4.9% higher throughput than a strong pipeline-parallel backpropagation baseline. If these claims hold, edge-device LLM fine-tuning would gain a principled BP-free alternative that trades a polylog factor in theory for large practical gains in memory and pipelining.","feed_headline":"Backprop-free LLM training matches backprop convergence rate","feed_subtitle":"ZeroLock decouples chunk updates with local objectives, cutting memory 26.5% and raising throughput 4.9%.","key_machinery":"The load-bearing identity is the local-optimum representation of Lemma 1: the minimizer $p^*_k$ of chunk $k$'s local loss can be rewritten as the minimizer of $\\langle\\nabla L(p_{k-1}), p-p_{k-1}\\rangle + \\frac{1}{\\alpha}D_\\psi(p,p_{k-1})$, connecting a purely local objective to the global loss $L$. For the KL special case, Lemma 2 turns this into the closed-form geometric-mean target $p^*_k \\propto p_y^\\alpha p_{k-1}^{1-\\alpha}$. Lemma 3 then shows that the chunk-wise gradient steps compose exactly as a gradient step on the surrogate objective $R^t(\\omega;\\alpha)$, whose Jacobian is block-diagonal, so the decoupled updates are not an approximation at the level of the surrogate. Lemma 4, driven by the stability assumption, bounds the drift of this surrogate between iterations, and Theorem 1 closes the argument with a standard nonconvex SGD bound.","core_discovery":"The paper's central claim is that local-objective-based decoupled training, previously a heuristic, can be mapped onto a global objective and analyzed as such. Concretely, the paper shows that the optimal update of each chunk's readout distribution is the solution of a composite objective formed by a global-gradient term and a Bregman-divergence penalty (Lemma 1); that for KL divergence this optimum is the normalized geometric mean $p^*_k(l) \\propto p_y(l)^\\alpha p_{k-1}(l)^{1-\\alpha}$ of the target and the upstream output (Lemma 2); and that the stacked chunk-wise parameter updates equal gradient descent on a single surrogate loss $R^t(\\omega;\\alpha)=\\sum_k D_{\\mathrm{KL}}(\\hat{f}_k(p^t_{k-1};\\omega_k)\\,\\|\\,p^{*,\\,t}_k(\\alpha))$ (Lemma 3). A nonconvex-SGD argument with a drift bound (Lemma 4) then yields Theorem 1: after $T$ iterations the average squared gradient magnitude is $\\tilde{\\mathcal{O}}(1/\\sqrt{T})$, matching the rate of backpropagation up to polylog factors. The same framework yields a chunk-wise performance bound (Proposition 1) showing that near-optimal local updates decrease the final chunk's loss as the number of chunks grows.","pith_inferences":["The theory proves convergence for the KL surrogate objective, but the deployed loss is cross-entropy with a frozen readout head; a controlled experiment that optimizes exactly the geometric-mean KL objective would reveal whether the proven rate transfers to the implemented loss.","The stability assumption is the likeliest point of failure: since the constant $C_{\\mathrm{fo}}(\\alpha)$ is never measured, the drift bound is conditional. Empirically checking the inequality on a few real checkpoints would settle whether the $\\tilde{\\mathcal{O}}(1/\\sqrt{T})$ guarantee holds outside the proof.","The block-diagonal Jacobian view suggests the analysis could extend to asynchronous or heterogeneous update schedules, where chunks take different numbers of local steps per global iteration; such a generalization would need the drift term to absorb the added asynchrony."],"forward_implications":["If the convergence theorem is correct, a model can be split into any number of chunks that update concurrently, and fine-tuning is guaranteed to reach the same worst-case accuracy as backpropagation within a polylog factor of the iteration count.","Because only hidden states are exchanged between stages and activations are released after each chunk's local update, the approach supports larger micro-batches before running out of memory and tolerates slower, higher-latency device links.","Breaking update locking removes pipeline bubbles at the algorithmic level rather than patching them with scheduling tricks, so the throughput gain is structural rather than tuned.","The prototype results show the design is deployable on both multi-GPU servers and mobile phones, and the checkpointing scheme recovers from device failures by replaying only the failed stage's update windows."],"supporting_citations":[{"why":"Supplies the local-objective-construction method that ZeroLock adapts; the paper's Proposition 1 generalizes its chunk-wise analysis to general Bregman divergences.","marker":"[18]"},{"why":"Provides the prior convergence analysis for a local-learning recipe that is limited to two chunks, which this paper extends to general model chunk division.","marker":"[29]"},{"why":"Defines the GPipe pipeline-parallel baseline whose memory and throughput figures ZeroLock compares against.","marker":"[3]"},{"why":"Defines the 1F1B and PipeDream baselines used in the experiments and the update-locking bottleneck that motivates the decoupled design.","marker":"[4]"},{"why":"Gives the LoRA low-rank parameterization that the paper uses to keep per-chunk updates memory-feasible.","marker":"[30]"},{"why":"Supplies the standard nonconvex SGD assumptions (smoothness, bounded gradient, sampling) and analysis template used in the convergence proof.","marker":"[31]"}],"fun_headline_variants":["ZeroLock: no backprop, same convergence, 26.5% less memory","Backprop-free LLM training: ZeroLock cuts memory, boosts throughput","ZeroLock: decoupled updates match BP convergence, shrink memory","Train LLMs without backprop: ZeroLock matches convergence rate","ZeroLock: BP-free fine-tuning, 26.5% lower memory, 4.9% faster"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The rate proof rests on an unverified stability condition: the surrogate loss must change no faster than quadratically as the readout distribution moves from one iteration to the next, and the paper labels this 'reasonable' without deriving or measuring it.","fun_headline_variants_meta":{"raw":{"variants":["ZeroLock: no backprop, same convergence, 26.5% less memory","Backprop-free LLM training: ZeroLock cuts memory, boosts throughput","ZeroLock: decoupled updates match BP convergence, shrink memory","Train LLMs without backprop: ZeroLock matches convergence rate","ZeroLock: BP-free fine-tuning, 26.5% lower memory, 4.9% faster"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001127,"raw_usage":{"total_tokens":4741,"prompt_tokens":1059,"completion_tokens":3682,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":675,"completion_tokens_details":{"reasoning_tokens":3579}},"tokens_in":675,"tokens_out":3682,"duration_ms":31440,"temperature":1.0,"reasoning_tokens":3579,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T00:36:54.611405+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run ZeroLock on a real chunked LLM, recording at each iteration the readout distributions $\\tilde{p}^t$ and $\\tilde{p}^{t+1}$ and the inner product $\\langle\\nabla_{\\tilde{p}} R^t, \\tilde{p}^{t+1}-\\tilde{p}^t\\rangle$; if the positive part of this quantity ever exceeds $C_{\\mathrm{fo}}(\\alpha)\\|\\tilde{p}^{t+1}-\\tilde{p}^t\\|^2$ for the required constant, Assumption 5 is violated and the drift bound—and with it the claimed $\\tilde{\\mathcal{O}}(1/\\sqrt{T})$ rate—fails on that run.","supporting_citations":[{"cited_title":"Depth-progressive monotonic learning without global backpropagation,","cited_arxiv_id":null,"evidence_quote":"Supplies the local-objective-construction method that ZeroLock adapts; the paper's Proposition 1 generalizes its chunk-wise analysis to general Bregman divergences."},{"cited_title":"GPipe: Efficient training of giant neural networks using pipeline parallelism,","cited_arxiv_id":null,"evidence_quote":"Defines the GPipe pipeline-parallel baseline whose memory and throughput figures ZeroLock compares against."},{"cited_title":"PipeDream: Generalized pipeline parallelism for DNN training,","cited_arxiv_id":null,"evidence_quote":"Defines the 1F1B and PipeDream baselines used in the experiments and the update-locking bottleneck that motivates the decoupled design."},{"cited_title":"LoRA: Low-rank adaptation of large language models,","cited_arxiv_id":null,"evidence_quote":"Gives the LoRA low-rank parameterization that the paper uses to keep per-chunk updates memory-feasible."}],"review_version":1}