Junwon Lee

Study · Model anatomy

Looped transformers: depth as a runtime knob Looped Transformer: 런타임 노브가 된 깊이

A looped transformer stores a few layers once and applies them many times: a prelude embeds the input, a weight-tied core iterates, a coda decodes. Parameters stop tracking depth — and depth becomes something you choose at inference time. This page walks the verified mechanics of Huginn, Parcae, and LOTUS: how the loop is fed, why naive loops explode, how random-depth training works, and what the efficiency ledger actually says. Looped transformer는 layer 몇 개를 한 번만 저장하고 여러 번 적용한다: prelude가 입력을 embed하고, weight-tied core가 반복되고, coda가 decode한다. 파라미터 수는 더 이상 깊이를 따라가지 않는다 — 깊이는 inference 시점에 고르는 값이 된다. 이 페이지는 Huginn, Parcae, LOTUS의 검증된 메커니즘을 따라간다: loop에 입력을 어떻게 먹이는지, naive loop는 왜 폭발하는지, random-depth 학습은 어떻게 하는지, 그리고 효율 장부에 실제로 뭐가 적히는지.

Before you start. This page assumes you know what a transformer layer is — attention plus an MLP, each with its own weights — and why a decoder keeps a KV cache; attention anatomy covers both. §8 also leans on the fact that batch-1 decode is memory-bandwidth-bound (weights re-read from HBM for every token) — see the GPU memory hierarchy. 시작하기 전에. 이 페이지는 transformer layer가 무엇인지 — attention + MLP, 각자 자기 weight를 가진 — 그리고 decoder가 왜 KV cache를 유지하는지 알고 있다고 가정한다. 둘 다 attention anatomy에서 다룬다. §8은 batch-1 decode가 memory-bandwidth-bound라는 사실(모든 token마다 weight를 HBM에서 다시 읽는다)에도 기대는데, 이는 GPU memory hierarchy를 보라.
Models on this page — from the published papers and the public SandyResearch/parcae repo: 이 페이지의 모델들 — 공개 논문과 public SandyResearch/parcae repo에서 확인: Huginn 3.5B — prelude 2 / core 4 / coda 2, trained r̄ = 32 Parcae-1.3B — 8 / 8 / 8, r = 8 LOTUS 3B — K = 6 × c = 25 latents, R = 6 arXiv 2502.05171 · 2604.12946 · 2606.31779

§1 The itch: depth is welded to parameters 문제의식: 깊이가 파라미터에 용접되어 있다

In a standard transformer, the only way to be deeper is to buy more layers. Every layer carries its own weight matrices, so a 32-layer model stores — and, at batch-1 decode, re-reads from HBM for every generated token — 32 layers’ worth of bytes. Depth is decided once, at training time, and then billed forever: bytes stored, bytes shipped to every serving replica, bytes read per token. Standard transformer에서 더 깊어지는 유일한 방법은 layer를 더 사는 것이다. 모든 layer가 자기만의 weight 행렬을 가지므로, 32-layer 모델은 32개 layer 분량의 byte를 저장하고 — batch-1 decode에선 생성되는 token마다 HBM에서 다시 읽는다. 깊이는 학습 시점에 한 번 결정되고, 그 값은 영원히 청구된다: 저장하는 byte, 모든 serving replica로 전송하는 byte, token마다 읽는 byte.

There is a second, quieter problem: that frozen depth is spent identically on every token. Completing “2 + 2 =” and carrying out a hard reasoning step receive exactly the same 32 layers of computation. What we would actually like is a model whose depth is a runtime knob — a few passes for easy tokens, many for hard ones — without the parameter bill growing with the knob. That is the promise of looped transformers; the rest of this page is what it takes to make the promise real, and what it honestly costs. 더 조용한 두 번째 문제도 있다: 그 얼어붙은 깊이가 모든 token에 똑같이 지출된다. “2 + 2 =”를 완성하는 것과 어려운 reasoning 스텝을 수행하는 것이 정확히 같은 32 layer의 연산을 받는다. 우리가 실제로 원하는 것은 깊이가 런타임 노브인 모델이다 — 쉬운 token엔 몇 pass, 어려운 token엔 많이 — 노브를 돌려도 파라미터 청구서는 늘지 않으면서. 그것이 looped transformer의 약속이고, 이 페이지의 나머지는 그 약속을 실현하는 데 무엇이 필요한지, 그리고 정직하게 무엇을 지불하는지다.

standard: deeper ⇒ more parameters 8 L → 8 p 16 L → 16 p 32 L → 32 p depth chosen at training time — paid in bytes forever wanted: depth as a runtime knob small core — p′ params stored once × r — choose at inference r = 4, 8, 32, 64… — same stored bytes every time hard token → more passes · easy token → fewer

Can effective depth be decoupled from stored parameters at all? 유효 깊이를 저장 파라미터에서 떼어내는 것이 애초에 가능한가?

§2 Foundations: weight tying and fixed-point iteration 기초: weight tying과 fixed-point iteration

The escape hatch is old: weight tying. If two layers share one set of weights, the parameter count halves while the computation does not. Push it to the limit — one block applied r times — and depth becomes function composition, f(f(…f(x))): a recurrence, not through time like an RNN, but through depth. ALBERT (arXiv 1909.11942) used cross-layer sharing to shrink pretraining; the Universal Transformer (arXiv 1807.03819) made the loop explicit, applying one shared block under a dynamic halting rule, and is Turing-complete under certain assumptions. 탈출구는 오래된 것이다: weight tying. 두 layer가 weight 한 벌을 공유하면 파라미터 수는 절반이 되지만 연산은 그대로다. 극한까지 밀면 — block 하나를 r번 적용 — 깊이는 함수 합성 f(f(…f(x)))가 된다: RNN처럼 시간 방향이 아니라 깊이 방향의 recurrence다. ALBERT(arXiv 1909.11942)는 cross-layer 공유로 pretraining을 줄였고, Universal Transformer(arXiv 1807.03819)는 loop를 명시적으로 만들어 공유 block 하나를 dynamic halting 규칙 아래 반복 적용했다 — 특정 가정 하에 Turing-complete.

