acceptodds
Under review as a conference paper at ICLR 2027

Some Tokens Think, Others Remember: Separating Compute and Capacity in LLMs

Abstract

Looped transformers apply a shared block multiple times and have emerged as a parameter-efficient route to scaling compute in language models. However, at fixed FLOPs a looped model has strictly less capacity than a baseline transformer. We argue that compute, the number of sequential operations applied to a hidden state, and capacity, the parameters available at a single step, are distinct scaling axes that standard transformer layers conflate. We propose a dual-path block that exposes both axes as parallel pathways within a single layer: a deep sublayer re-applied 𝐾 times with shared parameters, and a wide sublayer with an enlarged feed-forward network applied once, combined by independent per-token gates. At two FLOP budgets, the best dual-path configuration surpasses both iso-FLOP single-axis controls on aggregate language modelling, commonsense, and math metrics, while using 17–33% fewer parameters than the width-scaled baseline. The learned gates are directly interpretable and show systematic per-token allocation: function words and lexical content trend wide, while punctuation, symbols, and arithmetic tokens trend deep. Our results suggest that compute and capacity can be scaled separately, with the model balancing the two token by token.

Primary area:
foundation or frontier models, including LLMs
Keywords:
looped transformers, parameter sharing, per-token routing, language model pretraining

Reviews

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

This paper argues that there are two distinct scale axes, compute and capacity, in the Looped Transformer. Inspired by this observation, the authors introduce dual-path block and expose these two axies, deep and wide, in parallel with per-token gate to combine them. They show that the best dual-path configuration beats both single-axis with using fewer parameters than the width-scaled control. This paper also shows interpretable results related with the function of word through the gate values per token.

Critical strengths

The perspective of separating compute and capacity provides an interesting way to understand recent studies on looped Transformers and language model scaling. The proposed dual path architecture also demonstrates promising performance at smaller model scales. Also, token-wise mechanistic interpretation through the gates provides additional interesting insights into model behavior.

Critical weaknesses

It is quite unclear whether iso-FLOP comparisons are really fair. The authors should provide a clearer flop computation and generation wall-clock times to establish the fair comparison.

The stability and scalability of the proposed architecture remain concerning. Although the gate soft cap addresses the instability at greater depths, Dual path still underperforms wide path on several benchmarks at L=32. It is unclear whether the proposed architecture remains effective as model depth increases.

Questions for authors
  1. In Equation 9, do the attention FLOPs only account for the query, key, value, and output projections? Are query-key scoring and weighted value aggregation operations, which are dependent on sequence length, excluded? If so, the flops of the looped and dual-path settings may be underestimated, meaning they could use more FLOPs than reported. Additionally, reporting generation wall-clock times would help readers compare these methods from practical perspective.

  2. In Table 3, dual path still underperforms pure wide path on language modeling and commonsense tasks at L=32, even with the gate soft cap. Could the authors explain why its advantage decreases at greater depths and whether this issue persists at larger scales, w,r,t scalability?

  3. Could the authors include an ablation comparing the learned token-wise gates with static gates in the same dual path architecture? It will help the reader to understand whether the effectiveness is from "token-wise" gates or just gating itself.

3 comments

Thank you for your detailed review, we appreciate the input and thank the reviewer for highlighting the strengths of our novel architecture. We ran new experiments for all three points raised by the reviewer, see the results below.


W1/Q1:

  • As mentioned by the reviewer the QK^T and AV are excluded from the FLOPs calculation. What our budget matches is weight-matmul FLOPs per token, which we will clearly state in the final version. Note that the excluded terms are moderat, at T=4096 Dual K=4 uses 1.27x at F80M and 1.14x at F160M.
  • We have now retrained the baselines at equal total compute: PureWide and PureLoop K=4 widened until their total FLOPs match Dual K=4, we used 3 seeds again:
