acceptodds
Under review as a conference paper at ICLR 2027

How Weight Tying Elicits Iterative Computation in Looped Transformers

22 views

Abstract

Looped transformers apply the same block of layers many times to each input, and have been shown to learn iterative solutions that progress roughly one step per iteration (a staircase). It remains unclear, however, how exactly weight tying leads to such solutions. We investigate this using directed permutation traversal, a task in which a model must report the node reached after hops from a starting node. Its precisely defined intermediate states let us track the model's progress iteration by iteration and layer by layer using linear probes and causal interventions. We find that the underlying mechanism is gradient pooling, the summing of gradients across repeated uses of the shared block. We test this by giving each iteration its own copy of the block and varying how much of each copy's update comes from the pooled gradient. With more pooling, the task is learned more quickly and reliably, and the solution moves from the layout of untied models, which expose intermediate states only near the output, to the staircase. Conversely, training a looped model on only one iteration's gradient, however it is scaled or sampled, prevents the solution from forming. Pooling thus favours a reusable hop operation which, once formed, is composed across iterations, explaining both the rapid acquisition of multi-hop capability during training and the staircase at inference. Together, these findings provide a mechanistic account of how weight tying elicits iterative computation, informing design choices as looped models scale.

Primary area:
interpretability and explainable AI
Keywords:
looped transformers, weight tying, mechanistic interpretability, iterative computation, training dynamics

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_vnhfOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This work is focused on weight tying in looped transformers, where a block of layers is reused multiple times during a forward pass to iteratively solve a given task. The authors investigate its effect on directed permutation traversal task, where the model's goal is to predict a node reached after H hops. Prior work (Sesodia et al., 2026) showed that on this task, looped models expose intermediate hops along a "staircase", where one hop corresponds roughly to one iteration. The paper's main contribution is the claim that gradient pooling (the summation of gradients per each iteration into the shared block's parameters) is the cause of this behavior. The authors use training interventions to validate this argument (e.g. interpolation between pooled and per-iteration updates or replacement of the summed gradient with alternatives). Linear probes are used to observe where intermediate states appear, and causal interventions are used to test whether the model uses them.

Critical strengths
  • The task is well chosen: its intermediate states are exactly defined but never supervised, which lets the authors track the model's progress layer by layer with probes and causal interventions, both with proper controls.
  • Gradient routing (§4.2, Fig. 5) keeps the tied forward computation and changes only how the gradient is aggregated, which is a useful attempt to separate "the block is applied repeatedly" from "its gradient is summed", two explanations that are normally inseparable. The partial-pooling results are also consistent: the more pooled model solves the task first in 24 of 30 pairs (§B.2).
  • The paper first establishes that neither the task (untied models solve it) nor the architecture (the no-curriculum looped run) forces the staircase (§4). The cyclic vs. contiguous result (§4.4, Fig. 7) also gives a plausible explanation for an observation from prior work (Takase & Kiyono, 2023; Mixture-of-Recursions).
  • Limitations are reported honestly, and the work is reproducible. Negative or unclear results (the register machine and N=32 in §C, the optimizer confounds in §A.7) are reported, and the setup, seeds and code are fully specified (§A, §A.8).
Critical weaknesses
  1. The experiments do not isolate the effect of the sum (§4.1, §4.2). When a block is reused, the sum of its gradients is simply its correct gradient, so the two always go together. Any α<1 lets the copies drift apart, so the block is no longer exactly reused either. At α=0 the model is weaker than the paper's own untied model (Table B.5 vs. A.4). Gradient routing replaces the correct gradient with a wrong one (last iteration only) or a noisy one (random iteration), so their failure does not single out the sum; the random variant fails even H=1 in 2 of the 3 seeds. Also, only α=1 forms the full staircase in Fig. 1(a), although α=0.75 also solves the task (Table B.5), which suggests that exact tying matters, not only the amount of pooling.
  2. A fully pooled model trained without the curriculum solves the task without the staircase (one run, Fig. B.4), and the curriculum's role is not otherwise tested. So pooling on its own may not be enough.
  3. The evidence for a reused one-hop step (§4.3) does not separate pooling from reuse either. The within-block result fits any tied model doing one hop per iteration, and the burst is compared with an untied model that starts as eight copies of the looped block and is much weaker than the paper's own untied model (Table B.6 vs. A.4). In one looped model every hop is readable, yet swapping hidden states between prompts never makes it follow the swapped-in state (matched-rate seed 44, Tables B.1 and B.4).
  4. One small synthetic task, small models and mostly three seeds, yet the title and conclusion present a general mechanism and extend it to large looped models (§6).
Questions for authors
  1. Does the staircase need exactly identical weights, or is the summed update enough? For example, give each iteration its own copy of the block, start the copies from different initialisations, and update all of them with the summed gradient (W1). The learned part is then still shared, but the weights used at each iteration differ.
  2. Does the random-iteration result hold with less noise? For example, by summing a random subset of iterations, or averaging several random draws per step (W1). If summing still clearly beats these, it would substantially strengthen the main claim.
  3. The one fully pooled run without the curriculum shows no staircase (Fig. B.4). Does this hold over more seeds, and does more pooling still help without the curriculum (W2)? If the staircase needs the curriculum, please state this in the main claims.
4 comments
AuthorsOpenReview ↗

Author Response to Reviewer vnhf

Thank you for your feedback! We appreciate that you recognized the merits of the task design. We ran both experiments you suggested in Q1 and Q2, and narrowed our central claim accordingly.

W1: "The experiments do not isolate the effect of the sum (§4.1, §4.2). When a block is reused, the sum of its gradients is simply its correct gradient, so the two always go together. [...] only α=1 forms the full staircase in Fig. 1(a), although α=0.75 also solves the task (Table B.5), which suggests that exact tying matters, not only the amount of pooling."

Our response: We agree that the sum cannot be separated from reuse, and in the revised pdf we have removed language that suggested otherwise. We also agree that α<1\alpha<1 lets the copies drift apart, which §4.1 now states as a caveat, and that tying matters, which the experiment you proposed in Q1 confirms, although nearly tied weights suffice. The revised claim is therefore that summing gradients from several iterations builds the operator only on tied or nearly tied weights, and we address the noise in gradient routing in Q2.

W2: "A fully pooled model trained without the curriculum solves the task without the staircase (one run, Fig. B.4), and the curriculum's role is not otherwise tested. So pooling on its own may not be enough."

Our response: We agree, and the revised pdf states that our claims concern training with the curriculum. Two further looped seeds trained without the curriculum do not solve the task, and neither do untied models reliably (Appendix B.1). The solving run serves only to show that the looped architecture does not force the staircase.

W3: "The evidence for a reused one-hop step (§4.3) does not separate pooling from reuse either. [...] In one looped model every hop is readable, yet swapping hidden states between prompts never makes it follow the swapped-in state."

Our response: We agree that the within-block analysis and the burst do not separate the sum from reuse. Their role is to characterize the operator that pooling builds. For the looped model you mention, our discussion of probes now states that readable states are not always used.

W4: "One small synthetic task, small models and mostly three seeds, yet the title and conclusion present a general mechanism and extend it to large looped models (§6)."

Our response: We agree, and in the revised pdf we removed the extrapolation to large models from the conclusion. The Scope paragraph (§5) states the single task, small models and seed counts, and now also that our claims concern training with the curriculum.

Q1: "Does the staircase need exactly identical weights, or is the summed update enough? For example, give each iteration its own copy of the block, start the copies from different initialisations, and update all of them with the summed gradient."

Our response: Thank you for suggesting this experiment, which we ran (§4.1). With the summed update, copies that start identical or close together form the looped staircase, while independent copies do not solve the eight-hop task. The staircase therefore needs nearly identical weights, though not exactly identical ones, and the summed update alone is not enough.

Q2: "Does the random-iteration result hold with less noise? For example, by summing a random subset of iterations, or averaging several random draws per step. If summing still clearly beats these, it would substantially strengthen the main claim."

Our response: We ran random subsets of one, two and four of the eight iterations, rescaled so that each has the full sum as its expected update (§4.2, updated Fig. 5). Summing four solves the task like the full sum, while one or two do not. A correct expected update is therefore not enough, and so we revised the title of §4.2 to "Pooling several iterations per update builds the operator".

Q3: "Does this hold over more seeds, and does more pooling still help without the curriculum? If the staircase needs the curriculum, please state this in the main claims."

Our response: Without the curriculum, neither looped nor untied models solve the task reliably across seeds (Appendix B.1), so we could not test pooling in that setting. Contribution 1 and the Scope paragraph (§5) now state that our claims concern curriculum training.

Area_Chair_NE3tOpenReview ↗

AC Request

Dear Reviewer,

Thank you very much for your time and feedback. I would greatly appreciate if you could confirm if the rebuttal addresses your concerns and let them know about any remaining concerns.

Best regards, AC

Thank you for the response and for running the experiments from Q1 and Q2. The rebuttal addresses most of my concerns about the claims.

The new experiments went against the original claim, and the revision narrowed it. The paper now says what the results show: the staircase needs tied or nearly tied weights, and the summed update is not enough on its own (W1, Q1). The claims are now also limited to training with the curriculum (W2, Q3), the probes paragraph says that readable states are not always used (W3), and the extension to large models is removed from the conclusion (W4).

Two smaller points remain. First, the abstract still says that "the underlying mechanism is gradient pooling", and Fig. 1 is still titled "Gradient pooling elicits iterative solutions". Both read as if pooling were enough, with no mention that it needs tied or nearly tied weights, or that the claims hold only for training with the curriculum.

Second, on Q2, an update built from one or two iterations is noisier than one built from four, while the expected update is the same in all cases. So the result may only show that a very noisy update fails, which is true of training in general and says little about pooling.

What keeps me from raising my score is the contribution (W4). Sesodia et al. (2026) already showed the staircase on this task, and this paper builds on it. What the paper mainly adds is when the staircase forms: with tied or nearly tied weights, and with updates built from several iterations. That is useful to know, but it is shown on one small task with small models, and it is not yet known whether the finding carries over to other tasks. The paper is open about this (§5), and it is clear and carefully done, but to me the contribution is modest and specific to this one setup.

I keep my rating at 2.

AuthorsOpenReview ↗

Author Response to Reviewer vnhf

Thank you for your reply and continued engagement. We respond to your remaining points below.

First, the abstract still says that "the underlying mechanism is gradient pooling", and Fig. 1 is still titled "Gradient pooling elicits iterative solutions". Both read as if pooling were enough, with no mention that it needs tied or nearly tied weights, or that the claims hold only for training with the curriculum.

Our response: The title and the abstract's second sentence frame our pooling claims within weight-tied looped transformers. Since our partial-pooling and distinct-initialization experiments also applied pooling to untied weights to probe the mechanism, we have, for the avoidance of doubt, revised the abstract to state that tied or nearly tied weights are needed, and the title of Fig. 1 to state weight tying.

The revised abstract also now states the curriculum condition, which is echoed in Contribution 1, the training details of §3, and the Scope paragraph of §5.

Second, on Q2, an update built from one or two iterations is noisier than one built from four, while the expected update is the same in all cases. So the result may only show that a very noisy update fails, which is true of training in general and says little about pooling.

Our response: We agree that learning may fail if the updates are too noisy. For a tied block, though, pooling is the mechanism that reduces this noise, which is consistent with our hypothesis in §4.1. The result therefore shows that weight-tied models need each update to combine several iterations.

What keeps me from raising my score is the contribution (W4). [...] it is shown on one small task with small models, and it is not yet known whether the finding carries over to other tasks. [...] to me the contribution is modest and specific to this one setup.

Our response: Looped transformers are widely motivated by an assumed bias towards iterative computation, and we believe that providing a mechanism for how training produces it is a valuable contribution. While our evidence comes from one task with small models, we chose the task deliberately as the minimal sequential task with uniquely defined intermediate states, which is what allowed us to follow the mechanism inside the model. The paper also offers an explanation for the previously unexplained advantage of cyclic over sequential reuse (Takase & Kiyono, 2023; Bae et al., 2025; §4.4).

We hope these revisions and clarifications address your remaining concerns, and would be grateful if you would consider them in your final rating.

Reviewer_ZEfAOpenReview ↗
Rating
3
Confidence
3(+1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Looped transformers apply the same block of layers many times to each input, and have been shown to learn iterative solutions that progress roughly one step per iteration (a staircase). The authors investigate this using directed permutation traversal, a task in which a model must report the node reached after H hops from a starting node, and find that the underlying mechanism is gradient pooling, the summing of gradients across repeated uses of the shared block. With more pooling, the task is learned more quickly and reliably, and the solution moves from the layout of untied models, which expose intermediate states only near the output, to the staircase.

Critical strengths
  1. The research question is clearly defined.
  2. The training intervention is novel and cleverly designed.
  3. Detailed information regarding reproducibility is provided.
Critical weaknesses
  1. The distinction between the core argument and alternative explanations is not sufficiently clear.
  2. The evidence supporting the proposed mechanism is largely indirect.
  3. The scope of the experiments is narrow: it involves only a single synthesis task, small-scale models, and a limited number of random seeds.
  4. The conclusions are generalized beyond what the current evidence can support.
Questions for authors

Section 2:

  1. Zhang et al. conclude that this phenomenon is " which they attribute to an architecture prior" whereas the central argument of this paper is that the staircase pattern is determined by training rather than architecture. Does this paper’s conclusion overturn theirs, or are both findings valid within their respective settings? Section 3:
  2. This section acknowledges that "the two are not matched in parameter count (3.22M against 25.72M) or in initialisation," yet it fails to provide a comparison under equivalent conditions. Consequently, the observed differences in behavior between the two types of models cannot be attributed solely to weight sharing. Section 4:
  3. The paper hypothesizes that " this gradient pooling is what is responsible for building the reusable one-hop operator, and not the architectural fact that the shared block is repeatedly applied" However, in the experiments conducted, these two factors invariably appear or disappear together, making it impossible to disentangle their respective effects. To substantiate this claim, a controlled experiment is required: one that maintains gradient aggregation while employing a distinct, independent module for each iteration. Section 5:
  4. The authors write that the transplanted state “redirects the remaining traversal in about half of trials,” and they acknowledge that “in some models transplanting a readable state leaves the answer unchanged.” This indicates that a portion of the state read by the probe is not actually utilized by the model. However, since the mechanistic conclusions of this paper are primarily based on the probe results, this section fails to discuss the implications of this finding for those main conclusions.
  5. This section states that “All results come from this one task, with models of 3M to 26M parameters,” and the only other task included “did not test the staircase as intended” Nevertheless, the conclusion in Section 6 generalizes to the claim that “as looped models scale beyond tens of billions of parameters, the bias can be controlled through careful design of the backward pass” This inference is not sufficiently supported by the experiments presented in the paper.
3 comments
AuthorsOpenReview ↗

Author Response to Reviewer ZEfA

Thank you for your feedback! We appreciate that you found the training intervention novel and cleverly designed. We ran the experiment you suggested in Q3, narrowed our central claim, and addressed your questions below.

W1: "The distinction between the core argument and alternative explanations is not sufficiently clear."

Our response: Our core claim is that summing gradient contributions from several iterations onto nearly identical weights builds a reusable one-hop operator (§4.1). We test the main alternatives, the architecture itself (§4.2), the amount of training per parameter (§4.4) and a shared starting point alone (§4.1), with experiments that each hold one of them fixed.

W2: "The evidence supporting the proposed mechanism is largely indirect."

Our response: The training interventions test the mechanism directly, since we change the update and measure whether, when and where the solution forms. We also test causally that the model uses the states it builds (§4.3).

W3, W4, Q5: "The scope of the experiments is narrow" and "The conclusions are generalized beyond what the current evidence can support", in particular "tens of billions of parameters".

Our response: We agree. In the revised pdf, we removed the extrapolation to models with tens of billions of parameters from §6, so the conclusion now stays within the single task, and the model sizes are clearly stated (§5).

Q1: "Does this paper's conclusion overturn [Zhang et al.'s], or are both findings valid within their respective settings?"

Our response: Both are valid within their settings. Zhang et al. show that the looped architecture favors a stepwise solution, and we show how training selects it. Specifically, the same tied architecture does not build the staircase when each update sums too few iterations (§4.2). We note that their setting also supervises every intermediate step, while ours supervises none and so leaves the choice of solution to training.

Q2: "This section acknowledges that 'the two are not matched in parameter count (3.22M against 25.72M) or in initialisation,' yet it fails to provide a comparison under equivalent conditions. Consequently, the observed differences in behavior between the two types of models cannot be attributed solely to weight sharing."

Our response: We agree this was not clear in the original text. Below full pooling (α<1\alpha<1) the copies of the partial-pooling models diverge, so these models all have 25.7M distinct parameters and the same initialization, and differ only in how much each update is pooled (§4.1). Within this matched family, more pooling makes solving the task more likely and earlier (Appendix B.2). Full pooling (α=1\alpha=1), which keeps the copies identical, is the only setting that builds the complete staircase.

Q3: "The paper hypothesizes that 'this gradient pooling is what is responsible for building the reusable one-hop operator, and not the architectural fact that the shared block is repeatedly applied' However, in the experiments conducted, these two factors invariably appear or disappear together, making it impossible to disentangle their respective effects. To substantiate this claim, a controlled experiment is required: one that maintains gradient aggregation while employing a distinct, independent module for each iteration."

Our response: We have run the suggested experiment (§4.1). With the pooled update, independent blocks do not solve the eight-hop task, while both closely and identically initialized blocks form the looped staircase. The submitted claim was therefore too strong, and the revised pdf states that the pooled update builds the operator only on tied or nearly tied weights.

Q4: "The authors write that the transplanted state 'redirects the remaining traversal in about half of trials,' and they acknowledge that 'in some models transplanting a readable state leaves the answer unchanged.' This indicates that a portion of the state read by the probe is not actually utilized by the model. However, since the mechanistic conclusions of this paper are primarily based on the probe results, this section fails to discuss the implications of this finding for those main conclusions."

Our response: We agree and have added the implication to the Probes paragraph (§5). Readable states are not always used, so we read the staircase as marking where states are available. Our main conclusions compare training conditions by whether they solve the task and where states become readable, and neither depends on every readable state being used.

Thank you for your detailed response and the revisions you have made.

All of my previous concerns have been addressed. I appreciate that you conducted the requested control experiments based on my suggestion regarding Question 3 (Q3). Your explanation of the "matched partial-pooling" family also resolved my questions from Question 2 (Q2) concerning the number of parameters and their initialization. Your response to Question 1 (Q1) clearly defines the relationship between this study and the work of Zhang et al. Furthermore, the addition of a discussion on probe experiment results in Section 5 (§5) and the removal of content regarding extrapolation to larger-scale models in Section 6 (§6) have addressed my remaining concerns about the scope of the study.

In light of these clarifications, I am maintaining my score of 3 and have increased my confidence level.

Thank you for your thoughtful engagement, and for raising your confidence! We are glad the revisions have addressed all of your concerns.

Reviewer_TWdZOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper develops a set of techniques and ablations to study the inductive bias of looped transformer models compared with similar untied models by selectively pooling gradients across layers compared with a variety of baselines with partial or selective weight-tying. The models are evaluated on a synthetic 'directed permutation traversal' task, and performance is measured in terms of 'how far' each model gets on this directed chain of pointers, and when it learns these steps. They demonstrate through a series of empirical results that gradient pooling over all steps appears to be the most significant factor contributing to the performance advantage of looped models over untied models on these tasks. They perform careful ablations to try to make this argument sound.

Critical strengths

The general paper, related work, methods, and results well presented. The paper is written in a nice story-telling style that is refreshing compared to a large portion of the more mechanical submissions that I have read. The cross references throughout the paper make it sufficiently accessible while not being too dense.

The empirical evaluation is well done and there are relevant ablations and baselines (e.g. figure 5). While I think some of the claims or wording could be made more precise (or further ablations could be performed, see weaknesses) the overall hypothesis and claim of the paper is well interesting and well supported even if not fully proven (in my opinion) beyond a doubt.

Critical weaknesses

My major concern with the paper is conceptual and fundamental, surrounding the precise framing: "We hypothesise that this gradient pooling is what is responsible for building the reusable one-hop operator, and not the architectural fact that the shared block is repeatedly applied." To me, these two properties are fundamentally inseparable -- if you have shared gradients and shared initialization, you will have shared application of the weights. There is no way to repeatedly apply a shared block while using non-shared gradients (they will immediately diverge from being 'shared weights' after the first training step). I understand what the authors mean after reading the full paper and their set of experiments, but this is likely to be somewhat confusing to other readers if presented this plainly. I would therefore recommend the authors try to remove language that is this strong about gradient pooling being significantly separable from shared application. The results the authors have found on their own are interesting and valuable -- they should not (and do not need to) over-state them to avoid potential confusion, precision of wording is more valuable.

Related to the point above: one major baseline which would address directly this distinction between shared weights and shared gradients would be to try non-shared initializations with perfectly-shared-gradients. Did the authors experiment with this? If this similarly shows strong performance on this task similar to looped models, then this would be another argument for their hypothesis, and a more direct statement about 'shared gradients'.

The second biggest weakness of the paper is relatively limited novelty. The paradigm buildis heavily on prior work, and introduces only a few small ablations/experiments related to gradient pooling and weight tying as the new axes through which to investigate the problem. I believe that the results and analysis are sufficiently insightful to make the paper valuable and interesting to the community, but the paper is more of an empirical evaluation than a novel interpretability method development.

Minor: The authors should note that Figure 2 is also effectively an exact reproduction of Figure 2 from Sesodia et al. 2026.

Questions for authors

Could there be other ways to investigate looping other than this one axis of pooling gradients? For example, prior work proposes to project the parameters towards a weighted mean at every update (https://openreview.net/forum?id=BC10Dk7nv2). Do you believe this type of alternative would yield different conclusions? I don't mean this paper's method in particular, I just mean thinking more broadly about other ways to 'interpolate' between looped and untied models.

I dont know if I understand this: "If sharing acts only through the amount of training per parameter, cyclic and contiguous should behave similarly. If it acts by making one set of weights serve every stage of the computation, cyclic should behave like the looped model and contiguous like the untied one." Can you explain why this is the hypothesis? Specifically the second sentence seems like an oversimplification of the system. Could it not be that there are far more complicated optimization dynamics at play between these two systems? For example, the fact that B in the cyclic sharing version gets 'earlier' training signal from shorter paths could explain some benefits? I think these additional confounders should be mentioned at least if not controlled for. Your results in Fig 7b seem to support the idea that this is a reasonable alternative hypothesis. (I think you get at this point a bit with the mentioned caveat 'One caveat is that A’s output passes through B before A recurs, so the cyclic result is also consistent with a two-block unit AB being reused rather than one block composing with itself', but I think you should make this more prominent of a discussion. This is a big caveat and should potentially be explored further or otherwise stated more honestly.)

3 comments
AuthorsOpenReview ↗

Author Response to Reviewer TWdZ

Thank you for your feedback! We appreciate that you found the empirical evaluation well done and liked the story-telling style of presentation. We corrected wording surrounding the claims you highlighted, and ran the baseline you suggested (non-shared initializations with perfectly-shared-gradients).

W1: "These two properties are fundamentally inseparable [...] I would therefore recommend the authors try to remove language that is this strong about gradient pooling being significantly separable from shared application. [...] try non-shared initializations with perfectly-shared-gradients. Did the authors experiment with this?"

Our response: We agree that gradient pooling cannot be separated from the repeated application of shared weights. In the revised pdf, we have removed language that suggested otherwise.

We also ran the baseline you suggested, giving each iteration its own copy of the block, starting the copies from different initializations and updating all of them with the same pooled gradient (§4.1). Copies that start identical (or close together) solve the eight-hop task and form the looped staircase, while fully independent copies do not. We therefore revised Contribution 1 to state that the pooled update builds the reusable one-hop operator only when weights are (nearly) tied.

W2: "Relatively limited novelty [...] more of an empirical evaluation than a novel interpretability method development."

Our response: We agree that the paper does not propose a new interpretability method. Our empirical study explains how training produces the staircase that prior work observed, which we test by altering the correct backward pass of a tied block in controlled ways.

Minor: "Figure 2 is also effectively an exact reproduction of Figure 2 from Sesodia et al. 2026."

Our response: Thank you, the caption now credits Sesodia et al. (2026).

Q1: "Could there be other ways to investigate looping other than this one axis of pooling gradients? For example, prior work proposes to project the parameters towards a weighted mean at every update [...] Do you believe this type of alternative would yield different conclusions?"

Our response: Thank you for this interesting idea. We do not believe it would yield different conclusions, since our results suggest the staircase forms when a) nearly identical weights are b) updated with gradients summed over several iterations, and projection towards the mean keeps both.

Q2: "Can you explain why this is the hypothesis? [...] the fact that B in the cyclic sharing version gets 'earlier' training signal from shorter paths could explain some benefits?"

Our response: Cyclic and contiguous sharing give each block the same amount of training per parameter, so a difference between them rules out the amount of training as the explanation. Our account predicted that cyclic sharing would help because each block serves every stage of the traversal, while contiguous sharing confines each block to half of it. We agree that predicting cyclic to "behave like the looped model and contiguous like the untied one" was too strong and oversimplified the dynamics. We have relaxed the wording (§4.4) and stated the shorter-path effect you highlighted, which Fig. 7b is consistent with, as a real alternative next to the AB caveat.

Thank you for your direct and honest engagement with my review. The additional baseline is much appreciated and I believe insightful for readers. I believe the paper is a solid contribution and relevant to the community. I recommend acceptance and will raise my score.

Thank you for your careful reading and engagement, and for raising your score and recommending acceptance!

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of new experiments and revisions

Thank you all for your feedback! We appreciate that reviewers found the task well chosen (vnhf), the training interventions novel and cleverly designed (ZEfA), the paper clearly written (TWdZ) and the work reproducible (vnhf, ZEfA).

We have uploaded a revised pdf, with additions in blue and deletions in red.

All three reviewers point out that gradient pooling cannot be separated from the repeated application of shared weights. We agree, and in the revised pdf we have removed language that suggested otherwise. We also ran the experiments the reviewers proposed:

  • Distinct initialization (vnhf Q1, ZEfA Q3, TWdZ W1). Each iteration gets its own copy of the block, started from different initializations and updated with the summed gradient. Copies that start identical or close together form the looped staircase, while independent copies do not solve the task.
  • Subset routing (vnhf Q2). The tied block is updated with a random subset of its iterations, rescaled so the expected update is the full sum. Summing four of the eight iterations solves the task like the full sum, while one or two do not.
  • No curriculum (vnhf W2, Q3). Two further looped seeds trained without the curriculum do not solve the task.

Our revised claim is that summing gradient contributions from several iterations onto nearly identical weights builds the reusable one-hop operator, in models trained with the curriculum.

Main changes in the revised pdf

  • §1: Restated Contribution 1 to require nearly tied weights and updates that pool several iterations, under curriculum training.
  • §4.1: Added the distinct initialization experiment as a new paragraph.
  • §4.2: Retitled "Pooling several iterations per update builds the operator", and added the subset routing experiment (Fig. 5).
  • §5: Updated the Probes, Expressivity and Scope paragraphs.
  • Abstract, §6: Removed the extrapolation to larger models.

We address each reviewer's concerns in our individual replies.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.