Iterating one map is a well-studied object: fixed-point iteration. Apply f again and again and one of two things happens. If f contracts (spectral radius of its transition below 1), the iterates converge to a fixed point x* with f(x*) = x*; if it expands, they blow up. This one dichotomy organizes most of the page: it is what gives “more loops” a meaning — each pass refines the state toward an input-conditioned answer — and it names the failure mode training must avoid. Both halves return, quantitatively, in §5. 한 map을 반복 적용하는 것은 잘 연구된 대상이다: fixed-point iteration. f를 계속 적용하면 둘 중 하나가 일어난다. f가 수축하면(transition의 spectral radius가 1 미만) iterate들은 f(x*) = x*인 fixed point x*로 수렴하고, 팽창하면 폭발한다. 이 이분법 하나가 페이지 대부분을 조직한다: “loop를 더 돈다”에 의미를 주는 것 — 매 pass가 state를 입력-조건부 답으로 다듬는다 — 이자, 학습이 피해야 할 실패 모드의 이름이기도 하다. 두 측면 모두 §5에서 정량적으로 돌아온다.

So why did looped models take until recently to become competitive language models? Because naive looping — feed the block its own output and nothing else — turns out to be the wrong recurrence. Making the loop stable, trainable, and worth its FLOPs took a handful of specific engineering decisions, and those are the next sections. 그렇다면 looped 모델이 경쟁력 있는 언어 모델이 되기까지 왜 최근까지 걸렸는가? block에 자기 출력만 되먹이는 naive looping이 잘못된 recurrence로 판명났기 때문이다. loop를 안정적이고, 학습 가능하고, FLOPs 값을 하게 만드는 데는 구체적인 엔지니어링 결정 몇 가지가 필요했고, 그것이 다음 섹션들이다.

Takeaway핵심 한 줄 Weight tying turns depth into iteration of one map, and fixed-point theory says iteration converges exactly when the map contracts — everything that follows is engineering that keeps a transformer core in the contracting regime while it does useful work. weight tying은 깊이를 한 map의 반복으로 바꾸고, fixed-point 이론은 그 반복이 map이 수축할 때 정확히 수렴한다고 말한다 — 이후의 모든 것은 transformer core가 유용한 일을 하면서도 수축 영역에 머물게 하는 엔지니어링이다.

What does a competitive looped LM actually look like, next to the standard stack it replaces? 경쟁력 있는 looped LM은 그것이 대체하는 standard stack 옆에서 실제로 어떤 모습인가?

§3 The shape: two ways to be 32 layers deep 형태: 32 layer 깊이가 되는 두 가지 방법

We want depth without buying parameters, and §2 handed us the tool — one block, applied r times. Here is the finished object: the prelude–core–coda sandwich, standing next to the standard stack it competes with. 파라미터를 사지 않고 깊이를 얻고 싶고, 도구는 §2가 건네주었다 — block 하나를 r번 적용하는 것. 여기 완성된 물건이 있다: prelude–core–coda 샌드위치가, 경쟁 상대인 standard stack 옆에 서 있다.

Left: a standard net, 32 unique layers. Right: the sandwich — prelude → weight-tied core × 8 → coda. Both apply 32 layer-transformations per token; only one stores 32 layers’ worth of weights. Hover every box. 왼쪽: standard net, unique layer 32개. 오른쪽: 샌드위치 — prelude → weight-tied core × 8 → coda. 둘 다 token마다 32번의 layer 변환을 적용하지만, 32개 layer 분량의 weight를 저장하는 쪽은 하나뿐이다. 모든 박스에 hover해 보자.

standard — 32 unique layers 18162432 32 p unique params same effective depth 32 applications / token looped — prelude → core × 8 → coda prelude P — 2 unique layers, runs once core R — weight-tied, drawn once shared layer 1 of 4shared layer 2 of 4shared layer 3 of 4shared layer 4 of 4 × 8 coda C — 2 unique layers → logits 4 p core + prelude/coda ≈ 8× fewer unique params Huginn 3.5B — 1.5B prelude+head · 1.5B core · 0.5B embed; r̄=32 → 132 apps (derived) Parcae-1.3B — 8/8/8, r=8 → 80 apps from 24 unique layers
Takeaway핵심 한 줄 Both nets apply 32 layer-transformations per token, but only the standard one stores 32 layers of weights: looping decouples stored parameters from effective depth (~8× fewer unique bytes in this worked example) while compute per token stays identical. 두 네트워크 모두 token마다 32번의 layer 변환을 적용하지만, 32개 layer 분량의 weight를 저장하는 쪽은 standard뿐이다: looping은 저장 파라미터와 유효 깊이를 분리하고(이 계산 예시에선 unique byte ~8× 감소), token당 연산량은 동일하게 유지된다.

If the core just eats its own output eight times, what stops the input from washing out of the state? core가 자기 출력을 여덟 번 되먹기만 한다면, 입력이 state에서 씻겨 나가는 것은 무엇이 막는가?

§4 Feeding the loop: how one token’s state cycles Loop에 입력 먹이기: token 하나의 state 순환