ParamsC4WikiCS accGSM8KAgg. BPBTrain tok/s/GPU
F80M PureWide927M1.0290.9330.5280.0910.86512.1k
F80M PureLoop257M1.0740.9840.4970.0580.91020.1k
F80M Dual α=25606M1.0330.9320.5270.1070.86514.8k
F160M PureWide1559M1.0160.9180.5390.1080.8517.4k
F160M PureLoop417M1.0420.9460.5180.1200.87314.5k
F160M Dual α=251125M1.0070.8970.5430.1510.8378.8k
(Agg. = mean BPB over C4, WikiText, commonsense, math; seed sd ≤ 0.003. α=25 at F80M: 2 of 3 seeds so far, last one is still queued)
  • The results show that our comparison still holds, i.e. for our largest FLOP budget the dual beats the compute-matched PureWide on every metric with 28% fewer parameters. On our smaller FLOP budget (F80M), PureWide is better on C4, while Dual is better on Math, with 35% fewer parameters.
  • Note that the PureLoop has nearly the same attention compute as the Dual model (4 vs. 5 passes) but its still the weakest model, so the extra attn FLOPs are not solely what makes Dual work.
  • Regarding wall clock time: In our setup (using FSDP across 64 GPUs) Dual models train 1.2-1.5x faster than the compute-matched PureWide. At this size the step time is largely dominated by sharding and syncs, where Dual has about half as many.
  • On a single GPU this flips, the Dual model trains at 0.65x (F80M) & 0.74x (F160M) and prefill at T=4096 tokens takes 1.7x (F80M) & 1.39x (F160M) as long as PureWide.

W2/Q2:

  • The gap most likely comes from the capacity gap, as doubling L doubles every model, i.e. Dual has 236M fewer parameters than PureWide at L=16 and 472M fewer parameters at L=32. Additionally a deeper stack already provides more sequential compute so looping adds less on top of it.
  • We want to note that Dual still leads at L=32 on the compute heavy tasks, i.e. GSM8K 0.175 vs 0.126, math BPB 0.485 vs 0.493 and that the uncapped models at L=32 diverge.
  • We are currently retraining more seeds for this comparison and will post the 3-seed results here when they are finished.

Q3: We have now included experiments where we train the model from scratch with the following gate ablations:

  • token-wise (as in the paper): each token gets its own deep and wide weight, computed from its hidden state
  • token-wise on updates: the same as above but it only scales what each path adds, i.e. y = x + g_d·(h_deep − x) + g_w·(h_wide − x)
  • per-layer: each layer learns one pair of weights that all tokens share
  • static: every token gets 0.5 * deep + 0.5 * wide
GatesC4WikiCS accGSM8K
token-wise (paper, capped)1.0370.9350.5230.118
token-wise on updates1.0330.9300.5250.122
per-layer1.0370.9360.5280.128
static 0.5/0.51.0360.9380.5210.120

We note that most of the gain comes from the dual-architecture itself, as even static mixing gets close. The best variant is token-wise on updates only which we will adapt as our final version, so we want to thank the reviewer for this suggestion! Note that a) uses the gate cap of Table 2, an uncapped run is still training but we will post it here when its done.

We want to thank the reviewer again and hope our initial comment has addressed their main concern. Here are the follow up results which have now finished training:


  • The third seed for Dual α=25 at F80M (first table). With all 3 seeds the row is:
ParamsC4WikiCS accGSM8KAgg. BPB
F80M PureWide927M1.0290.9330.5280.0910.865
F80M Dual α=25606M1.0320.9310.5280.1040.865

The conclusion is unchanged: level on aggregate, PureWide slightly better on C4, Dual better on math, with 35% fewer parameters.


  • L=32 with F80M, α=50, K=4, Dual with gate cap (due to congestion on the cluster and longer training times we only have one seed so far):
L=32C4WikiCS accGSM8KMath BPB
PureWide1.0080.9030.5440.1260.493
Dual1.0140.9050.5410.1750.485

PureWide is ahead on language modelling and commonsense at this depth and Dual keeps a lead on GSM8K and Math BPB. We think these results point to the capacity gap described above (dual model has 472M fewer parameters) and will state this limitation clearly in the final version.


  • Uncapped token-wise gates, same code and seeds as the other gate variants (3 seeds):
GatesC4WikiCS accGSM8K
token-wise (paper, no cap)1.0380.9400.5230.098
token-wise (paper, capped)1.0370.9350.5230.118
token-wise on updates1.0330.9300.5250.122

