OpenMythos

OpenMythos

Disclaimer: OpenMythos è una ricostruzione teorica indipendente e guidata dalla comunità, basata esclusivamente su ricerche pubblicamente disponibili e speculazioni. Non è affiliato, supportato o collegato ad Anthropic o a nessuno dei loro sistemi proprietari.

OpenMythos è un'implementazione teorica open-source del modello Claude Mythos. Implementa un Recurrent-Depth Transformer (RDT) con tre stadi: Prelude (blocchi trasformer), un Recurrent Block in loop (fino a max_loop_iters), e una Coda finale. L'attenzione è commutabile tra MLA e GQA, e il feed-forward utilizza un MoE (Mixture-of-Experts) sparso con esperti instradati e condivisi, ideale per esplorare un ragionamento adattivo al calcolo e a profondità variabile.

Installazione

pip install open-mythos

#uv pip install open-mythos

Per abilitare Flash Attention 2 in GQAttention (richiede CUDA e strumenti di compilazione):

pip install open-mythos[flash]

Utilizzo

import torch
from open_mythos.main import OpenMythos, MythosConfig


attn_type = "mla"  # o "gqa"

base = {
    "vocab_size": 1000,
    "dim": 256,
    "n_heads": 8,
    "max_seq_len": 128,
    "max_loop_iters": 4,
    "prelude_layers": 1,
    "coda_layers": 1,
    "n_experts": 8,
    "n_shared_experts": 1,
    "n_experts_per_tok": 2,
    "expert_dim": 64,
    "lora_rank": 8,
    "attn_type": attn_type,
}

if attn_type == "gqa":
    cfg = MythosConfig(**base, n_kv_heads=2)
elif attn_type == "mla": # Usare 'elif' invece di 'else' per chiarezza e per prevenire errori se attn_type non è 'gqa' né 'mla'
    cfg = MythosConfig(
        **base,
        n_kv_heads=8,
        kv_lora_rank=32,
        q_lora_rank=64,
        qk_rope_head_dim=16,
        qk_nope_head_dim=16,
        v_head_dim=16,
    )

model = OpenMythos(cfg)
total = sum(p.numel() for p in model.parameters())
print(f"\n[{attn_type.upper()}] Parametri: {total:,}")

ids = torch.randint(0, cfg.vocab_size, (2, 16))
logits = model(ids, n_loops=4)
print(f"[{attn_type.upper()}] Forma dei logit: {logits.shape}")

out = model.generate(ids, max_new_tokens=8, n_loops=8)
print(f"[{attn_type.upper()}] Forma generata: {out.shape}")

A = model.recurrent.injection.get_A()
rho = torch.linalg.eigvals(A).abs().max().item()
print(
    f"[{attn_type.upper()}] Raggio spettrale ρ(A) = {rho:.4f} (deve essere < 1)"
)

Varianti del Modello

Scale preconfigurate da 1 miliardo a 1 trilione di parametri:

from open_mythos import (
    mythos_1b,
    mythos_3b,
    mythos_10b,
    mythos_50b,
    mythos_100b,
    mythos_500b,
    mythos_1t,
    OpenMythos,
)

cfg = mythos_7b()  # restituisce un MythosConfig
model = OpenMythos(cfg)

total = sum(p.numel() for p in model.parameters())
print(f"Parametri: {total:,}")

Addestramento

Lo script di addestramento per il modello da 3B su FineWeb-Edu si trova in training/3b_fine_web_edu.py.

Singola GPU:

python training/3b_fine_web_edu.py

Multi-GPU (rileva automaticamente il numero di GPU):

torchrun --nproc_per_node=$(python -c "import torch; print(torch.cuda.device_count())") training/3b_fine_web_edu.py

Scelte di design chiave:

Documentazione

L'Ipotesi Centrale

Si sospetta che Claude Mythos sia un Recurrent-Depth Transformer (RDT) — anche chiamato Looped Transformer (LT). Invece di impilare centinaia di strati unici, un sottoinsieme di strati viene riciclato ed eseguito più volte per ogni passata in avanti. Stessi pesi. Più loop. Pensiero più profondo.