We now have the sandwich. But the coral loop arrow in §3 hides the load-bearing decision: what exactly re-enters the core at each pass? Getting this wrong is the difference between the Universal Transformer of 2018 and the looped LMs that work today. 이제 샌드위치는 손에 있다. 그러나 §3의 loop 화살표는 하중을 받치는 결정 하나를 숨기고 있다: 매 pass마다 core로 정확히 무엇이 재진입하는가? 이것을 틀리는 것이 2018년 Universal Transformer와 오늘날 작동하는 looped LM들의 차이다.

The load-bearing detail. Every serious looped LM re-injects the input at every iteration — the recurrence is si = R(e, si−1), not ht+1 = f(ht). Pick a variant to redraw the wiring, then step one token’s residual stream through the core. 하중을 받치는 디테일. 제대로 된 looped LM은 전부 입력을 매 iteration마다 재주입한다 — recurrence는 si = R(e, si−1)이지 ht+1 = f(ht)가 아니다. variant를 골라 배선을 다시 그린 뒤, token 하나의 residual stream을 core에 한 스텝씩 통과시켜 보자.

init — s₀
x — input tokens [n] prelude P runs once e = P(x) [n × h] every iteration s₀ ~ N(0, σ²·I) · σ² = 2/5 random noise init input re-injection — concat + adapter A sᵢ = R( A·[ sᵢ₋₁ ; e ] ) A: ℝ²ʰ → ℝʰ, start of the core block core R — weight-tied block 4 layers · 1.5 B params (Huginn) i = 0 / 8 same weights, pass after pass weights: stored ONCE read again each pass (no new params per loop) hᵢ loops back · × r — trained r̄ = 32 (animated: 8) coda C p = C(s_r) → logits
trace s₀s₁s₂s₃s₄s₅s₆s₇s₈ p = C(s_r)

Huginn starts the loop from random noise: s₀ ~ N(0, σ²I), σ² = 2/5 — not zeros, not the embedding. The input only ever arrives through the injection junction, and the trained model is path-independent: the loop converges toward an input-conditioned fixed point regardless of s₀.Huginn은 loop를 random noise에서 시작한다: s₀ ~ N(0, σ²I), σ² = 2/5 — zero도 embedding도 아니다. 입력은 오직 injection junction을 통해서만 들어오고, 학습된 모델은 path-independent해서 s₀가 무엇이든 입력-조건부 fixed point로 수렴한다.

The three verified injection mechanisms — concat + adapter (Huginn), decay-SSM (Parcae), additive E + h (LOTUS) — are three answers to the same question, and the public Parcae repo ships all three as selectable modules (LinearInjection, DiagonalInjection, AdditiveInjection in parcae_lm/modules/injection.py). Even the initial state is deliberate: noise, so the model learns to converge from anywhere. 검증된 세 가지 주입 메커니즘 — concat + adapter(Huginn), decay-SSM(Parcae), additive E + h(LOTUS) — 은 같은 질문에 대한 세 가지 답이고, 공개 Parcae repo는 셋 다 선택 가능한 모듈로 제공한다 (parcae_lm/modules/injection.py의 LinearInjection, DiagonalInjection, AdditiveInjection). 초기 state까지도 의도적이다: noise에서 시작해, 어디서 출발하든 수렴하도록 학습시킨다.

Takeaway핵심 한 줄 A working looped LM computes sᵢ = R(e, sᵢ₋₁), not hᵢ = f(hᵢ₋₁): the input is re-injected at every iteration and the state starts from noise — with e only at the start, “the iterative process would not be stable” (Huginn §3.1). 작동하는 looped LM은 hᵢ = f(hᵢ₋₁)이 아니라 sᵢ = R(e, sᵢ₋₁)을 계산한다: 입력이 매 iteration 재주입되고 state는 noise에서 출발한다 — e가 시작에만 주어지면 “iterative process는 불안정하다” (Huginn §3.1).

Re-injection feeds the loop — but what guarantees that 32 passes of the same block contract instead of exploding? 재주입이 loop를 먹여 살린다 — 그런데 같은 block을 32번 통과시켜도 폭발하지 않고 수축한다는 보장은 어디서 오는가?

§5 Keeping the loop stable: ρ(Ā) decides Loop 안정화: ρ(Ā)가 결정한다

Here §2’s fixed-point dichotomy becomes measurable. Iterate a map, and the spectral radius of its transition decides everything: below 1, contraction to a fixed point; at or above 1, explosion. Parcae located exactly this quantity inside trained looped LMs. §2의 fixed-point 이분법이 여기서 측정 가능한 것이 된다. map을 반복하면 transition의 spectral radius가 모든 것을 결정한다: 1 미만이면 fixed point로 수축, 1 이상이면 폭발. Parcae는 바로 이 양을 학습된 looped LM 안에서 찾아냈다.

Parcae’s diagnosis of why looped-LM training blows up: divergent runs learn a spectral radius ρ(Ā) ≥ 1 in the injection parameters; convergent runs keep ρ(Ā) < 1. Drag the slider across the boundary. looped-LM 학습이 폭발하는 이유에 대한 Parcae의 진단: 발산하는 run은 injection 파라미터에서 spectral radius ρ(Ā) ≥ 1을 학습하고, 수렴하는 run은 ρ(Ā) < 1을 유지한다. slider를 경계 너머로 움직여 보자.

ht+1 = Ā·ht + B̄·e + R̄(ht, e) Ā = exp(Δ·A), A = Diag(−exp(log_A)) → ρ(Ā) < 1 code: x·e^(−dt·A) + dt·B@e — injection.py
loop iteration t ‖state‖ (schematic) 06121824 input-conditioned fixed point h* ρ = 0.8 — two inits, one fixed point (path independence) ρ = 1.05 — residual state explosion your ρ (slider)
ρ(Ā) 0.95