Without the cap, token-wise gates on the full output are the weakest variant, because they also rescale the residual x by g_d + g_w. Bounding this (cap) or removing it (gates on updates only) fixes it, and the update-only variant remains the best. Since Table 1 used the uncapped variant, its gains are already conservative.

Thank you for the detailed rebuttal and additional experiments. I appreciate the authors' efforts to address my concerns. The new total FLOP experiments largely address my FLOP matching concern and provide encouraging results for the dual-path architecture. However, the single-GPU prefill overhead and missing generation latency still raise questions about practical efficiency.

For Q3, the new ablations show that static and per-layer gates perform comparably to token-wise gating, suggesting that most of the gains comes from the dual-path architecture itself. While this does not undermine the architectural contribution, it makes the benefit of token-wise allocation less clear (Please clarify this, if i'm misunderstanding some contributions). Also, the proposed update only gating changes the original formulation, so it is unclear whether the main results and gate analyses would still hold. +) the L=32 results are still based on a single seed, and the reduced gains on language modeling and commonsense tasks leave my scalability concern unresolved.

Overall, I appreciate the additional evidence, but I will maintain my original rating.

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

The paper tackles the trade-off between computation and parameter capacity in looped language models. Repeating a shared transformer block adds computation without adding parameters, but may limit performance on tasks that require stored knowledge. The authors propose a two-path block that combines a deep path, which repeats a shared transformer sublayer, with a wide path, which uses a larger FFN and runs once. Learned per-token gates combine the outputs. Both paths run for every token, so the gates determine how much each path contributes rather than how much compute is used. The authors train on 38B tokens and report improvements over loop-only and width-only baselines at two reported compute budgets, with fewer parameters than the width-only baseline. They also analyze the gates and intervene on their values to study differences between layers, tasks, and token types.

Critical strengths
  1. The proposed approach is compelling. Given the loss of parameter capacity from sharing weights, combining a looped path with a separate wide path seems like a reasonable way to retain the benefits of both. The authors also test how the model uses the paths, rather than only reporting the final performance. Shuffling the gates increases loss, and forcing arithmetic tokens through the wide path hurts GSM8K more than overriding the same number of random tokens (Tables 4 and 7). These experiments show that the trained model relies on its learned assignments.

  2. The authors evaluate several allocations between the paths and loop counts at two budgets, using the same training data and three seeds for the main results. At the lower budget, the balanced four-loop model uses 483M rather than 719M parameters and improves several metrics over PureWide (Table 1). The authors also report where the gains weaken. In the gate-capped depth sweep, PureWide performs slightly better on language modelling and commonsense at 32 layers, while the dual-path model remains better on math (Table 3). These are promising results against the tested baselines, subject to clarification of the compute accounting below.

Critical weaknesses
  1. The FLOP calculation appears to omit the matrix products for attention scores and the weighted sum of values (Equation 9). These costs differ between models because PureWide runs attention once per layer, PureLoop K times, and the dual-path model K+1 times. This renders claims of matched total compute less convincing.

  2. It is unclear how much the outer per-token gates add over the two-path architecture. Changing gates after training does not show that fixed or learned per-layer mixing would work worse if used throughout training. The gates also scale the input residual by their sum (Equation 5). The authors test a cap in Table 2, but it still permits token-dependent residual scaling. Controls trained from scratch would help separate these effects

Questions for authors
  1. Could the authors report total forward and training FLOPs at sequence length 4096 and check whether the gains persist at matched total compute? Allso clarify the difference between the aggregate BPB values in Figure 2 and Section 4.2.

  2. Could the authors train the same two-path model with a fixed outer mixture or learned outer per-layer gates that do not depend on the token (keeping the inner recursion router unchanged)? A control that gates only the path updates (keeping a single unchanged residual connection) would also help separate the effects of path selection and residual scaling.

  3. Could the authors compare recall and computation using similar formats and token types, such as numbers that must be recalled versus calculated? For the existing interventions, could the random controls also match the original gate values or perturbation sizes?

2 comments

Thank you for your very detailed review. We ran all the controls you proposed, see the results below.


W1/Q1a:

  • As mentioned by the reviewer the QK^T and AV are excluded from the FLOPs calculation. What our budget matches is weight-matmul FLOPs per token, which we will clearly state in the final version. Note that the excluded terms are moderat, at T=4096 Dual K=4 uses 1.27x at F80M and 1.14x at F160M.
  • We have now retrained the baselines at equal total compute: PureWide and PureLoop K=4 widened until their total FLOPs match Dual K=4, we used 3 seeds again:
ParamsC4WikiCS accGSM8KAgg. BPB
F80M PureWide927M1.0290.9330.5280.0910.865
F80M PureLoop257M1.0740.9840.4970.0580.910
F80M Dual α=25606M1.0320.9310.5280.1040.865
F160M PureWide1559M1.0160.9180.5390.1080.851
F160M PureLoop417M1.0420.9460.5180.1200.873
F160M Dual α=251125M1.0070.8970.5430.1510.837

(Agg. = mean BPB over C4, WikiText, commonsense, math; seed sd ≤ 0.003.)

  • The gains persist: at F160M, Dual beats the compute-matched PureWide on every metric with 28% fewer parameters. At F80M, PureWide is better on C4, the two are level on Wiki, commonsense and aggregate BPB, and Dual is better on math, with 35% fewer parameters.
  • PureLoop has almost the same attention compute as Dual but is the weakest model, so the extra attention FLOPs do not explain Dual's results. With FSDP on 64 GPUs, Dual also trains 1.2-1.5x faster than the compute-matched PureWide.

Q1b:

  • They are different aggregates. Fig. 2 averages all 17 per-task BPBs of single-seed runs, incl. LAMBADA and QASPER (F80M Dual α=50 K=4: 0.749, PureWide 0.757). Sec. 4.2 averages four categories (C4, WikiText, commonsense, math) over 3 seeds (0.869 vs 0.878). We will use one aggregate throughout now.

W2/Q2: We trained the variants you proposed from scratch, inner recursion router unchanged (F80M, α=50, K=4, 3 seeds):

  • (a) token-wise (as in the paper): y = g_d·h_deep + g_w·h_wide with per-token gates. Since both paths include the input x, this also scales x by g_d + g_w
  • (b) token-wise on updates (your update-only control): y = x + g_d·(h_deep − x) + g_w·(h_wide − x)
  • (c) per-layer: each layer learns one pair of weights that all tokens share
  • (d) fixed: every token gets 0.5 · deep + 0.5 · wide
GatesC4WikiCS accGSM8K
(a) token-wise (paper)1.0390.9420.5240.099
(a) + gate cap (Table 2)1.0370.9350.5230.118
(b) token-wise on updates1.0330.9300.5250.122
(c) per-layer1.0370.9360.5280.128
(d) fixed 0.5/0.51.0360.9380.5210.120

(seed sd ≤ 0.003 on C4/Wiki, up to 0.02 on GSM8K; (a) without cap: 2 of 3 seeds so far)

  • Residual scaling is not the source of the gain, it hurts: token-wise gates on the full output (a) are the weakest variant, since they rescale x by g_d + g_w (up to 2). Bounding this with the cap of Table 2 or removing it (b) fixes it, and (b) is then the best variant; we will adopt it in the final version. Thank you for suggesting this control. As Table 1 used (a), its gains are if anything conservative.
  • Fixed and per-layer mixing get close, so most of the gain comes from combining a looped and a wide path in every layer. The per-token gates are still used: changing only the ratio g_d:g_w at a fixed sum raises loss on all 15 checkpoints we tested (+0.04 to +0.32 nats).

Q3a:

  • To keep format and token type the same, we looked only at numbers and grouped them by where they come from: numbers the model computes (results after "=", ">>" or "####" in GSM8K), operands used in a calculation, numbers stated in the question, and numbers recalled from memory. We measure deep share ρ_d, 15 checkpoints, paired Wilcoxon.
  • Computed numbers go deeper than recalled ones: +0.024 vs WikiText (13 of 15 checkpoints, p=0.001) and +0.029 vs TriviaQA (11/15, p=0.007). The difference comes from the first six layers (+0.04 to +0.11); in the last six layers all numbers go deep.
  • Computed numbers also go deeper than numbers that are only stated in the question (+0.061, 13/15, p=0.003), and operands go as deep as results (p=0.45). So numbers that take part in a calculation use the deep path more.

  • We added a random control matched in gate values: each targeted token is paired with a random token with similar gates, so both get the same size of change (mean |Δg| 0.949 vs 0.946 for arithmetic, 1.087 vs 1.086 for function words).
  • Forcing arithmetic tokens through the wide path still hurts much more than the matched control: +0.41 nats on GSM8K and +0.25 on WikiText (p<0.001).
  • For function words forced deep, most of the effect disappears: +0.07 on WikiText (p=0.048), +0.03 on TriviaQA (p=0.21), −0.04 on GSM8K.

Thank you for the detailed response and additional experiments. The compute-matched baselines and additional routing controls address my concerns on W1 and Q3.

On W2/Q2: Results from the variants are particularly informative. Fixed and per-layer mixing perform comparably to per-token gating, suggesting that most of the gains come from combining the two paths rather than token-dependent routing. I would encourage the authors to reflect this distinction in the paper's main claims.

Overall, the additional experiments strengthen the paper, and I am raising my score to 3.

Reviewer_GkkMOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies the trade-off between sequential computation and parameter capacity in language models. It proposes a dual-path Transformer block that combines a shared recurrent sublayer with a separate wide-FFN sublayer through token-level gates. The models are evaluated against purely widened and purely looped controls at two stated computational budgets. The results show favorable parameter–quality trade-offs, while routing interventions reveal task- and token-class-dependent sensitivity to the two paths.

Critical strengths
  1. The paper is well motivated and the method design is clear. Combining repeated computation with dedicated parameter capacity within a single block provides a useful architectural perspective on the limitations of looped models.
  2. The conducted experiments are informative. The study explores multiple path allocations and loop counts, and Table 1 reports results across three seeds. At the lower stated budget, the balanced configuration uses 483M parameters versus 719M for PureWide while improving several reported metrics, demonstrating a useful parameter–quality trade-off.
  3. The mechanistic analyses include meaningful justification. Table 4 compares token-class interventions with size-matched random-token interventions across 18 configuration checkpoints. This provides stronger evidence of the functional relevance of routing than gate visualizations alone.
Critical weaknesses

W1. Comparability under the full computational budget requires further clarification.
The comparison strategy is reasonable. The concern is the scope of the accounting: Appendix B, Eq. (9) explicitly includes attention projections but does not account for the sequence-length-dependent QK⊤QK^\top and AVAV operations. These operations are performed once in PureWide, KK times in PureLoop, and K+1K+1 times in Dual, so their costs cannot cancel as a common overhead. The authors should clarify which operations are included, report full forward and training costs, and, where necessary, verify key comparisons under the corrected budget. The current results support the reported parameter–quality trade-off, but a strict equal-total-compute advantage remains to be established. [Appendix B, Eqs. (9)–(13)]

W2. The gate interventions do not fully isolate the benefit of token-dependent allocation.
The two gates control not only the relative weights of the deep and wide paths, but also the overall residual-stream gain through their sum. Consequently, fixing, disabling, or shuffling the gates can alter both the path mixture and the output scale. Table 7 shows that the trained model relies on its learned gating configuration, but it does not establish that the improvements specifically require token-dependent allocation rather than parallel branches or gain modulation. The gate-cap experiments in Table 2 and the random-token controls in Table 4 are useful evidence. Further controls that preserve each token’s gate sum while changing only the path ratio, together with fixed-mixture or layer-wise-mixture models trained from scratch under the same branch architecture and training recipe, would clarify the role of the gates. [Eqs. (5)–(6); Tables 2, 4, and 7]

Questions for authors
  1. Does the stated budget include sequence-length-dependent attention matrix operations? Do the key efficiency comparisons hold after accounting for the full computational cost?
  2. Does changing the path ratio while preserving each token’s residual gain produce similar loss increases? How do fixed-mixture or layer-wise-mixture models trained from scratch compare with token-level gating?
2 comments

Thank you for your careful review and your comments raised. We have now ran additional experiments to address them, see results below.


W1/Q1:

  • As the reviewer points out, QK^T and AV were excluded, and they run 1, K and K+1 times per layer in PureWide, PureLoop and Dual. What our budget matches exactly is weight-matmul FLOPs per token with every loop iteration counted, the standard parameter-FLOP accounting; we will state this and correct Eq. 9 and App. B in the final version.
  • The excluded terms are moderate: at T=4096 (causal), Dual K=4 uses 1.27x the total forward FLOPs of PureWide at F80M and 1.14x at F160M. The gap halves when the per-layer budget doubles.
  • We retrained the baselines at equal total compute: PureWide and PureLoop K=4 widened until their total FLOPs match Dual K=4, again with 3 seeds:
ParamsC4WikiCS accGSM8KAgg. BPBTrain tok/s/GPU
F80M PureWide927M1.0290.9330.5280.0910.86512.1k
F80M PureLoop257M1.0740.9840.4970.0580.91020.1k
F80M Dual α=25606M1.0320.9310.5280.1040.86514.8k
F160M PureWide1559M1.0160.9180.5390.1080.8517.4k
F160M PureLoop417M1.0420.9460.5180.1200.87314.5k
F160M Dual α=251125M1.0070.8970.5430.1510.8378.8k

(Agg. = mean BPB over C4, WikiText, commonsense, math; seed sd ≤ 0.003.)

  • The comparison still holds: at F160M, Dual beats the compute-matched PureWide on every metric with 28% fewer parameters. At F80M, PureWide is better on C4, the two are level on Wiki, commonsense and aggregate BPB, and Dual is better on math, with 35% fewer parameters.
  • PureLoop has almost the same attention compute as Dual (4 vs 5 passes) but is the weakest model, so the extra attention FLOPs do not explain Dual's results.
  • Cost: with FSDP across 64 GPUs, Dual trains 1.2-1.5x faster than the compute-matched PureWide (about half the parameters to sync). On a single GPU this flips (0.65x / 0.74x), since the loop runs sequentially.

W2/Q2: At inference, on the 15 checkpoints behind Table 4, we changed only the ratio g_d:g_w at a fixed sum, or only the sum at a fixed ratio. Loss increase in nats over the learned gates (positive on all 15 checkpoints, p<0.001):

GSM8KTriviaQAWikiText
ratio set to layer mean, sum kept+0.04+0.17+0.14
ratio shuffled, sum kept+0.10+0.32+0.24
sum shuffled, ratio kept+0.60+1.05+0.73
  • Changing only the ratio hurts on every checkpoint, so the ratio (the deep share ρ_d we analyse) carries token-specific information the model uses. The sum matters more, so the shuffled-gates row of Table 7 mostly measured gain modulation; we will say so in the final version.

We also trained the model from scratch (F80M, α=50, K=4, 3 seeds) with the following gates, while keeping paths and loop identical:

  • (a) token-wise (as in the paper): y = g_d·h_deep + g_w·h_wide with per-token gates. Since both paths include the input x, this also scales x by g_d + g_w
  • (b) token-wise on updates: the same gates, but they only scale what each path adds: y = x + g_d·(h_deep − x) + g_w·(h_wide − x)
  • (c) per-layer: each layer learns one pair of weights that all tokens share
  • (d) static: every token gets 0.5 · deep + 0.5 · wide
GatesC4WikiCS accGSM8K
(a) token-wise (paper)1.0390.9420.5240.099
(a) + gate cap (Table 2)1.0370.9350.5230.118
(b) token-wise on updates1.0330.9300.5250.122
(c) per-layer1.0370.9360.5280.128
(d) static 0.5/0.51.0360.9380.5210.120

(seed sd ≤ 0.003 on C4/Wiki, up to 0.02 on GSM8K; (a) without cap: 2 of 3 seeds so far)

  • Fixed and per-layer mixing (c, d) get close to the best variant, so most of the gain comes from having a looped and a wide path in every layer, the core claim of the paper. Thank you for suggesting these controls.
  • Gain modulation does not help, it hurts: token-wise gates on the full output (a) are the weakest variant, because they also rescale x by g_d + g_w (up to 2). Bounding this with the cap of Table 2 or removing it (b) fixes it, and (b) is then the best variant. We will adopt (b) in the final version. As Table 1 used (a), its gains over PureWide and PureLoop are conservative.

Thanks for the authors' response. The included results illustrate the detailed computational budget comparison and the impact of the gated designation. As the ratings have been postive, I would like to maintain my ratings. The supplemented results should also be included in the next revised paper version.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.