Questo non è un chain-of-thought. Non c'è output di token intermedio. Tutto questo ragionamento avviene silenziosamente, all'interno di una singola passata in avanti, nello spazio latente continuo.

Architettura

Un transformer a loop divide i suoi strati in tre blocchi funzionali:

Input
  ↓
[Prelude P]        — strati trasformer standard, eseguiti una volta
  ↓
[Blocco Ricorrente R] — eseguito in loop T volte
  ↑_______↓         (stato nascosto h aggiornato ad ogni loop con iniezione di input e)
  ↓
[Coda C]           — strati trasformer standard, eseguiti una volta
  ↓
Output

La regola di aggiornamento del blocco ricorrente ad ogni passo del loop t:

h_{t+1} = A·h_t + B·e + Transformer(h_t, e)

Dove:

• h_t è lo stato nascosto dopo il loop t
• e è l'input codificato (dal Prelude), iniettato ad ogni loop
• A e B sono parametri di iniezione appresi
• I blocchi Transformer applicano attenzione e MLP come di consueto

L'iniezione di e ad ogni passo è ciò che impedisce al modello di divergere — mantiene vivo il segnale di input originale per tutta la profondità della ricorrenza.

L'implementazione completa è in open_mythos/main.py. Vedi il riferimento della classe OpenMythos per una descrizione dettagliata dell'API, le opzioni di configurazione e gli esempi di utilizzo.

Implementazioni dell'Attenzione

Lo strato di attenzione è commutabile tramite cfg.attn_type:

RoPE viene applicato a Q e K prima della memorizzazione in cache, quindi i valori in cache non devono essere ruotati nuovamente al recupero.

Perché questo spiega Mythos

1. Generalizzazione Sistematica

I transformer vanilla non riescono a combinare la conoscenza in modi che non hanno mai visto durante l'addestramento. I transformer a loop superano questo test. L'abilità emerge attraverso un processo di grokking in tre fasi:

1. Memorizzazione — il modello si adatta alla distribuzione di addestramento
2. Generalizzazione in-distribuzione — il modello gestisce composizioni note
3. Generalizzazione sistematica — il modello gestisce composizioni nuove OOD, bruscamente e improvvisamente

Questo è il motivo per cui Mythos si sente qualitativamente diverso dagli altri modelli su domande nuove — la capacità avviene per transizioni di fase, piuttosto che emergere gradualmente.

2. Estrapolazione della Profondità

Addestra su catene di ragionamento a 5 salti. Testa su 10 salti. Il transformer vanilla fallisce. Il transformer a loop ha successo — eseguendo più loop in fase di inferenza. Questo corrisponde direttamente all'osservazione secondo cui Mythos gestisce problemi profondamente composizionali (matematica a più passaggi, pianificazione a lungo termine, argomenti a strati) senza un chain-of-thought esplicito.

Più loop in fase di inferenza = catene di ragionamento più profonde = problemi più difficili risolti.

3. Pensieri Latenti come Chain-of-Thought Implicito

Ogni iterazione del loop è l'equivalente funzionale di un passo del chain-of-thought, ma operando nello spazio latente continuo anziché nello spazio dei token. Un modello a loop che esegue T loop simula implicitamente T passi di ragionamento CoT. Questo è stato formalmente provato (Saunshi et al., 2025).

Inoltre, i pensieri latenti continui — a differenza degli output discreti di token — possono codificare molteplici passi successivi alternativi contemporaneamente. Ciò consente qualcosa di più simile a una ricerca in ampiezza sullo spazio di ragionamento, anziché un singolo percorso di ragionamento impegnato. Il modello sta effettivamente esplorando molteplici direzioni possibili all'interno di ogni passata in avanti prima di convergere.

4. Nessuna Esplosione di Parametri

Un modello a loop con k strati eseguito L volte raggiunge la qualità di un modello non a loop con kL strati, con solo la quantità di parametri di k strati. Per le implementazioni in scala di Mythos, questo è enormemente importante:

• L'ingombro di memoria non aumenta con la profondità di ragionamento
• Il calcolo in fase di inferenza scala con il numero di loop, non con la dimensione del modello
• Questo rende il ragionamento più profondo "gratuito" in termini di parametri