ρ = 0.95: still contracting, just slowly — the state closes most of the distance to its fixed point within ~20 iterations. Parcae makes this regime structural: the diagonal decay e^(−Δ·A) is elementwise in (0, 1) by construction, so the injection transition cannot learn its way past ρ = 1.ρ = 0.95: 여전히 수축하지만 느리다 — state는 ~20 iteration 안에 fixed point까지 거리 대부분을 좁힌다. Parcae는 이 영역을 구조적으로 보장한다: 대각 decay e^(−Δ·A)가 구조상 elementwise로 (0, 1)에 있으므로, injection transition은 학습으로도 ρ = 1을 넘을 수 없다.

Precision note. The ρ(Ā) < 1 guarantee covers the injection transition Ā only — the full loop map includes the transformer term R̄(h, e), so end-to-end stability is empirical (Parcae shows it tracks ρ(Ā) in practice). Huginn’s stability comes from a different pair: input re-injection every step + noise init, with convergence to input-conditioned fixed points verified post-training. Chart curves are a schematic scalar model x ← ρx + 1, not model traces. 정밀 주석. ρ(Ā) < 1 보장은 injection transition Ā에만 해당한다 — 전체 loop map에는 transformer 항 R̄(h, e)가 포함되므로 end-to-end 안정성은 경험적이다 (Parcae는 실측에서 ρ(Ā)를 따라감을 보인다). Huginn의 안정성은 다른 조합에서 온다: 매 스텝 입력 재주입 + noise init, 그리고 학습 후 검증된 입력-조건부 fixed point로의 수렴. 차트의 곡선은 x ← ρx + 1 스칼라 모형의 개략도이지 실제 모델 trace가 아니다.

+ prelude output norm · per-sequence depth sampling (Parcae) + noise init → path independence (Huginn)
Takeaway핵심 한 줄 Divergent training runs are the ones that learned ρ(Ā) ≥ 1 in the injection parameters; Parcae’s diagonal decay Ā = exp(ΔA) keeps every entry in (0, 1) by construction, so the injection transition cannot leave the contracting regime — stability becomes structural, not lucky. 발산한 학습 run들은 injection 파라미터에서 ρ(Ā) ≥ 1을 학습해 버린 run들이다; Parcae의 대각 decay Ā = exp(ΔA)는 구조적으로 모든 성분을 (0, 1)에 가두므로, injection transition은 수축 영역을 벗어날 수 없다 — 안정성이 운이 아니라 구조가 된다.

A stable loop still has to be trained at some depth. Which r do you unroll — and can you afford backprop through all of it? 안정적인 loop라도 결국 어떤 깊이에서 학습되어야 한다. 어떤 r로 펼칠 것인가 — 그리고 그 전부를 backprop할 여력은 있는가?

§6 Training the loop: random depth, truncated gradients Loop 학습: random depth와 truncated gradient

Stability makes deep unrolling possible; training decides which depths the model will ever be good at. Bake in one r and depth stops being a knob — so the working recipe makes r itself a random variable, and keeps the backprop bill bounded. 안정성은 깊은 unrolling을 가능하게 하고, 학습은 모델이 어떤 깊이에서 잘할지를 결정한다. r 하나를 구워 넣으면 깊이는 더 이상 노브가 아니다 — 그래서 작동하는 레시피는 r 자체를 확률변수로 만들고, backprop 청구서는 유한하게 묶는다.

Three verified schemes. Depth is sampled per step so the model never overfits one loop count; gradients flow through only a suffix of the loop; and LOTUS adds dense supervision on the latent positions. 검증된 세 가지 방식. depth를 스텝마다 샘플링해 모델이 특정 loop 수에 과적합하지 않게 하고, gradient는 loop의 suffix로만 흘리며, LOTUS는 latent 위치에 dense supervision을 더한다.

6a · Depth is a random variable at train time 6a · 학습 시 depth는 확률변수다

Huginn samples r per step from a log-normal Poisson: τ ~ N(log r̄ − ½σ², σ), r ~ Poisson(e^τ) + 1, with σ = ½ and mean recurrence r̄ = 32, over 800 B tokens. Parcae samples Poisson depths per sequence (repo: poisson-truncated-full). The histogram below is that exact Huginn distribution, computed numerically. Huginn은 스텝마다 log-normal Poisson에서 r을 뽑는다: τ ~ N(log r̄ − ½σ², σ), r ~ Poisson(e^τ) + 1, σ = ½, 평균 recurrence r̄ = 32, 800 B token 학습. Parcae는 시퀀스별 Poisson depth를 샘플링한다 (repo: poisson-truncated-full). 아래 히스토그램은 Huginn의 그 분포를 수치적으로 계산한 것이다.

mean recurrence r̄ = 32 11632486480 sampled loop count r — log-normal Poisson, σ = ½ (Huginn §3.3)

6b · Truncated backprop: gradients only through the last k 6b · Truncated backprop: 마지막 k개에만 gradient

Unrolling 32+ iterations for backprop would be ruinous. Huginn backpropagates through only the last k = 8 iterations — the earlier prefix runs under no-grad. Parcae’s repo implements the same two-phase loop (no-grad prefix, with-grad suffix) with μ_bwd = ⌈μ_rec/2⌉, e.g. 8 total / 4 backprop at 140M. LOTUS, with only R = 6, backprops through all of them. 32+ iteration을 backprop용으로 전부 펼치면 비용이 파멸적이다. Huginn은 마지막 k = 8 iteration만 backprop하고, 앞쪽 prefix는 no-grad로 돌린다. Parcae repo도 같은 2-phase loop(no-grad prefix, with-grad suffix)를 구현하며 μ_bwd = ⌈μ_rec/2⌉ — 140M 기준 전체 8 / backprop 4. LOTUS는 R = 6뿐이라 전부 backprop한다.

