BDH-CQ vs Transformer vs Mamba: memoria sinaptica, ragionamento latente e complessità computazionale
Per quasi un decennio, la self-attention ha definito il paradigma dominante dei Large Language Model. Ma l'accesso esplicito ai token precedenti, l'accumulo della KV cache e la generazione autoregressiva del ragionamento non sono necessariamente l'unico modo di costruire sistemi capaci di memoria, adattamento e inferenza.
Tre famiglie architetturali permettono di studiare il problema da prospettive differenti: i Transformer, gli State Space Model selettivi come Mamba e Dragon Hatchling (BDH), l'architettura sviluppata da Pathway. Nell'agosto 2026, il lavoro BDH-CQ ha introdotto un'ulteriore dimensione: l'apprendimento in contesto tramite memoria ricorrente combinato con ragionamento iterativo in uno spazio latente continuo.
L'obiettivo di questo approfondimento non è decretare la fine dei Transformer, ma analizzare quali informazioni ciascuna architettura conserva, come le aggiorna, quanto costa recuperarle e quali capacità sono realmente supportate dalle evidenze sperimentali.
1. Tre diverse nozioni di memoria
La prima distinzione importante riguarda il significato di memoria durante l'inferenza. I pesi appresi durante il training non coincidono con lo stato contestuale costruito a runtime.
Un modello può avere miliardi di parametri permanenti e, allo stesso tempo, possedere una memoria contestuale limitata. Viceversa, può aggiornare uno stato temporaneo durante l'elaborazione senza modificare alcun parametro addestrabile.
| Proprietà | Transformer | Mamba | BDH / BDH-CQ |
|---|---|---|---|
| Meccanismo principale | Self-attention | Selective State Space | Memoria associativa e dinamiche ricorrenti |
| Storia del contesto | KV cache indicizzata per token | Stato ricorrente compresso | Stato associativo o sinaptico |
| Aggiornamento | Aggiunta di nuove K/V | Transizione dipendente dall'input | Associazioni locali e aggiornamenti ricorrenti |
| Recupero | Attention sui token | Lettura dallo stato dinamico | Lettura associativa dallo stato |
| Ragionamento interno iterativo | Non intrinseco al blocco standard | Non intrinseco al blocco standard | Esplicito in BDH-CQ |
| Memoria persistente fra richieste | Richiede gestione esterna | Richiede gestione dello stato | Dipende dall'implementazione e dal ciclo di vita dello stato |
Attenzione a una semplificazione frequente: possedere uno stato ricorrente a dimensione fissa non significa ricordare indefinitamente ogni informazione. La quantità di memoria occupata può essere indipendente dalla lunghezza della sequenza, ma la capacità informativa rimane finita.
2. Transformer: accesso esplicito contro costo della storia
2.1 Scaled dot-product attention
Per una sequenza di lunghezza L e dimensione del modello d, la self-attention proietta gli embedding nelle rappresentazioni Query, Key e Value:
M rappresenta la maschera causale, mentre d_k è la dimensione delle query e delle key per testa.
Ogni posizione può recuperare informazioni dalle posizioni precedenti attraverso una distribuzione normalizzata. L'attenzione esplicita conserva una caratteristica importante: la possibilità di distinguere e indirizzare i singoli token presenti nella cache, entro i limiti dell'encoding e della precisione numerica.
2.2 Complessità del prefill
La matrice QKᵀ contiene L² elementi per testa. Ignorando costanti e proiezioni, la complessità dell'attenzione densa è:
H è il numero di teste e d_kv la larghezza complessiva delle Key/Value conservate per livello. Quest'ultima dipende anche dall'eventuale Multi-Query o Grouped-Query Attention.
FlashAttention riduce drasticamente il traffico di memoria e non richiede di materializzare globalmente la matrice quadratica, ma non elimina la dipendenza quadratica dei calcoli della full attention densa.
2.3 Quanto pesa una KV cache?
Consideriamo un esempio teorico con 32 livelli, 8 teste KV, head dimension 128 e precisione BF16.
Il risultato riguarda soltanto la KV cache di una singola sequenza. Non comprende pesi, workspace, allocator overhead e altre strutture runtime.
Per questa ragione il costo di memoria del contesto lungo è un problema architetturale, non semplicemente una questione di velocità della GPU.
3. Mamba: sostituire il recupero esplicito con uno stato selettivo
Mamba nasce dalla famiglia degli Structured State Space Models. Il passaggio decisivo rispetto ai precedenti SSM è rendere selettive alcune componenti della dinamica in funzione dell'input.
3.1 Dall'SSM continuo alla ricorrenza discreta
Un sistema lineare continuo può essere descritto dalle equazioni:
Applicando una discretizzazione, per esempio con un intervallo Δ, si ottiene:
Nella discretizzazione zero-order hold:
Quando A è invertibile, l'ultima relazione può essere scritta come A⁻¹(Ā-I)B, ma la forma integrale è più generale e numericamente preferibile in alcuni casi.
3.2 La selettività
Mamba rende dipendenti dall'input alcune grandezze, in particolare B, C e il passo di discretizzazione Δ:
Questa modifica consente alla dinamica di trattenere o attenuare informazioni in funzione del token corrente. La selezione non è però una memoria simbolica perfetta: dipende dalla capacità dello stato, dalle transizioni apprese e dalla precisione numerica.
3.3 Selective scan e parallelizzazione
Le transizioni ricorrenti impediscono di calcolare ogni stato indipendentemente, ma possiedono una struttura algebrica utile.
Per una ricorrenza affine:
si può rappresentare ogni passo come una coppia (A_t,b_t). La composizione di due passi è:
L'operazione è associativa: permette algoritmi di parallel prefix scan. Mamba sfrutta strutture di questo tipo con kernel hardware-aware, evitando di trasferire continuamente tutto lo stato ricorrente nella memoria globale della GPU.
Il lavoro totale dello scan è lineare nella lunghezza della sequenza, a dimensioni di stato fissate. Il percorso critico può essere ridotto attraverso il parallelismo, mentre l'efficienza reale dipende dai kernel e dall'hardware.
3.4 Cosa Mamba non risolve automaticamente
Uno stato ricorrente a dimensione fissa è una rappresentazione compressa della storia. Se informazioni differenti devono essere preservate simultaneamente, possono verificarsi interferenza, cancellazione e perdita di dettagli.
La linearità del costo rispetto a L non implica capacità illimitata di recupero associativo, né garantisce che Mamba superi un Transformer su ogni benchmark di ragionamento.
4. BDH: un'architettura basata su interazioni locali
Il paper originale The Dragon Hatchling: The Missing Link between the Transformer and Models of the Brain, pubblicato nel settembre 2025, propone una famiglia di reti ispirata a dinamiche neuronali locali e all'aggiornamento dello stato associato alle connessioni.
Il modello teorico descrive sistemi a grafo con variabili sui nodi e sugli archi. La sua formulazione GPU-friendly, BDH-GPU, utilizza invece operazioni tensoriali dense, proiezioni low-rank, attivazioni ReLU e attenzione lineare.
4.1 Non simulare il cervello, ma reinterpretare il calcolo
BDH non è una simulazione biologicamente completa del cervello. Il riferimento alla neuroscienza introduce alcuni principi: località delle interazioni, attività sparse, memoria associativa e adattamento dello stato.
Nella formulazione a grafo, un insieme di n neuroni interagisce attraverso connessioni i cui pesi possono essere modificati dalla dinamica locale.
Queste ultime equazioni rappresentano lo schema concettuale di una dinamica neuronale locale; non sono una trascrizione letterale delle regole complete BDH del paper.
4.2 Hebbian learning
L'intuizione classica dell'apprendimento hebbiano è che l'attivazione congiunta di due unità rafforzi la loro associazione.
η è il learning rate della plasticità locale. Nella forma più semplice, la regola è correlazionale e non richiede un gradiente globale propagato attraverso tutta la rete.
Tuttavia, l'aggiornamento additivo puro può produrre crescita illimitata dei pesi. Un modello operativo richiede normalizzazione, decadimento, competizione, gating o altre forme di stabilizzazione.
Questo è un modello didattico con decadimento, non la specifica esatta della plasticità BDH.
4.3 Fast weights e memoria associativa
Una memoria key-value può essere rappresentata attraverso una matrice costruita mediante prodotti esterni.
Sostituendo la definizione dello stato:
Il risultato è una somma di valori pesati dalla similarità fra la query e le key precedenti. Qui compare il collegamento matematico con la linear attention.
L'apprendimento hebbiano e le fast weights sono concetti correlati ma non identici. Nella forma key-value, le due rappresentazioni possono anche avere dimensioni differenti; non occorre una matrice sinaptica simmetrica.
5. Linear attention e memoria sinaptica
5.1 Dalla somma sui token allo stato ricorrente
Per una funzione di feature φ e query/key trasformate, una forma causale di linear attention normalizzata è:
Quando l'architettura richiede causalità stretta con esclusione del token corrente, la lettura avviene usando S_(t-1), prima dell'aggiornamento.
La normalizzazione del denominatore è comune nelle formulazioni kernelizzate, ma non è obbligatoria. Il BDH pubblico utilizza una forma non normalizzata della somma associativa.
Il vantaggio è evidente: non occorre conservare ogni coppia key-value individuale per effettuare il retrieval. È possibile leggere la memoria da uno stato aggregato.
5.2 Complessità della memoria associativa
Con dimensione feature n e larghezza value d_v, la matrice S ha n × d_v elementi:
A dimensioni fisse, la dipendenza temporale è lineare. Ma se n è molto grande, il costo assoluto dello stato e delle proiezioni può essere considerevole.
Uno stato ricorrente di dimensione costante rispetto a L non è necessariamente piccolo rispetto alla memoria disponibile sulla GPU.
5.3 Interferenza fra associazioni
Consideriamo due key non ortogonali:
Il secondo termine rappresenta la contaminazione dell'associazione desiderata. Questa interferenza aumenta quando molte key condividono direzioni simili nello spazio delle feature.
La capacità del sistema dipende quindi da dimensionalità, sparsità, separabilità delle rappresentazioni e regole di aggiornamento. Non basta aumentare indefinitamente la lunghezza della sequenza.
6. Il dettaglio che cambia l'interpretazione del repository Pathway
Nel repository pubblico pathwaycom/bdh,
il file bdh.py contiene un'implementazione
di attention che costruisce esplicitamente la matrice
dei punteggi.
# Estratto essenziale da bdh.py
# Pathway: implementazione pubblica BDH
def forward(self, Q, K, V):
assert K is Q
_, _, T, _ = Q.size()
r_phases = (
torch.arange(
0, T,
device=self.freqs.device,
dtype=self.freqs.dtype
).view(1, 1, -1, 1)
) * self.freqs
QR = self.rope(r_phases, Q)
KR = QR
scores = (QR @ KR.mT).tril(diagonal=-1)
return scores @ VQuesta implementazione possiede tre caratteristiche tecnicamente importanti.
-
La moltiplicazione
QR @ KR.mTcostruisce punteggi con dimensione temporale T × T. -
tril(diagonal=-1)elimina i contributi dei token correnti e futuri. - Non viene applicata softmax: gli elementi mascherati sono zero e il risultato è una somma associativa non normalizzata.
6.1 La formulazione ricorrente equivalente
Dopo aver applicato il positional encoding rotatorio, indichiamo query e key con q_t e k_t. Nel caso pubblico sono la stessa rappresentazione:
Questa ricorrenza riproduce la strict causal linear attention non normalizzata, a parte le differenze di arrotondamento floating-point dovute all'ordine delle operazioni.
La trasformazione è algebricamente esatta in aritmetica reale e non richiede retraining per essere studiata. Per ottenere un'accelerazione pratica, tuttavia, occorrono kernel scan efficienti: un semplice ciclo Python potrebbe risultare più lento della versione quadratica su sequenze moderate.
7. Laboratorio Python 1 — eseguire il repository BDH originale
Il primo laboratorio utilizza direttamente i file ufficiali di Pathway, senza dipendenze aggiuntive rispetto a quelle del progetto.
git clone https://github.com/pathwaycom/bdh.git
cd bdh
python -m venv .venv
# Windows
.venv\Scripts\activate
# Linux / macOS
# source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -r requirements.txt
python train.pyLo script originale scarica Tiny Shakespeare, utilizza un dataset byte-level, esegue training autoregressivo e genera un breve campione di testo.
La configurazione standard definita in bdh.py
include sei iterazioni del blocco, embedding di 256,
quattro teste e un grande spazio interno di feature.
Nel training script la sequenza predefinita ha
lunghezza 512 e il batch size è 32.
La demo applica ripetutamente gli stessi moduli all'interno del proprio ciclo di livelli. Questo weight sharing va distinto da una generica pila di Transformer con pesi indipendenti.
Per un primo smoke test, invece di addestrare subito, possiamo costruire un modello più piccolo.
# smoke_test.py
import torch
from bdh import BDH, BDHConfig
torch.manual_seed(42)
cfg = BDHConfig(
n_layer=2,
n_embd=64,
n_head=4,
mlp_internal_dim_multiplier=8,
vocab_size=256,
dropout=0.0,
)
model = BDH(cfg).eval()
x = torch.randint(
0, cfg.vocab_size,
(2, 32),
dtype=torch.long,
)
with torch.no_grad():
logits, loss = model(x, x)
print("Logits:", logits.shape)
print("Loss:", float(loss))
print(
"Parameters:",
sum(p.numel() for p in model.parameters())
)
assert logits.shape == (2, 32, 256)
assert torch.isfinite(loss)Il test verifica il contratto tensoriale, la produzione di logits e la finitezza della loss. Non dimostra capacità di ragionamento né replica i benchmark riportati da Pathway.
8. Laboratorio Python 2 — attention quadratica contro memoria ricorrente
Questo esperimento riproduce l'operatore matematico di attenzione strettamente causale non normalizzata utilizzato nel repository, isolando il problema dalla restante architettura.
# causal_memory_equivalence.py
import torch
torch.manual_seed(7)
B = 2
H = 2
T = 32
N = 16
D = 8
q = torch.randn(B, H, T, N)
v = torch.randn(B, H, T, D)
# Reference: T x T attention.
scores = q @ q.transpose(-1, -2)
scores = scores.tril(diagonal=-1)
reference = scores @ v.unsqueeze(1)
# Recurrent associative memory.
state = torch.zeros(B, H, N, D)
outputs = []
for t in range(T):
qt = q[:, :, t, :]
vt = v[:, :, t, :].expand(-1, H, -1)
# Read before writing:
# strict causality excludes current token.
yt = torch.einsum(
"bhn,bhnd->bhd",
qt,
state
)
outputs.append(yt)
state = state + torch.einsum(
"bhn,bhd->bhnd",
qt,
vt
)
recurrent = torch.stack(outputs, dim=2)
max_error = (
reference - recurrent
).abs().max().item()
print("Reference:", reference.shape)
print("Recurrent:", recurrent.shape)
print("Max error:", max_error)
torch.testing.assert_close(
reference,
recurrent,
rtol=1e-4,
atol=1e-4,
)
Per il modello ufficiale occorre applicare prima la
stessa trasformazione RoPE utilizzata in Attention.
L'esempio lavora su query già trasformate e verifica
soltanto l'equivalenza del nucleo associativo.
8.1 Perché l'ordine lettura/scrittura è essenziale
Nel codice originale la diagonale della matrice dei punteggi viene azzerata. Pertanto il token alla posizione t non può contribuire alla propria uscita attention.
Spostare la scrittura dello stato prima della lettura cambierebbe l'operatore matematico e introdurrebbe un contributo corrente non previsto dalla demo.
8.2 Costi teorici dell'esperimento
La versione ricorrente richiede meno memoria temporale asintotica, ma il loop Python è seriale e non sfrutta automaticamente una GPU quanto un kernel ottimizzato.
Un confronto serio deve distinguere FLOPs teorici, memoria allocata, bandwidth, occupazione GPU, launch overhead e latenza reale.
9. Laboratorio Python 3 — misurare la sparsità delle attivazioni BDH
Un elemento centrale della formulazione BDH-GPU è la proiezione in uno spazio interno di feature, seguita da una ReLU che produce attivazioni non negative.
Possiamo osservare direttamente la sparsità nel modello pubblico, senza attribuire automaticamente alle singole feature una semantica interpretabile.
# activation_probe.py
import torch
import torch.nn.functional as F
from bdh import BDH, BDHConfig
torch.manual_seed(1337)
cfg = BDHConfig(
n_layer=2,
n_embd=64,
n_head=4,
mlp_internal_dim_multiplier=8,
vocab_size=256,
dropout=0.0,
)
model = BDH(cfg).eval()
idx = torch.randint(0, 256, (1, 64))
with torch.no_grad():
x = model.embed(idx).unsqueeze(1)
x = model.ln(x)
latent = x @ model.encoder
sparse = F.relu(latent)
nonzero_fraction = (
(sparse > 0).float().mean().item()
)
active_per_token = (
(sparse > 0)
.sum(dim=-1)
.float()
.mean()
.item()
)
print("Latent shape:", tuple(latent.shape))
print("Active fraction:", nonzero_fraction)
print("Mean active features:", active_per_token)
print("Min:", sparse.min().item())
print("Max:", sparse.max().item())L'esperimento misura la frazione di componenti positive e il numero medio di feature attive per token e testa.
Una rete appena inizializzata non è un test significativo di monosemanticità. Per studiare quest'ultima occorrono modelli addestrati, dataset di probe, identificazione di feature, esperimenti di attivazione e controlli causali.
L'attivazione sparsa può favorire la separazione di rappresentazioni, ma non dimostra da sola che una feature rappresenti un singolo concetto.
10. BDH-CQ: separare apprendimento contestuale e ragionamento
Il lavoro BDH-CQ introduce un'interfaccia concettuale con due stati distinti: la memoria delle dimostrazioni e il workspace latente utilizzato per risolvere la query.
10.1 Le equazioni ufficiali
Le dimostrazioni vengono elaborate tramite la seguente regola astratta:
Dopo aver acquisito K dimostrazioni, il modello inizializza il workspace della query:
Il ragionamento procede attraverso R iterazioni:
Infine:
Queste sono le relazioni pubblicate nel paper BDH-CQ. Le funzioni U, E, F e G sono indicate in forma astratta: le loro definizioni implementative complete, le dimensioni degli stati e le regole di aggiornamento rimangono proprietarie.
10.2 Perché S e H non sono la stessa cosa
S contiene informazioni contestuali costruite attraverso le dimostrazioni. H rappresenta invece il processo computazionale necessario a produrre una soluzione alla query corrente.
Separare questi ruoli permette di formulare una distinzione architetturale:
- Imparare dal contesto significa aggiornare S.
- Ragionare sulla query significa trasformare H.
- Aumentare il ragionamento significa eseguire ulteriori passaggi di F.
- Produrre una risposta significa decodificare H, senza obbligare ogni stato intermedio a diventare testo.
Il modello non aggiorna i suoi parametri θ durante l'inferenza riportata nel paper. Pertanto il termine in-context learning non deve essere confuso con fine-tuning online o modifica permanente dei pesi.
11. Recurrent latent reasoning contro Chain-of-Thought
11.1 Il vincolo della verbalizzazione
Nella chain-of-thought autoregressiva, ogni passaggio di ragionamento verbalizzato attraversa il vocabolario, viene selezionato come token e diventa parte del contesto successivo.
Questa struttura permette una traccia leggibile, ma introduce il costo della generazione sequenziale di token intermedi.
Nel ragionamento latente ricorrente, invece:
Il passaggio intermedio non richiede necessariamente tokenizzazione o campionamento.
11.2 Eliminare i token intermedi non significa eliminare il costo
Se ogni iterazione latente costa C_F e vengono eseguite R iterazioni, il costo aggiuntivo sarà proporzionale a R × C_F.
Le due quantità non sono direttamente confrontabili senza conoscere la struttura e la dimensione di F, la larghezza del workspace, l'hardware e l'eventuale riuso dei pesi.
Il ragionamento latente può evitare la serializzazione linguistica, ma può comunque richiedere molti FLOPs. Inoltre, l'assenza di una traccia testuale intermedia riduce la possibilità di ispezionare il percorso computazionale attraverso una spiegazione verbale.
11.3 Stabilità della ricorrenza
Per una dinamica H_(r+1)=F(H_r,S), lo studio del Jacobiano rispetto a H è fondamentale:
Se localmente la norma o il raggio spettrale della dinamica favoriscono la contrazione, le iterazioni possono convergere verso un attrattore. Se prevale l'espansione, possono amplificarsi perturbazioni o instabilità.
Conseguentemente, più iterazioni non garantiscono sempre risposte migliori. Il rapporto tra profondità ricorrente, stabilità e accuratezza deve essere misurato sperimentalmente.
12. Laboratorio Python 4 — memoria hebbiana e interferenza
Il laboratorio successivo implementa una semplice memoria associativa con decadimento. È un modello didattico separato dal codice proprietario BDH-CQ.
# hebbian_memory.py
import torch
class HebbianMemory:
def __init__(
self,
key_dim: int,
value_dim: int,
decay: float = 0.99
):
self.decay = decay
self.state = torch.zeros(
key_dim, value_dim
)
@torch.no_grad()
def write(self, key, value):
self.state.mul_(self.decay)
self.state.add_(torch.outer(key, value))
@torch.no_grad()
def read(self, query):
return query @ self.state
torch.manual_seed(42)
dim = 64
memory = HebbianMemory(
key_dim=dim,
value_dim=dim,
decay=0.99
)
keys = torch.eye(dim)
values = torch.randn(dim, dim)
for i in range(32):
memory.write(keys[i], values[i])
# Orthogonal keys eliminate cross-talk
# in this controlled example.
predicted = memory.read(keys[31])
target = values[31]
print("Last-item error:",
(predicted - target).norm().item())
# An older association has decayed.
older = memory.read(keys[0])
print("Older-item norm:",
older.norm().item())
print("Target norm:",
values[0].norm().item())Con key ortogonali, l'interferenza fra le 32 associazioni è assente in aritmetica esatta. Il decadimento attenua progressivamente le informazioni più vecchie.
Sostituendo le key ortogonali con vettori correlati, diventa possibile misurare il cross-talk e la perdita di accuratezza al crescere del numero di associazioni.
Questa è la vera domanda ingegneristica per la memoria sinaptica: non soltanto quanto spazio occupi, ma quante associazioni possa conservare con un errore di retrieval accettabile.
13. Laboratorio Python 5 — un solver ricorrente nello spazio latente
Per isolare il concetto di latent reasoning, possiamo costruire un sistema iterativo con pesi fissi, che utilizza uno stato latente per approssimare la soluzione di un sistema lineare.
L'esperimento non riproduce BDH-CQ; serve a visualizzare come un calcolo possa avanzare attraverso iterazioni interne senza emettere token testuali.
# recurrent_latent_solver.py
import torch
torch.manual_seed(42)
n = 16
A = torch.randn(n, n)
A = A.T @ A + 2.0 * torch.eye(n)
b = torch.randn(n)
# Exact solution for comparison only.
target = torch.linalg.solve(A, b)
# Fixed iterative transition:
# H_(r+1) = H_r + alpha * (b - A H_r)
eigmax = torch.linalg.eigvalsh(A).max()
alpha = 1.0 / eigmax
h = torch.zeros(n)
for step in range(101):
error = torch.norm(h - target).item()
if step % 10 == 0:
print(
f"Iteration {step:3d} "
f"error={error:.8f}"
)
residual = b - A @ h
h = h + alpha * residual
print("Final residual:",
torch.norm(A @ h - b).item())Questo è un metodo di Richardson precondizionato soltanto da uno scalare, per una matrice simmetrica definita positiva.
La transizione latente viene ripetuta senza generare testo. Lo stato H contiene una soluzione progressiva, mentre il numero di iterazioni determina quanta computazione viene allocata al problema.
La convergenza è qui spiegabile matematicamente. In una rete neuronale appresa, il corrispondente studio richiede misure del Jacobiano, analisi degli attrattori, test fuori distribuzione e valutazioni della stabilità numerica.
14. Complessità computazionale: confronto formale
Per confrontare le architetture bisogna fissare la dimensione del modello, il numero di livelli, la dimensione dello stato e il regime operativo. Dire soltanto che un modello è "lineare" è insufficiente.
Introduciamo L come lunghezza della sequenza, d come dimensione rappresentativa, n come dimensione delle feature associative, N come dimensione di stato SSM e R come numero di iterazioni di ragionamento.
| Operazione | Transformer denso | Mamba selettivo | BDH ricorrente ideale |
|---|---|---|---|
| Mixing sequenziale | O(L²d) | O(LdN) per lo stato, a fattori architetturali fissati | O(Lnd_v) |
| Stato durante decoding | O(Ld_kv) per livello | O(dN) circa, più stato convoluzionale | O(nd_v) |
| Costo di lettura per token | O(Ld_kv) | O(dN) circa | O(nd_v) |
| Dipendenza dalla storia | Esplicita | Compressa | Associativa compressa |
| Ragionamento iterativo | Token o ulteriori passaggi di rete | Richiede un solver aggiunto | BDH-CQ: R passaggi latenti |
Queste espressioni confrontano i principali operatori di sequence mixing, non il costo completo dei modelli. Proiezioni, normalizzazioni, MLP, convoluzioni, embedding e output head possono introdurre termini importanti.
Per BDH-CQ il costo totale non può essere determinato con precisione dalle informazioni pubbliche: le dimensioni e le regole esatte del ragionamento latente non sono disponibili.
14.1 Il confronto nello spazio contro il tempo
Una matrice associativa può mantenere la stessa occupazione di memoria indipendentemente da L. Ma questa caratteristica non equivale a dire che il modello possa conservare arbitrariamente molti dettagli senza perdita.
I Transformer pagano memoria per mantenere gli elementi individuali del contesto; i sistemi ricorrenti pagano attraverso compressione, interferenza e limiti di capacità dello stato.
La scelta architetturale è quindi un compromesso tra accesso esplicito, capacità informativa, latenza, parallelismo e costo della memoria.
15. Risultati sperimentali BDH-CQ: cosa è stato realmente misurato
Il paper BDH-CQ valuta un sistema da 150 milioni di parametri sul set pubblico ARC-AGI-1, composto da 400 task.
| Metrica | Risultato pubblicato |
|---|---|
| Parametri | 150 milioni |
| ARC-AGI-1 public evaluation | 400 task |
| Pass@1 | 24,25% (97/400) |
| Pass@2 | 29,50% (118/400) |
| Intervallo Wilson 95%, pass@2 | 25,24–34,15% |
| Tempo hardware default | Circa 0,85 H200 GPU-second/task |
| Costo calcolato | Circa 0,00070 USD/task |
Il costo è una stima basata sul tempo GPU e su una tariffa ipotizzata di 3 USD per ora H200. Non è un prezzo API pubblico né un confronto normalizzato del total cost of ownership.
Il lavoro riporta anche un audit black-box indipendente del sistema distribuito, senza accesso ai pesi del modello. Questa verifica è diversa dalla riproduzione completa del training a partire da codice e dataset.
15.1 Reasoning effort
Il paper confronta inoltre differenti quantità di ragionamento latente.
| Effort | ARC pass@2 | Riduzione costo riportata |
|---|---|---|
| LOW | 21% | 22% |
| MEDIUM | 27% | 11% |
| HIGH | 29,5% | 0% |
Questi dati evidenziano un tradeoff fra calcolo iterativo e accuratezza nel sistema specifico. Non dimostrano che incrementare indefinitamente R migliori sempre le prestazioni.
15.2 I limiti: composizione, copia e ordinamento
La valutazione ConceptARC mostra forti differenze fra famiglie di operazioni.
Nella variante con identificatori opachi, le categorie FilledNotFilled, TopBottom2D ed ExtendToBoundary raggiungono 9 task corretti su 10 in pass@2. Copy e Order si fermano a 2 task su 10.
Il numero di task per famiglia è piccolo e le stime sono incerte. Tuttavia, il risultato evidenzia una questione sostanziale: riconoscere alcune trasformazioni locali non significa saper eseguire composizioni, ordinamenti e manipolazioni strutturate di complessità arbitraria.
La distinzione tra accuratezza sul singolo test e accuratezza completa sul task è altrettanto importante. Risolvere alcune istanze non prova l'applicazione sistematica della regola inferita.
16. Un protocollo di benchmarking riproducibile
Un confronto credibile fra Transformer, Mamba e BDH dovrebbe prevedere almeno quattro classi di esperimenti: memoria, recupero associativo, ragionamento e prestazioni hardware.
16.1 Memoria e recupero
- Needle-in-a-haystack con distrattori controllati.
- Associative recall con key correlate.
- Overwrite e cancellazione di informazioni obsolete.
- Generalizzazione oltre la lunghezza del training.
- Misura di accuratezza in funzione della distanza temporale.
16.2 Ragionamento
- Composizione di operatori in profondità crescente.
- Sorting e permutation composition.
- Constraint satisfaction con difficoltà graduata.
- Trasformazioni ARC-like generate dopo il congelamento del modello.
- Separazione fra apprendimento della regola ed esecuzione ripetuta.
16.3 Prestazioni
- Prefill throughput in token/s.
- Decode throughput e latenza per token.
- Peak allocated e peak reserved GPU memory.
- Tempo per kernel e traffico memoria.
- Accuratezza a budget di calcolo fissato.
- Energia per task corretto, ove misurabile.
Tutti i benchmark devono fissare hardware, precisione, seed, batch size, lunghezza del contesto, kernel, warmup e configurazione del modello.
È inoltre necessario distinguere throughput dal tempo di risposta di una singola query. Un algoritmo può avere meno FLOPs ma una latenza maggiore se il parallelismo o l'implementazione hardware sono sfavorevoli.
17. Criticità scientifiche ancora aperte
17.1 Capacità della memoria sinaptica
La memoria associativa compatta presenta inevitabili problemi di interferenza e capacità. Occorre quantificare come l'errore di recupero dipenda dalla dimensione delle feature, dalla distribuzione delle key, dal numero di associazioni e dal tempo.
17.2 Continual learning e catastrophic forgetting
Aggiornare uno stato durante l'inferenza è diverso dal modificare stabilmente la conoscenza parametrica. Un sistema capace di lifelong learning dovrebbe dimostrare adattamento persistente, conservazione delle competenze e resistenza al forgetting in sequenze di task differenti.
17.3 Interpretabilità
Sparsità e non negatività delle feature facilitano l'ispezione, ma non dimostrano interpretabilità completa. L'osservazione di associazioni fra feature e concetti deve essere supportata da interventi causali e test di robustezza.
17.4 Reproducibility gap
Il BDH originale dispone di codice pubblico e di una formulazione matematica analizzabile. Per BDH-CQ, invece, l'implementazione valutata e la ricetta completa di training non sono pubblicamente disponibili.
I risultati ARC possono essere verificati attraverso il sistema black-box, ma non ricostruiti indipendentemente da zero utilizzando soltanto il repository BDH.
17.5 Generalizzazione
Il fatto che un sistema risolva alcune trasformazioni ARC non dimostra automaticamente capacità general-purpose equivalenti a quelle di un grande modello linguistico.
Servono valutazioni comparabili su language modeling, matematica, programmazione, ragionamento multistep, retrieval, robustezza e trasferimento fuori dominio.
18. Quale architettura scegliere?
Non esiste un vincitore universale. La scelta dipende dal tipo di informazione che deve essere conservata e dal calcolo necessario per utilizzarla.
Un Transformer standard mantiene un meccanismo molto espressivo di accesso esplicito alla storia, al costo di cache crescente e attenzione potenzialmente quadratica.
Mamba sostituisce questo meccanismo con una dinamica selettiva a stato compatto, adatta a sequence modeling efficiente, ma soggetta ai limiti informativi di una rappresentazione compressa.
BDH propone una prospettiva associativa, in cui lo stato può essere letto come memoria di connessioni dinamiche fra rappresentazioni sparse.
BDH-CQ va oltre il semplice sequence mixing: introduce una separazione esplicita fra la memoria dell'esperienza contestuale e il calcolo iterativo effettuato per risolvere un nuovo problema.
Rimane però prematuro considerare BDH-CQ un sostituto operativo dei Transformer. I risultati di efficienza su ARC-AGI-1 sono interessanti, ma la documentazione pubblica non consente ancora una valutazione indipendente completa dell'architettura.
19. Conclusioni: dalla memoria dei token alla memoria delle relazioni
Il cambiamento più interessante non è semplicemente passare da un algoritmo quadratico a uno lineare.
È la possibilità di distinguere tre operazioni che nei modelli attuali tendono a sovrapporsi: acquisire esperienza, conservare associazioni e utilizzare calcolo iterativo per raggiungere una soluzione.
La self-attention offre un meccanismo di recupero contestuale estremamente flessibile. Gli State Space Model mostrano come elaborare sequenze attraverso transizioni compatte e selettive. La memoria associativa BDH introduce una lettura delle interazioni come aggiornamenti dello stato sinaptico.
BDH-CQ aggiunge il passaggio decisivo sul piano concettuale: il ragionamento non deve necessariamente essere una sequenza di parole generate dal modello. Può essere una trasformazione ricorrente di uno stato latente condizionato dall'esperienza acquisita.
La questione ancora aperta è se questa organizzazione possa conservare capacità di generalizzazione e ragionamento comparabili ai migliori modelli general-purpose, offrendo vantaggi misurabili e riproducibili di memoria, latenza e costo.
Il futuro dei modelli di ragionamento potrebbe non dipendere soltanto da quanti token sono capaci di elaborare, ma da come trasformano l'esperienza in stato, e lo stato in computazione.
20. Riferimenti primari e repository
- Kosowski et al. (2025), The Dragon Hatchling: The Missing Link between the Transformer and Models of the Brain. arXiv:2509.26507
- Engdahl et al. (2026), BDH-CQ: In-Context Learning with Recurrent Latent Reasoning. arXiv:2608.09888
- Pathway, implementazione originale BDH. github.com/pathwaycom/bdh
- Pathway, generatore di task ARC. github.com/pathwaycom/arc-task-gen
- Gu e Dao (2023), Mamba: Linear-Time Sequence Modeling with Selective State Spaces. arXiv:2312.00752
- Dao e Gu (2024), Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality. arXiv:2405.21060
- Repository ufficiale Mamba. github.com/state-spaces/mamba
- Vaswani et al. (2017), Attention Is All You Need. arXiv:1706.03762
- Katharopoulos et al. (2020), Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention. arXiv:2006.16236
- Hao et al. (2024), Training Large Language Models to Reason in a Continuous Latent Space. arXiv:2412.06769
NicoGIS Tech Deep Dive — 13 novembre 2026. Le valutazioni di prestazione citate appartengono alle rispettive pubblicazioni. Gli script Python aggiuntivi illustrano proprietà matematiche e non costituiscono benchmark indipendenti del sistema proprietario BDH-CQ.
Commenti