Prelude
一般 transformer blocks，先把輸入編成比較穩定的表示。這段只跑一次，產生後面 loop 會一直拿來參照的 encoded input `e`。
e = Prelude(x)1. 先抓住主骨架
README 與 `open_mythos/main.py` 一致指向同一件事：整個專案的中心不是更多層，而是同一個 recurrent block 被反覆跑很多次。
Recurrent Block
真正的假說核心。不是堆很多不同層，而是把同一組 block 重複跑 `T` 次，讓模型在單次 forward 裡做更深的 latent refinement。
h(t+1) = A*h(t) + B*e + Block(h(t), e)ACT Halting
每個位置不是一定都跑到同樣深度。若某些 token 早就收斂，可以提早停止累積更新，把運算留給更難的位置。
if cumulative_p >= threshold: haltCoda
再用一般 transformer blocks 收尾，把 recurrent loop 的結果整理成最後可投影成 logits 的表示。
logits = Head(Norm(Coda(h)))
最重要的理解：
它把「思考更深」翻譯成「同一個 block 在 hidden state 上做更多輪更新」，而不是把 chain-of-thought 直接寫出來。也就是說，推理被放在 latent space 裡發生，而不是 token 序列裡明講出來。
2. 用圖理解一次
第一張圖講整體流程，第二張圖專門處理最容易搞混的地方：MoE experts 是每一輪重新選，不是某個 expert 自己反覆多跑。
整體資料流
把它當成一條主幹加一個會反覆打磨 hidden state 的回圈。真正被反覆執行的是中間的 recurrent block。
Run once
Prelude
先把 token 表示整理成比較穩定的 encoded input e。這份 e 之後每一輪都會被注回去。
→
Loop T times
Recurrent Block
1. Loop index
先告訴共享權重：現在是第幾輪。
2. Attention + MoE
這一輪做一次完整 block 計算。
3. Stable injection
用 A*h + B*e + out 更新 hidden state。
4. ACT halting
決定哪些位置已經夠了、哪些還要再算。
如果還沒停，就帶著新的
h 進入下一輪；不是把某個 expert 單獨重跑。→
Run once
Coda + Head
把 recurrent block 打磨完的表示再收尾一次，最後投影成 logits 或下一個 token 分布。
每一輪 loop 裡，MoE 到底怎麼工作
這裡最容易誤解成「某些 experts 自己會要求再 forward 幾次」。OpenMythos 不是這樣。它是每輪 loop 都重新 routing 一次。
Router 看見目前這輪的 token hidden states
Available
Expert 1
這輪沒被選到就不跑。
Selected
Expert 7
這輪被 router 選進 top-k。
Selected
Expert 19
這輪也被選到，跑一次。
Shared
Shared experts
每輪都固定啟動。
Step A. Routing
router 根據這一輪的 hidden state，替每個 token 選出 top-k routed experts。
↓
Step B. Experts forward once
被選中的 experts 在這一輪各自計算一次，沒有哪個 expert 自己再要求額外重跑。
↓
Step C. Aggregate
把 top-k experts 的輸出依權重合併，再加上 shared experts 的輸出，形成這一輪的 FFN 結果。
↓
Step D. Next loop reroutes
如果進入下一輪，會基於更新後的 hidden state 再重新選 experts，所以第 2 輪和第 9 輪可能完全不是同一批 experts。
3. 它是怎麼從觀察跳到實作的
你可以把這個 repo 看成一條五段論證鏈：從現象猜機制，再從機制挑公開論文中的零件。
先假設現象
作者先假設 Mythos 在多步推理、組合泛化、長鏈思考上表現突出，而且這種能力像是「單次 forward 裡的隱性多步計算」。
選主模型
若要讓模型在不暴增參數的情況下增加思考深度，最直接的候選就是 Looped / Recurrent-Depth Transformer。
補可訓練性
只做 loop 會不穩，所以加進穩定注入 `A*h + B*e`、ACT、loop index 等機制，避免漂移、爆炸或每輪都長一樣。
補可部署性
若真的要做大模型，attention cache 和 FFN 計算會太重，所以再用 MLA/GQA 降 cache、用 MoE 提高參數量但保持稀疏啟動。
變成可跑模型
最後把這些拼到 `OpenMythos` 類別裡，讓它不只是敘事，而是可以 `forward`、`generate`、甚至嘗試 training script 的原型。
4. 拆開看每個零件在扮演什麼角色
左邊選模組，右邊會顯示它在理論重建裡的工作。這一區最適合拿來理解「為什麼偏偏是這幾個零件」。
RDT / Looped Transformer
這是整個專案的主心骨：同一組 block 被重複執行，讓模型在不增加獨立層數的前提下，得到更深的內部計算深度。
核心假說
專案的 README 與 class reference 都把 Mythos 的核心假設寫成 Recurrent-Depth Transformer。 它的意思不是「多輸出幾步思考文字」，而是把 hidden state 丟進同一個 block 反覆更新。如此一來，推理深度可以靠 loop 次數擴張，而參數量不需要跟著線性成長。
- Prelude 先產生 encoded input `e`。
- Recurrent block 用同一組權重重複跑 `T` 次。
- Coda 再把整理過的 hidden state 投影到輸出。
- 這讓「更多思考」被解釋成「更多 latent refinement」。
5. 一次 forward 到底發生什麼事
如果把它想成一次「安靜版 chain-of-thought」，下面這六步就是最容易記住的閱讀方式。
把 token ids 變成向量表示，準備進入 Prelude。
用標準 transformer layers 先理解輸入，凍結成之後每輪都會被注入的 `e`。
在每一輪把 loop index 編碼灌進 hidden state，讓共享權重知道自己目前是第幾輪。
跑 attention + FFN，再加 LoRA depth adapter，然後做 `A*h + B*e + transformer_out`。
ACT 對每個位置預測是否已經收斂。收斂的 token 可以停，沒收斂的繼續迭代。
最後再收尾一次，輸出 logits。整個過程都在 latent space 內部完成。
6. loop 時怎麼決定哪些 experts 被啟動
關鍵不是 expert 自己要求出場，而是每一輪 loop 都由 router 根據當下 hidden state 重新打分，選出 top-k experts。
逐步拆開看
在 `OpenMythos` 裡，expert routing 發生在 `RecurrentBlock` 裡的 `MoEFFN.forward()`。也就是說，每輪 recurrent loop 都會重新做一次 routing。
1. 先形成這一輪的輸入表示
這輪不是直接拿原始 token 去選 expert，而是先把目前 hidden state、loop index、原始輸入編碼
e 合在一起。
2. router 對每個 token 產生 expert logits
logits = self.router(flat)，shape 是 (B*T, n_experts)。這代表每個 token 都各自有一份對所有 experts 的偏好分數。
3. 用 top-k 決定誰真的被啟動
topk_idx = (logits + router_bias).topk(self.topk)。被選進 top-k 的 experts，才會在這一輪真正跑 forward。
4. 權重不是用 bias 後分數，而是原始 softmax
scores = softmax(logits)，再把被選中的 top-k 分數抓出來重正規化。也就是說，router_bias 比較像在影響「誰比較容易被挑中」，不是直接改 mixture 權重。
5. 被選中的 experts 各跑一次，再加權合併
這一輪對某 token 而言，輸出會是 top-k experts 的加權和，再加上 shared experts 的輸出。
6. 下一輪 loop 重新做一次 routing
因為 hidden state 已經更新了，所以第 2 輪與第 9 輪看到的表示不同，選到的 experts 也可能不同。
對應程式碼該怎麼讀
如果你只抓核心，讀這幾行就夠了。它直接說明了「誰被選中」和「如何加權」其實是兩個步驟。
flat = x.view(B * T, D)
logits = self.router(flat)
scores = F.softmax(logits, dim=-1)
_, topk_idx = (logits + self.router_bias).topk(self.topk, dim=-1)
topk_scores = scores.gather(-1, topk_idx)
topk_scores = topk_scores / topk_scores.sum(dim=-1, keepdim=True)
一個很重要的分界
expert 並不會自己說「我還要再 forward 三次」。真正反覆發生的是整個 recurrent block。每進入下一輪，router 才基於新的 hidden state 重新決定這輪要叫哪些 experts。
for i in range(self.topk):
expert_ids = topk_idx[:, i]
token_scores = topk_scores[:, i].unsqueeze(-1)
...
out[mask] += token_scores[mask] * self.routed_experts[eid](flat[mask])
for shared in self.shared_experts:
out = out + shared(flat)7. 參數效率不等於知識容量
這是理解 OpenMythos 很重要的一道分界。重複計算可以提升「怎麼用知識」，但不會自動增加「模型本來裝進去多少知識」。
你剛剛的質疑，其實抓到重點了
如果推論時權重不變，那 recurrent loop 比較像是在重複利用既有參數，讓同一份知識被更細地展開、重組、修正。這常常會改善多步推理、規劃、組合泛化，但不代表模型突然多知道了原本沒壓進去的事實。
高推理深度
低推理深度
Looped / recurrent model
可能把小參數的推理深度往上拉，但知識容量仍受限於原本權重。
大參數且計算也強
同時有較高知識覆蓋與較強推理，通常也是最昂貴的配置。
小而淺的模型
知識存量有限，推理深度也有限。
只加容量，不加推理
可能記得更多，但未必更會把知識做深度組合。
把 OpenMythos 拆成兩條路看
如果只看 recurrent loop，你可以把它理解成「用計算換參數」。如果再把 MoE 算進來，作者其實是在同時補兩件不同的東西。
Looping 補的是推理深度
它比較像讓模型有更多 latent steps 去重整已知資訊，而不是增加新的記憶槽位。
MoE 補的是總容量
這比較接近你說的知識壓縮問題：想裝更多領域知識，通常還是要更多參數或更大的有效容量。
所以它頂多逼近某些大模型能力
對推理型任務可能很划算，但如果瓶頸是長尾知識、事實記憶、世界模型覆蓋，looping 本身通常補不起來。
8. 哪些是相對扎實，哪些是大膽猜測
這裡是你最應該保留的判斷：它在工程上是真的，但在「是不是 Mythos 真相」這件事上仍然只是研究假說。
相對扎實的部分
這些東西在 repo 內都有明確程式碼，不是口號：
- 三段式結構：Prelude / Recurrent / Coda
- 每輪 recurrent update 的公式與實作
- ACT halting 的 early-stop 累積機制
- MLA / GQA 兩種 attention 版本
- MoE、LoRA、loop index embedding 的拼裝方式
大膽猜測的部分
這些是作者用公開研究去補的合理推測，不是官方證據：
- Anthropic 的 Mythos 真的是不是 RDT
- 穩定性問題是否真的靠這一套 injection 解法
- 是否真的用 ACT 做 token-level 可變深度
- 是不是採 MLA / DeepSeek 風格 cache 壓縮
- README 中對 Mythos 行為的部分敘述，是否真能被這個架構充分解釋
9. 你可以怎麼讀這個 repo
如果你之後要自己往下看，不用從頭到尾啃完，照這個順序最快。