forward: 16 iterations sampled
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 no-grad prefix — forward only gradient window — last k = 8 ∂L flows right → left, stops at the window edge torch.no_grad()

6c · LOTUS: dense latent supervision — dense across positions, at the final iteration 6c · LOTUS: dense latent supervision — 위치에 대해 dense, 마지막 iteration에서

Every latent position’s post-loop state h⁽ᴿ⁾ is decoded through the base LM head and scored against its gold CoT-step token — dense across the K × c = 150 positions, applied at iteration R (not per-iteration). Either loss alone collapses gold-step recovery to ~9% top-1; combined, 70.9% top-1 / 85.8% top-5. 모든 latent 위치의 loop 통과 후 state h⁽ᴿ⁾를 base LM head로 decode해 gold CoT-step token과 대조한다 — K × c = 150개 위치에 대해 dense하고, iteration R에서 적용된다 (iteration마다가 아니다). 두 loss 중 하나만 쓰면 gold-step 복원율이 ~9% top-1로 무너지고, 결합하면 70.9% top-1 / 85.8% top-5.

f_head — base LM head (readout) CE( f_head(hᵢⱼ⁽ᴿ⁾), Tᵢⱼ ) — gold CoT step tokens Q — question → C_pre, once BoT lat 1 × 25 lat 2 × 25 lat 3 × 25 lat 4 × 25 lat 5 × 25 lat 6 × 25 EoT A — answer ℒ_ans (CE) ℒ = ℒ_ans + λ_step · ℒ_step — full backprop through all R = 6 iterations ablation: either loss alone → ~9% gold-step top-1; combined → 70.9% top-1 / 85.8% top-5 (arXiv 2606.31779)
Takeaway핵심 한 줄 Three verified tricks — sample r per step (log-normal Poisson, r̄ = 32), backprop only through the last k = 8 iterations, and (LOTUS) supervise every latent position at the final iteration — together produce a core that behaves at any r. 검증된 세 가지 트릭 — r을 스텝마다 샘플링(log-normal Poisson, r̄ = 32), 마지막 k = 8 iteration만 backprop, 그리고 (LOTUS) 마지막 iteration에서 모든 latent 위치를 supervision — 이 셋이 합쳐져 어떤 r에서도 제대로 동작하는 core를 만든다.

Trained under random depth, the model accepts any r at inference. What does turning that knob actually buy — and when does it stop paying? random depth로 학습된 모델은 inference에서 어떤 r이든 받는다. 그 노브를 돌리면 실제로 무엇을 얻는가 — 그리고 언제부터 돈값을 못 하는가?

§7 Test-time depth: the runtime knob, and what it caches Test-time depth: 런타임 노브, 그리고 무엇이 cache되는가

This is the payoff the title promised. Because no single depth was baked in at training, r is now an inference-time choice — the interesting facts are the shape of the quality curve, and what each extra loop quietly costs. 제목이 약속한 보상이 여기다. 학습에서 특정 깊이가 구워지지 않았으므로 r은 이제 inference 시점의 선택이다 — 흥미로운 사실은 품질 곡선의 모양, 그리고 추가 loop 하나하나가 조용히 청구하는 비용이다.

Trained under random r, the model accepts any r at inference. Quality follows a saturating exponential — Parcae fits it explicitly as ℒ(T) = ℒ∞ + Z·e−zT — with task-dependent ceilings: Huginn reports HellaSwag near-saturating at ~8 recurrences while GSM8K keeps improving to r ≈ 32–64. random r로 학습된 모델은 inference에서 어떤 r이든 받는다. 품질은 포화 지수 곡선을 따르고 — Parcae는 이를 ℒ(T) = ℒ∞ + Z·e−zT로 명시적으로 피팅한다 — 천장은 task마다 다르다: Huginn 보고 기준 HellaSwag은 recurrence ~8에서 거의 포화하고 GSM8K는 r ≈ 32–64까지 계속 오른다.

test-time loop count r (log scale) task metric (schematic) 1248163264 early exit: successive-iterate KL < 5×10⁻⁴ (Huginn §6.1) recall-style — saturated reasoning-style — climbing recall-style task (HellaSwag-like ceiling ~8) reasoning-style task (GSM8K-like, climbs to 32–64)
r r = 8

r = 8: the recall-style curve has flattened — this is where per-token early exit fires — while the reasoning-style curve is still climbing. Depth bought this way is compute, not parameters: FLOPs scale linearly with r.r = 8: recall류 곡선은 평평해졌고 — 바로 여기서 per-token early exit이 발동한다 — reasoning류 곡선은 아직 오르는 중이다. 이렇게 산 깊이는 파라미터가 아니라 연산이다: FLOPs는 r에 선형으로 늘어난다.

Huginn — zero-shot KL exit MoR — learned routers Ouro — entropy-regularized depth

Because r was sampled at training time, no single depth is baked in — the model must produce something sensible at r = 4 and at r = 64. That is what turns depth into a runtime knob: quality follows a saturating exponential in r, the ceiling is task-dependent (recall saturates early, reasoning keeps climbing), and a per-token KL test tells you when a token is done thinking. Depth becomes a scheduling decision, made per token, at inference. One more consequence hides inside the loop: every extra iteration runs attention again — which is the panel below. r이 학습 시점에 샘플링되었기에 특정 깊이가 구워져 있지 않다 — 모델은 r = 4에서도 r = 64에서도 말이 되는 출력을 내야 한다. 이것이 깊이를 런타임 노브로 바꾼다: 품질은 r의 포화 지수 곡선을 따르고, 천장은 task마다 다르며(recall은 일찍 포화, reasoning은 계속 상승), token이 생각을 끝냈는지는 per-token KL 검사가 알려 준다. 깊이는 inference에서 token 단위로 내리는 스케줄링 결정이 된다. loop 안에는 결과가 하나 더 숨어 있다: 추가 iteration마다 attention이 다시 돈다 — 그것이 아래 패널이다.

