L'IA di domani Glossario
IT

← Torna al quaderno

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.

Speculativo aggiornato il

I

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.

II

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)

III

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)

IV

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)

V

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)

VI

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)

VII

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)

VIII

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)

IX

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.

Fonte: OrigoTech, H2 toy pilot 8: frequent facts in the weights, rare ones in memory (results, JSON; protocol alongside)

X

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)

XI

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)

XII

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.

XIII

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.

Torna su