Approfondimento · Ipotesi
H2 alla prova: i nostri piloti giocattolo
Dieci piloti giocattolo su H2, imparare l’alto e consultare il basso: 34 previsioni preregistrate su 51 si verificano, e nei piloti da 4 a 7 la maggior parte di quelle false sono fallimenti di apprendimento, non confutazioni. Un modello minuscolo, una regola inventata, una memoria ideale nella maggior parte dei casi: non sono una prova sui modelli linguistici reali.
La domanda
H2 dice che i parametri sono scarsi e vanno riservati al ragionamento, mentre i fatti vanno in una memoria esterna. Prima di toccare un modello reale abbiamo costruito un mondo giocattolo: 1024 entità, ciascuna con una cifra casuale (il suo fatto), e una regola che somma le cifre di due entità modulo 10 (tre entità nel quinto pilota). Le coppie di prova non compaiono mai nell’addestramento, quindi il modello deve applicare la regola, non recitarla.
Il modello è un transformer a 2 strati e larghezza 64, addestrato per 2000 aggiornamenti. Ogni cifra è una media su 5 semi, il caso vale 0,1 e la dimensione giudicata è 1024 entità (256 è riportata, non giudicata). Le previsioni sono state scritte prima di ogni esecuzione; dal secondo pilota in poi sono state scritte dopo aver visto i precedenti, quindi non sono cieche. I dati pubblici sono anche sulla [pagina del laboratorio](https://huggingface.co/spaces/Kyyzen01/OrigoTech-AI-Research-Lab). I piloti da 6 a 10 riusano lo stesso modello e lo stesso mondo; la durata dell’addestramento varia (da 2000 a 4000 aggiornamenti, più una messa a punto nel pilota 10), come indicato in ogni protocollo.
Pilota 1: fatti nei pesi o in una memoria
Con 64 entità, tutte e tre le condizioni raggiungono almeno 0,9985 sulle coppie escluse. Con 1024, un modello che tiene i fatti nei suoi pesi li ricorda perfettamente (accuratezza dei fatti 1,0000) ma ottiene 0,0973 sulle coppie escluse, e 0,1235 con circa 2,6 volte i parametri (larghezza 128): vicino al caso. Lo stesso modello ottiene 1,0000 quando una memoria ideale mette i due fatti nel suo contesto. Tutte le 5 previsioni si sono verificate. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 1: facts in the weights or in a memory (results, JSON; protocol alongside)
Pilota 2: passaggi espliciti o addestramento più lungo
Se il modello scrive prima i due fatti e poi li somma (passaggi espliciti, supervisionati nell’addestramento), raggiunge 1,0000 con 1024 entità senza alcuna memoria. Raddoppiare l’addestramento a 4000 aggiornamenti lascia invece il modello semplice a 0,1285 (0,1018 a 2000). Con 256 entità, l’esecuzione più lunga raggiunge 0,9393, da 0,4710 a 2000 aggiornamenti, con semi da 0,6965 a 1,0000. In questo giocattolo una memoria non serve per comporre, ma i passaggi sono supervisionati, il che non dice nulla sui modelli reali. Tutte le 5 previsioni si sono verificate. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 2: explicit steps or longer training (results, JSON; protocol alongside)
Pilota 3: aggiornare i fatti
Con i fatti nel contesto, i fatti modificati ottengono 1,0000 e le entità mai viste nell’addestramento 1,0000, contro 0,1066 e 0,1008 del modello senza memoria. L’affinamento dei pesi solo sulle modifiche, per 200 aggiornamenti, arriva a 0,2376 sui fatti modificati mentre l’accuratezza sui fatti intatti scende da 1,0000 a 0,1337. Con la ripetizione dei vecchi fatti, i fatti intatti restano a 0,9975, ma quelli modificati arrivano solo a 0,3399. 5 previsioni su 6 si sono verificate; quella falsa si aspettava che la modifica fosse assorbita in 200 aggiornamenti. Una sola ricetta di affinamento, nessun editor di conoscenza dedicato. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 3: updating facts (results, JSON; protocol alongside)
Pilota 4: recupero imperfetto
Ogni elemento recuperato viene sostituito, con probabilità 1 − r, da quello di un’altra entità. Con r = 0,9, 0,7 e 0,5 l’accuratezza è 0,8366, 0,5604 e 0,3306, vicina a r² + (1 − r²) × 0,1 (0,829, 0,541, 0,325): entrambi gli elementi devono essere giusti, altrimenti la risposta è casuale. Il modello a passaggi senza memoria ottiene 0,9997, quindi il modello con memoria scende di oltre 0,10 sotto di esso già a r = 0,9. Il test dei distrattori non è concluso: un modello addestrato con 4 distrattori casuali non ha imparato la regola (0,1163), quindi ciò che accade con 8 non si può leggere. 3 previsioni su 5 si sono verificate; le due false sono fallimenti di apprendimento. Sostituzione casuale, non un vero motore di ricerca; costo della ricerca non misurato. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 4: imperfect retrieval (results, JSON; protocol alongside)
Pilota 5: tre fatti
Con tre fatti da sommare, un passaggio dà 0,0989 e i passaggi espliciti semplici 0,1215, benché i tre fatti siano ricordati a 0,9999. Aggiungere una somma parziale intermedia porta il risultato a 0,9998. Il modello a memoria esterna ha una media di 0,2659 (semi da 0,0985 a 0,9285): impara molto tardi, e in questa esecuzione un solo seme su cinque ha imparato la regola. 3 previsioni su 5 si sono verificate; le due false sono fallimenti di apprendimento entro 2000 aggiornamenti, il che non è una prova contro la composizione. Una regola giocattolo, una dimensione di modello. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 5: three-fact composition (results, JSON; protocol alongside)
Pilota 6: distrattori e curriculum
Qui la memoria contiene anche elementi distrattori casuali. Con 4 distrattori, un modello addestrato per 4000 aggiornamenti raggiunge 0,2456 sulle coppie escluse (semi da 0,0955 a 0,7690), e uno addestrato con un curriculum (0, poi 2, poi 4 distrattori) 0,3856 (0,1275 a 0,7440). Con 8 distrattori il modello con curriculum resta a 0,1052, livello del caso, contro 0,9999 dello stesso formato senza distrattori. Il controllo sui fatti recuperati fallisce in diverse celle (per esempio 0,1440 e 0,1666 con 8 distrattori), quindi gli altri risultati non sono leggibili e la domanda resta aperta. 1 previsione su 5 si è verificata; le quattro false sono fallimenti di apprendimento. Il riferimento pulito è addestrato per 2000 aggiornamenti contro 4000 (non appaiato). Solo distrattori casuali. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 6: distractors and a curriculum (results, JSON; protocol alongside)
Pilota 7: tre fatti, addestramento più lungo
Con tre fatti e 4000 aggiornamenti, il modello a memoria esterna ha una media di 0,3286 (semi da 0,0955 a 0,8415; nessuno arriva a 0,90), contro 0,1046 a 2000 aggiornamenti. Cominciare con due fatti per un riscaldamento di 1500 aggiornamenti porta la media a 0,6981 (0,1230 a 0,9995; +0,3695 rispetto alla sola memoria), ma la dispersione tra i semi è grande. I passaggi espliciti semplici, senza somma parziale, restano a 0,1645 (0,1030 a 0,2425). I tre fatti sono ricordati a 1,0000 in tutte e tre le condizioni. 2 previsioni su 5 si sono verificate (il curriculum è almeno buono quanto la sola memoria; i fatti sono ricordati). Le false sono fallimenti di apprendimento, con una cella dovuta a un seme fortunato. Una durata di riscaldamento, una regola giocattolo. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 7: three facts, longer training (results, JSON; protocol alongside)
Pilota 8: frequenti nei pesi, rari in memoria
Con entità estratte da una legge di Zipf (poche frequenti, molte rare), il modello senza memoria ottiene 0,9520 sulle coppie di entità frequenti e 0,9260 su quelle di entità rare, quindi anche i fatti rari sono appresi nei pesi. L’ibrido (fatti frequenti nei pesi, rari in memoria) ottiene 0,9904 e 0,9926, e il modello tutto in memoria 1,0000 e 0,9999. Ponderato per la frequenza, l’ibrido è 0,0024 sotto la memoria completa (0,9976 contro 1,0000). 3 previsioni su 5 si sono verificate; le due false sono che i fatti rari non sarebbero appresi nei pesi e che l’ibrido sarebbe almeno buono quanto la memoria completa. Una sola suddivisione di Zipf; i fatti frequenti possono essere stati memorizzati anziché composti. Recupero ideale. Dettagli: risultati, protocollo.
Pilota 9: quanti esempi della regola
Addestrato solo sul 2 % o sul 5 % delle coppie, il modello a memoria esterna raggiunge 1,0000 sulle coppie escluse (0,9977 al 20 %, 1,0000 con tutte). Senza memoria (passaggi espliciti) raggiunge 0,9998 al 2 % ma 0,9132 al 5 % (semi da 0,5960 a 1,0000), contro 0,9980 con tutte le coppie. 4 previsioni su 5 si sono verificate; la falsa (più coppie non nuocciono mai) fallisce perché, senza memoria, il 2 % supera il 100 % di 0,0018. La regola usa solo 100 coppie di cifre, quindi qui bastano pochi esempi: è specifico del giocattolo e non dice nulla sui modelli reali. Recupero ideale. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 9: how many rule examples (results, JSON; protocol alongside)
Pilota 10: aggiornamenti più lunghi o più forti
Dopo 1000 aggiornamenti, la messa a punto sui fatti modificati con ripetizione dei vecchi raggiunge 0,5310 sulle coppie modificate, e 0,8212 con un tasso di apprendimento tre volte maggiore (semi da 0,6720 a 0,9665), mentre i fatti intatti restano a 0,9876. Senza ripetizione e con un tasso piccolo, i fatti intatti scendono a 0,2092 e le coppie modificate arrivano solo a 0,2138. Una quota maggiore di righe modificate con ripetizione raggiunge 0,4054, sotto la ricetta di ripetizione semplice (scarto −0,1256). Dopo la messa a punto, le entità mai viste in addestramento restano al caso (0,099 a 0,103), mentre la memoria esterna ottiene 0,9998 sulle coppie modificate e 1,0000 sulle entità nuove, senza alcun aggiornamento. 3 previsioni su 5 si sono verificate; le false sono che l’oblio sarebbe limitato senza ripetizione (0,2092, sotto lo 0,50 atteso) e che una quota maggiore di modifiche aiuterebbe. Quattro ricette di messa a punto, un valore ciascuna, senza ricerca; nessun editor di conoscenze dedicato. Dettagli: risultati, protocollo.
Fonte: OrigoTech, H2 toy pilot 10: longer or stronger updates (results, JSON; protocol alongside)
Lettura: che cosa suggerisce il mondo giocattolo
In questo mondo giocattolo, comporre molti fatti memorizzati in un solo passaggio è la parte difficile, e due cose la risolvono: una memoria esterna ideale, o scrivere i fatti passo dopo passo. Ciò che una memoria aggiunge con chiarezza è l’aggiornamento: immediato con una memoria, lento nei pesi e, senza ripetizione dei vecchi fatti, molto smemorato (con ripetizione e un tasso di apprendimento maggiore, le modifiche arrivano a 0,8212 dopo 1000 aggiornamenti). Il suo vantaggio si riduce quando il recupero peggiora. Con tre fatti, scrivere i fatti non basta e serve una somma intermedia; un riscaldamento su due fatti aiuta in media (0,6981 contro 0,3286), ma i semi differiscono molto. Un ibrido con i fatti frequenti nei pesi non si distingue dal tenere tutto in memoria, e in questo giocattolo sono bastati pochi esempi della regola. La questione dei distrattori resta aperta. 34 delle 51 previsioni preregistrate si sono verificate (5 su 5, 5 su 5, 5 su 6, 3 su 5, 3 su 5, 1 su 5, 2 su 5, 3 su 5, 4 su 5 e 3 su 5); nei piloti da 4 a 7 la maggior parte di quelle false sono fallimenti di apprendimento, non confutazioni, mentre quelle dei piloti da 8 a 10 sono risultati misurati.
Cosa non dimostrano i numeri
Un mondo giocattolo: una regola (somma modulo 10), fatti casuali indipendenti, un modello piccolo, 5 semi. Il recupero è ideale, tranne nei piloti 4 e 6, dove è corrotto da una sostituzione casuale o da distrattori, e il costo della ricerca non è misurato. I passaggi espliciti sono ragionamento supervisionato, non dimostrato su modelli linguistici reali. La dimensione 256 è riportata ma non giudicata; non si esegue alcun test di significatività e non si stima alcuna percentuale di dati risparmiati. Le previsioni successive al primo pilota sono state scritte conoscendo i risultati precedenti. Il pilota 1 è stato eseguito a 2000 aggiornamenti dopo che un primo tentativo a 3000 era stato interrotto per il tempo, e un controllo di durata su CPU, di cui gli autori hanno visto le accuratezze, ha preceduto il giudizio. Nel pilota 6 il riferimento pulito è addestrato per 2000 aggiornamenti contro 4000 per gli altri (non appaiato); i piloti 7 e 8 usano una sola durata e una sola suddivisione testa/coda; il pilota 10 ha quattro ricette di messa a punto con un valore ciascuna. Anche le 13 previsioni verificate nei piloti da 6 a 10 (su 25) sono state scritte conoscendo i piloti precedenti. Questi piloti non convalidano né confutano H2 per modelli reali: la sua confidenza del 64 % resta invariata.
Altri approfondimenti
- Imparare in ordine
- Scartare con intelligenza
- Una memoria dentro il modello
- Il costo diventa logaritmico
- Pensare per idee, non per parole
- Accendere solo una parte del modello
- Chiedere prima al modello piccolo
- Distillare in programmi, non in modelli
- Calcolare con meno bit
- Cambiare la macchina
- Verificare costa meno che scrivere
- Come si combinano le sette piste
- Un modello piccolo all'altezza di un gigante?
- Un modello piccolo che migliora da solo, su un computer qualunque?
- Le ipotesi alla prova
- Tradurre un modello e tenere solo il necessario?
- H1 alla prova: i nostri esperimenti
- Come funzionano i nostri esperimenti su H1
Fonti
- OrigoTech, H2 toy pilot 1: facts in the weights or in a memory (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 2: explicit steps or longer training (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 3: updating facts (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 4: imperfect retrieval (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 5: three-fact composition (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 6: distractors and a curriculum (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 7: three facts, longer training (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 8: frequent facts in the weights, rare ones in memory (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 9: how many rule examples (results, JSON; protocol alongside)
- OrigoTech, H2 toy pilot 10: longer or stronger updates (results, JSON; protocol alongside)