7b · What the loop caches: KV along the iteration axis 7b · Loop가 cache하는 것: iteration 축의 KV

Each loop iteration runs attention again, so at generation the naive looped decoder stores KV per (iteration × core layer) — KV grows with effective depth, not unique layers. The public Parcae cache (parcae_lm/utils/cache.py, ParcaeDynamicCache) keys entries by exactly that step index; Huginn’s fix is modulo-budget sharing. loop iteration마다 attention이 다시 돌기 때문에, naive looped decoder는 생성 시 (iteration × core layer) 단위로 KV를 저장한다 — KV는 unique layer가 아니라 유효 깊이에 비례해 자란다. 공개된 Parcae cache (parcae_lm/utils/cache.py의 ParcaeDynamicCache)가 정확히 그 step index로 엔트리를 keying하고, Huginn의 해법은 modulo-budget 공유다.

iter 1 KV × core layers — its own copy iter 2 KV × core layers — its own copy iter 3 KV × core layers — its own copy iter 4 KV × core layers — its own copy iter 5 KV × core layers — its own copy iter 6 KV × core layers — its own copy iter 7 KV × core layers — its own copy iter 8 KV × core layers — its own copy total: 8 × (core KV) grows with loop count related: MoR caches KV only at the recursion level a token is routed to (§2.2.2), or reuses first-recursion KV; the public Parcae cache also ships compress-first / last / stride / anchor remaps onto earlier slots.
Takeaway핵심 한 줄 Depth is now a per-token runtime knob — task-dependent ceilings, KL-based exit (< 5×10⁻⁴) — but what it spends is compute: FLOPs grow linearly in r, and naive KV grows along the loop axis until slots are shared i mod k. 깊이는 이제 token 단위 런타임 노브다 — task별 천장, KL 기반 exit (< 5×10⁻⁴) — 하지만 지출되는 것은 연산이다: FLOPs는 r에 선형으로 늘고, naive KV는 slot을 i mod k로 공유하기 전까지 loop 축을 따라 자란다.

So which resources did looping actually make cheaper? Time to open the ledger — it has four lines, and they disagree. 그래서 looping이 실제로 싸게 만든 자원은 무엇인가? 장부를 펼 시간이다 — 네 줄이 있고, 서로 말이 다르다.

§8 The accounting: params ≠ FLOPs ≠ bytes 장부 정리: params ≠ FLOPs ≠ bytes

This is the hardest section of the page — take it slowly. The word “efficient” is doing four different jobs here: parameters, FLOPs, weight-reads, and KV bytes are separate ledgers, and looping moves each one differently. Everything before this was mechanism; this is what it costs. 이 페이지에서 가장 어려운 섹션이다 — 천천히 읽자. 여기서 “efficient”라는 단어는 네 가지 다른 일을 하고 있다: parameters, FLOPs, weight-read, KV byte는 서로 다른 장부이고, looping은 각각을 다르게 움직인다. 지금까지가 메커니즘이었다면, 여기는 그 값이다.

Worked example, all arithmetic labeled [RE]: a 4-layer core looped 8 times versus 32 unique layers at equal width. Four ledgers, four different verdicts — hover each row. 계산 예시, 산술 전부 [RE] 표기: 동일 폭에서 4-layer core × 8 loop 대 unique 32 layers. 장부 네 줄, 판정도 네 가지 — 각 행에 hover.

unique weight bytes (storage) 32L standard 32 p 4L core × 8 4 p (+prelude/coda) → ≈ 8× fewer unique bytes to store — the core IS the win FLOPs / token 32L standard 32 layer-applications 4L core × 8 4 × 8 = 32 — equal → equal — FLOPs scale with r, not with unique layers HBM weight-reads / token (batch-1 decode) 32L standard 32 layer-reads 4L core × 8 32 layer-reads — equal → equal — the core does not fit in SRAM, so it is re-read every loop KV-cache bytes / token 32L standard 32 layer-caches 4L × 8, naive 8 iters × 4 layers = 32 4L × 8, i mod 4 4 slots × 4 layers = 16 — 2×↓ → naive KV grows with loops; budgeted sharing claws it back [RE] worked example — 4L core × 8 loops vs 32L standard, equal width d; per-layer units. Core ≈ 400 MB BF16 at d = 2048 → never SRAM-resident.

Where looping paysLooping이 이득인 곳

Storage and capacity-per-byte. Looped transformers match standard ones on data-fitting tasks with under 10% of the parameters (arXiv 2311.12424). Test-time compute without more params or longer context — Huginn’s r is a free knob. KV, if you share it along the loop axis. And fewer unique bytes means cheaper communication and multi-copy serving. 저장량과 byte당 capacity. looped transformer는 data-fitting task에서 파라미터 10% 미만으로 standard와 대등하다 (arXiv 2311.12424). 파라미터도 context도 늘리지 않는 test-time compute — Huginn의 r은 공짜 노브다. loop 축으로 공유한다면 KV도 이득. unique byte가 적으니 통신과 다중 복제 serving도 싸진다.

Where it doesn’t이득이 아닌 곳