Il Problema della Stabilità (e come è stato probabilmente risolto)

L'addestramento di modelli a loop è notoriamente instabile. Dominano due modalità di fallimento:

• Esplosione residua — lo stato nascosto h_t cresce illimitatamente attraverso i loop
• Picchi di perdita — l'addestramento diverge improvvisamente a causa di grandi norme spettrali nei parametri di iniezione

La Visione dei Sistemi Dinamici

Riformula il looping come un sistema dinamico discreto lineare tempo-invariante (LTI) sul flusso residuo. Ignorando il contributo del Transformer non lineare, la ricorrenza diventa:

h_{t+1} = A·h_t + B·e

Per questo sistema LTI, la stabilità è governata interamente dal raggio spettrale di A:

• ρ(A) < 1 → stabile, convergente
• ρ(A) ≥ 1 → instabile, divergente

Empiricamente, ogni esecuzione di addestramento divergente apprende ρ(A) ≥ 1. Ogni esecuzione convergente mantiene ρ(A) < 1.

La Soluzione

Vincola i parametri di iniezione in modo che la stabilità sia garantita per costruzione:

1. Parametrizza A come una matrice diagonale negativa continua
2. Discretizza usando schemi ZOH/Euler: A_discreto = exp(Δt · A_continuo)
3. Imponi la negatività tramite A := Diag(-exp(log_A)) con uno scalare appreso Δt
4. Ciò garantisce che ρ(A) < 1 sia sempre valido, indipendentemente dal tasso di apprendimento o dal rumore del batch

Il risultato: il modello a loop diventa significativamente più robusto alla selezione degli iperparametri e si addestra in modo pulito anche con tassi di apprendimento elevati. Questa è l'architettura Parcae (Prairie et al., 2026), e rappresenta la classe di soluzione più probabile che Anthropic abbia utilizzato per rendere Mythos addestrabile.

Leggi di Scaling per Modelli a Loop

Parcae stabilisce le prime leggi di scaling prevedibili per l'addestramento a loop:

• Addestramento: Per un budget FLOP fisso con parametri fissi, aumentare la ricorrenza media e ridurre il conteggio dei token produce una perdita inferiore rispetto all'addestramento con loop minimi su più dati. La ricorrenza ottimale e il conteggio ottimale dei token seguono entrambe leggi di potenza con esponenti consistenti tra le scale.
• Inferenza: Più loop in fase di test migliorano la qualità seguendo un decadimento esponenziale prevedibile e saturo — i guadagni sono reali ma decrescenti. Questo rispecchia lo scaling in fase di inferenza del chain-of-thought.

Con 770 milioni di parametri, un modello a loop raggiunge la qualità downstream di un Transformer a profondità fissa da 1,3 miliardi di parametri addestrato sugli stessi dati — circa metà dei parametri per la stessa qualità.

Applicato a Mythos: se addestrato sotto queste leggi di scaling, Mythos potrebbe essere drammaticamente più efficiente in termini di parametri di quanto sembri, con una grande frazione della sua apparente "capacità" proveniente dalla profondità del loop piuttosto che dal conteggio grezzo dei parametri.

L'Ipotesi dell'Embedding dell'Indice del Loop

Una questione aperta chiave è se il blocco a loop si comporta identicamente ad ogni iterazione, o se può imparare a fare cose diverse a diverse profondità di loop.

Senza alcun segnale posizionale attraverso i loop, gli stessi pesi devono gestire sia la corrispondenza di pattern in fase iniziale che la raffinazione in fase avanzata — una restrizione stretta. Un embedding simile a RoPE dell'indice del loop iniettato insieme all'input ad ogni passo permetterebbe agli stessi parametri di implementare operazioni funzionalmente distinte tra le iterazioni, proprio come RoPE permette alle stesse head di attenzione di comportarsi in modo diverso a diverse posizioni della sequenza.

Se Mythos usa questa tecnica, ogni loop non è una ripetizione — è una fase computazionale distinta, tutte con pesi condivisi ma che operano in regimi rappresentazionali diversi. Ciò aumenterebbe sostanzialmente l'espressività del blocco ricorrente senza aumentare il numero di parametri.

Il Problema dell'Overthinking