FLOPs scale with r — 32 applications is 32 applications. Batch-1 decode bandwidth: the core is re-read from HBM every loop, so at matched effective depth the weight-read floor doesn’t drop [RE]. Capacity floors bite at small scale: MoR’s 135M model underperforms vanilla. And per-task ceilings saturate — more loops stop paying (§7). FLOPs는 r에 비례 — 32번 적용은 32번 적용이다. batch-1 decode bandwidth: core를 loop마다 HBM에서 다시 읽으므로, 동일 유효 깊이에서 weight-read 바닥은 내려가지 않는다 [RE]. 작은 스케일에선 capacity 바닥이 문다: MoR 135M은 vanilla보다 못하다. 그리고 task별 천장이 포화하면 loop를 더 돌려도 득이 없다 (§7).

Published wins공개된 성과들

Parcae: “up to 6.3% lower validation perplexity over prior large-scale looped models”; at 1.3B, +2.99 CORE over a matched transformer — “up to 87.5%” the relative quality of one twice its size; the 770M ≈ a 1.3B transformer on Core. Ouro: 1.4B/2.6B models (4 loop steps, per paper/shipped config) “match the results of up to 12B SOTA LLMs” (7.7T tokens). MoR-4: up to 2.06× serving throughput. LOTUS: thought-phase 2.5–6.9× faster than explicit CoT, 2.1× total, at ~parity accuracy. Parcae: “기존 대규모 looped 모델 대비 validation perplexity 최대 6.3% 감소”; 1.3B에서 matched transformer 대비 CORE +2.99 — 2배 크기 모델의 상대 품질 “최대 87.5%”; 770M ≈ 1.3B transformer (Core 기준). Ouro: 1.4B/2.6B(기본 4 loop steps)가 “최대 12B SOTA LLM에 상응하는 결과” (7.7T tokens). MoR-4: serving throughput 최대 2.06×. LOTUS: thought-phase가 explicit CoT보다 2.5–6.9× 빠르고, 전체 2.1×, 정확도는 ~동률.

Weight tying divides unique parameter storage by ~r, and that is real: fewer bytes to hold, ship, and replicate, more capability per stored byte. But FLOPs count layer-applications, which looping does not reduce; and at batch-1 decode the core (hundreds of MB) is re-read from HBM every pass, so the weight-bandwidth floor at matched effective depth doesn’t move either [RE]. The subtlest line is KV: attention runs every iteration, so naive KV grows with r — until you share slots i mod k along the loop axis, which Huginn reports as free at budget 4. weight tying은 unique 파라미터 저장량을 ~r로 나누고, 이것은 실질적이다: 보관·전송·복제할 byte가 줄고, 저장 byte당 능력은 커진다. 그러나 FLOPs는 layer-application 수를 세고, looping은 그걸 줄이지 않는다; batch-1 decode에선 수백 MB짜리 core를 pass마다 HBM에서 다시 읽으므로 동일 유효 깊이의 weight-bandwidth 바닥도 움직이지 않는다 [RE]. 가장 미묘한 줄은 KV다: iteration마다 attention이 돌아 naive KV는 r에 비례해 자란다 — loop 축에서 slot을 i mod k로 공유하기 전까지는. Huginn은 budget 4에서 이것이 공짜라고 보고한다.

Takeaway핵심 한 줄 Params, FLOPs, weight bytes, KV bytes: four ledgers, and looping helps two — stored parameters (÷ ~r) and KV (only with loop-axis sharing). Compute and batch-1 decode weight-reads stay put at matched effective depth. params, FLOPs, weight bytes, KV bytes: 장부 네 줄 중 looping이 돕는 것은 두 줄이다 — 저장 파라미터(÷ ~r)와 KV(loop 축 공유가 있을 때만). 연산량과 batch-1 decode weight-read는 동일 유효 깊이에서 그대로다.

If the honest wins are storage, capacity-per-byte, and a brand-new KV axis — where is the field pushing next? 정직한 이득이 저장량, byte당 capacity, 그리고 완전히 새로운 KV 축이라면 — 이 분야는 다음으로 어디를 밀고 있는가?

§9 Where this goes 앞으로의 방향

The mechanics are on the table. What remains is the frontier: what the field is scaling, what it is automating, and what nobody has solved yet. 메커니즘은 테이블 위에 다 올려놓았다. 남은 것은 최전선이다: 이 분야가 무엇을 키우고 있고, 무엇을 자동화하고 있으며, 아직 아무도 풀지 못한 것은 무엇인가.

Three directions carry most of the momentum. Scale: Ouro (arXiv 2510.25741) pretrained looped LMs on 7.7T tokens, with 1.4B/2.6B models reported to match much larger SOTA LLMs — whether the advantage persists at frontier scale is open. Adaptive depth: Huginn exits zero-shot on a KL test, Mixture-of-Recursions learns per-token routers, Ouro trains an entropy-regularized halting objective — depth is turning into a serving and scheduling problem, and batching tokens that exit at different depths efficiently is largely unsolved. The loop-axis KV cache: a genuinely new structured-redundancy axis — the published record already spans full per-iteration caches, modulo-budget sharing, and recursion-wise caching — and it is an open target for cache work. 추진력 대부분은 세 방향에 실려 있다. 스케일: Ouro(arXiv 2510.25741)는 looped LM을 7.7T token으로 사전학습했고, 1.4B/2.6B 모델이 훨씬 큰 SOTA LLM에 상응한다고 보고한다 — frontier 스케일에서도 이 이점이 유지되는지는 열린 문제다. 적응형 깊이: Huginn은 KL 검사로 zero-shot exit하고, Mixture-of-Recursions는 token별 router를 학습하며, Ouro는 entropy-regularized halting 목적함수를 학습한다 — 깊이는 serving·스케줄링 문제로 변하는 중이고, 서로 다른 깊이에서 exit하는 token들을 효율적으로 batch하는 문제는 대체로 미해결이다. loop 축 KV cache: 진짜로 새로운 구조적 중복 축이다 — 공개된 기록만 해도 full per-iteration cache, modulo-budget 공유, recursion-wise caching에 걸쳐 있다 — cache 연구의 열린 표적이다.

Two edges are worth watching from this site’s reviews: LOTUS uses the loop to bridge latent and explicit chain-of-thought reasoning (review), and at the small-model end weight sharing is already shipping — MobileLLM’s block-wise layer sharing is the same trick aimed at on-device budgets (review). 이 사이트의 리뷰에서 지켜볼 만한 가장자리 둘: LOTUS는 loop로 latent reasoning과 explicit chain-of-thought 사이를 잇고 (리뷰), 소형 모델 쪽에서는 weight 공유가 이미 제품으로 나가고 있다 — MobileLLM의 block-wise layer 공유는 같은 트릭을 on-device 예산에 겨눈 것이다 (리뷰).

Why this matters for efficiency work 효율화 연구에 왜 중요한가

Looped models redraw the serving map. First, they create a new cache axis: KV per loop iteration, which is exactly the kind of structured redundancy compression lives on — the published record already spans full per-iteration caches, modulo-budget sharing, and routed recursion-wise caching. Second, they decouple the knobs: a model’s quality can now be spent or saved per token at serve time (early exit), which turns accelerator questions into scheduling questions. Third, they are honest about what weight tying cannot buy — the decode weight-read floor stays put at matched depth, so the interesting seams are where r is adaptive, batched, or amortized. That is the lens this site keeps applying: find where the bytes actually move. looped 모델은 serving 지도를 다시 그린다. 첫째, 새로운 cache 축을 만든다: loop iteration별 KV — compression이 먹고 사는 바로 그 구조적 중복이며, 공개된 기록만 해도 full per-iteration cache, modulo-budget 공유, routing 기반 recursion-wise caching까지 걸쳐 있다. 둘째, 노브를 분리한다: 모델 품질을 serve 시점에 token 단위로 쓰거나 아낄 수 있게 되면서(early exit), 가속 문제가 스케줄링 문제로 바뀐다. 셋째, weight tying이 사 줄 수 없는 것에 정직하다 — 동일 깊이에서 decode weight-read 바닥은 그대로이므로, 흥미로운 틈새는 r이 적응적이거나 batch되거나 상각되는 지점이다. 이 사이트가 계속 들이대는 렌즈가 그것이다: byte가 실제로 움직이는 곳을 찾아라.

unique params ÷ ~r — FLOPs × 1 decode weight-reads: equal at matched depth [RE] KV: per-iteration axis → i mod k sharing (free at k=4, Huginn) depth = per-token runtime knob (KL < 5×10⁻⁴)

Going deeper 더 깊이 보기

Sources: Huginn facts from arXiv 2502.05171 (structure 2/4/2, param split, s₀ noise σ² = 2/5, log-normal Poisson r̄ = 32 / σ = ½, truncated BPTT k = 8, KL early exit 5×10⁻⁴, i-mod-k KV budget with MTBench 5.86 at budget 4, HellaSwag-vs-GSM8K split, ~50B-parameter-FLOPs compute equivalence). Parcae facts from arXiv 2604.12946 and the public SandyResearch/parcae repo (model table 2/2/2@140M and 8/8/8@1.3B, injection modules, state_init, depth samplers, μ_bwd = ⌈μ_rec/2⌉, ParcaeDynamicCache, scaling-law forms and exponents, +2.99 CORE / 87.5% / 6.3% claims). LOTUS facts from arXiv 2606.31779 (official title “Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers”; K = 6, c = 25, R = 6 at 3B on GSM8k-Aug; loss design and ablation; 70.0 ± 0.9 vs 71.5 in-domain; OOD 63.9 vs 62.1; thought-phase 2.5–6.9× / total 2.1×). UT, ALBERT, looped-TF-algorithms, MoR, and Ouro as cited inline. Schematic charts (§5, §7) are labeled as such; every [RE] item is this page’s arithmetic on those published inputs, not a measured or published result. MoR’s speedup is quoted as “up to 2.06×” per its §3.3 (B=Max setting). 출처: Huginn 관련 사실은 arXiv 2502.05171 (구조 2/4/2, 파라미터 분할, s₀ noise σ² = 2/5, log-normal Poisson r̄ = 32 / σ = ½, truncated BPTT k = 8, KL early exit 5×10⁻⁴, budget 4에서 MTBench 5.86인 i-mod-k KV budget, HellaSwag-GSM8K 대비, ~50B 파라미터 FLOPs 상당의 compute). Parcae 관련 사실은 arXiv 2604.12946과 공개 SandyResearch/parcae repo (모델 표 140M 2/2/2, 1.3B 8/8/8, injection 모듈, state_init, depth sampler, μ_bwd = ⌈μ_rec/2⌉, ParcaeDynamicCache, scaling law 형태와 지수, +2.99 CORE / 87.5% / 6.3% 주장). LOTUS 관련 사실은 arXiv 2606.31779 (공식 제목 “Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers”; 3B, GSM8k-Aug에서 K = 6, c = 25, R = 6; loss 설계와 ablation; in-domain 70.0 ± 0.9 vs 71.5; OOD 63.9 vs 62.1; thought-phase 2.5–6.9× / 전체 2.1×). UT, ALBERT, looped-TF-algorithms, MoR, Ouro는 본문 인용처 그대로. 개략도 차트(§5, §7)는 그렇게 표기했고, 모든 [RE] 항목은 공개된 입력값 위에서 이 페이지가 한 산술이지 측정되거나 발표된 결과가 아니다. MoR의 speedup은 §3.3의 “최대 2.06×” (B=Max 설정)를 그대로 인용했다.