Deep Dive into LLMs like ChatGPT

Ciao a tutti, volevo fare questo video da un po'. È un'introduzione completa ma per un pubblico generale ai modelli linguistici di grandi dimensioni come ChatGPT e quello che spero di ottenere in questo video è darvi dei modelli mentali per pensare a cosa sia questo strumento. È ovviamente magico e sorprendente per certi versi, è molto bravo in alcune cose, non molto bravo in altre e ci sono anche molti spigoli vivi di cui essere consapevoli. Quindi, cosa c'è dietro questa casella di testo? Puoi metterci dentro qualsiasi cosa e premere invio, ma cosa dovremmo metterci dentro e come vengono generate queste parole? Come funziona e con cosa stai parlando esattamente? Spero di affrontare tutti questi argomenti in questo video. Andremo attraverso l'intera pipeline di come vengono costruite queste cose, ma manterrò tutto accessibile a un pubblico generale. Quindi, diamo un'occhiata prima a come si costruisce qualcosa come ChatGPT. E lungo la strada parlerò di alcune delle implicazioni cognitive e psicologiche di questi strumenti.

Ok, costruiamo ChatGPT. Ci saranno più fasi disposte sequenzialmente. La prima fase è chiamata fase di pre-addestramento e il primo passo della fase di pre-addestramento è scaricare ed elaborare internet. Per avere un'idea di cosa assomigli approssimativamente, consiglio di guardare questo URL qui. Quindi, questa azienda chiamata Hugging Face ha raccolto, creato e curato questo set di dati chiamato FineWeb. E entrano nei dettagli in questo post del blog su come hanno costruito il set di dati FineWeb. E tutti i principali fornitori di LLM come OpenAI, Anthropic e Google e così via avranno un equivalente interno di qualcosa come il set di dati FineWeb.

Quindi, approssimativamente, cosa stiamo cercando di ottenere qui? Stiamo cercando di ottenere tonnellate di testo da internet, da fonti pubblicamente disponibili. Quindi, stiamo cercando di avere un'enorme quantità di documenti di altissima qualità e vogliamo anche una grande diversità di documenti perché vogliamo avere molta conoscenza all'interno di questi modelli. Quindi, vogliamo una grande diversità di documenti di alta qualità e ne vogliamo molti, molti. E raggiungere questo obiettivo è piuttosto complicato e, come puoi vedere qui, richiede più fasi per essere fatto bene.

Quindi, diamo un'occhiata a come sono alcune di queste fasi. Per ora, vorrei solo notare che, ad esempio, il set di dati FineWeb, che è abbastanza rappresentativo di ciò che vedresti in un'applicazione di livello di produzione, finisce per essere solo circa 44 terabyte di spazio su disco. Puoi ottenere una chiavetta USB per un terabyte molto facilmente o penso che questo potrebbe stare quasi su un singolo disco rigido oggi. Quindi, non è una quantità enorme di dati alla fine della giornata, anche se internet è molto, molto grande. Stiamo lavorando con il testo e lo stiamo anche filtrando aggressivamente, quindi finiamo con circa 44 terabyte in questo esempio.

Quindi, diamo un'occhiata a come sono questi dati e quali sono anche alcune di queste fasi. Il punto di partenza per molti di questi sforzi e qualcosa che contribuisce alla maggior parte dei dati alla fine è il dato da Common Crawl. Quindi, Common Crawl è un'organizzazione che ha fondamentalmente setacciato internet dal 2007. Quindi, a partire dal 2024, ad esempio, Common Crawl ha indicizzato 2,7 miliardi di pagine web. E hanno tutti questi crawler che vanno in giro per internet e quello che finisci per fare fondamentalmente è iniziare con poche pagine web seed e poi segui tutti i link e continui a seguire i link e continui a indicizzare tutte le informazioni e finisci con tonnellate di dati da internet nel tempo. Questo è solitamente il punto di partenza per molti di questi sforzi.

Ora, questi dati di Common Crawl sono piuttosto grezzi e vengono filtrati in molti, molti modi diversi. Quindi, qui documentano, questo è lo stesso diagramma, documentano un po' il tipo di elaborazione che avviene in queste fasi. La prima cosa qui è qualcosa chiamato filtraggio URL. Quindi, a cosa si riferisce è che ci sono queste liste di blocco di URL o domini da cui non vuoi ottenere dati. Quindi, di solito questo include cose come siti web di malware, siti web di spam, siti web di marketing, siti web razzisti, siti per adulti e cose del genere. Quindi, ci sono tonnellate di diversi tipi di siti web che vengono semplicemente eliminati in questa fase perché non li vogliamo nel nostro set di dati.

La seconda parte è l'estrazione del testo. Devi ricordare che tutte queste pagine web, questo è l'HTML grezzo di queste pagine web che vengono salvate da questi crawler. Quindi, quando vado a ispezionare qui, è così che appare l'HTML grezzo. Noterai che ha tutto questo markup, come elenchi e cose del genere, e c'è CSS e tutto questo tipo di cose. Quindi, questo è quasi codice informatico per queste pagine web. Ma quello che vogliamo davvero è solo questo testo, giusto? Vogliamo solo il testo di questa pagina web e non vogliamo la navigazione e cose del genere. Quindi, c'è molto filtraggio, elaborazione ed euristiche che vanno nel filtrare adeguatamente solo il loro buon contenuto di queste pagine web.

La fase successiva qui è il filtraggio linguistico. Quindi, ad esempio, FineWeb filtra utilizzando un classificatore linguistico. Cercano di indovinare in quale lingua si trova ogni singola pagina web e poi conservano solo le pagine web che hanno più del 65% di inglese, come esempio. E così puoi avere un'idea che questa è una decisione di progettazione che diverse aziende possono prendere per sé. Quale frazione di tutte le diverse lingue includeremo nel nostro set di dati? Perché, ad esempio, se filtriamo tutto lo spagnolo, come esempio, allora potresti immaginare che il nostro modello in seguito non sarà molto bravo in spagnolo perché non ha mai visto così tanti dati di quella lingua. E così diverse aziende possono concentrarsi sulle prestazioni multilingue in misura diversa, come esempio. Quindi, FineWeb è piuttosto focalizzato sull'inglese e quindi il loro modello linguistico, se ne addestrano uno in seguito, sarà molto bravo in inglese, ma potrebbe non essere molto bravo in altre lingue.

Dopo il filtraggio linguistico, ci sono alcuni altri passaggi di filtraggio e deduplicazione e cose del genere, finendo ad esempio con la rimozione di PII. Questa è informazione personalmente identificabile. Quindi, come esempio, indirizzi, numeri di previdenza sociale e cose del genere. Cercheresti di rilevarli e cercheresti di filtrare anche quel tipo di pagine web dal set di dati. Quindi, ci sono molte fasi qui e non entrerò nei dettagli completi, ma è una parte piuttosto estesa della pre-elaborazione e si finisce, ad esempio, con il set di dati FineWeb.

Quindi, quando ci clicchi sopra, puoi vedere alcuni esempi di come appare effettivamente. E chiunque può scaricarlo dalla pagina web di Hugging Face. E quindi, ecco alcuni esempi del testo finale che finisce nel set di addestramento. Questo è un articolo sui tornado nel 2012. Quindi, ci sono stati alcuni tornado nel 2020 nel 2012 e cosa è successo. Il prossimo è qualcosa su "lo sapevi che hai due piccole ghiandole surrenali grandi come batterie da 9 volt nel tuo corpo?". Ok, quindi questo è un articolo medico un po' strano. Quindi, pensali semplicemente come pagine web su internet filtrate solo per il testo in vari modi. E ora abbiamo tonnellate di testo, 40 terabyte, e questo ora è il punto di partenza per il passo successivo di questa fase.

Ora, volevo darti un senso intuitivo di dove siamo in questo momento. Quindi, ho preso le prime 200 pagine web qui, e ricorda che ne abbiamo tonnellate, e prendo tutto quel testo e lo metto tutto insieme, lo concateno. E questo è quello che otteniamo. Otteniamo solo questo testo grezzo, testo grezzo di internet, e ce n'è tonnellate anche in queste 200 pagine web. Quindi, posso continuare a zoomare qui e abbiamo questo enorme arazzo di dati testuali. E questi dati testuali hanno tutti questi schemi. E quello che vogliamo fare ora è iniziare ad addestrare reti neurali su questi dati, in modo che le reti neurali possano interiorizzare e modellare come scorre questo testo, giusto? Quindi, abbiamo solo questa gigantesca trama di testo e ora vogliamo ottenere reti neurali che la imitino.

Ok, ora, prima di inserire il testo nelle reti neurali, dobbiamo decidere come rappresenteremo questo testo e come lo forniremo. Ora, il modo in cui funziona la nostra tecnologia per queste reti neurali è che si aspettano una sequenza unidimensionale di simboli e vogliono un insieme finito di simboli possibili. E quindi dobbiamo decidere quali sono i simboli e poi dobbiamo rappresentare i nostri dati come una sequenza unidimensionale di quei simboli. Quindi, in questo momento, quello che abbiamo è una sequenza unidimensionale di testo. Inizia qui e va qui e poi viene qui, ecc. Quindi, questa è una sequenza unidimensionale, anche se sul mio monitor, ovviamente, è disposta in modo bidimensionale, ma va da sinistra a destra e dall'alto verso il basso, giusto? Quindi, è una sequenza unidimensionale di testo.

Ora, essendo computer, ovviamente, c'è una rappresentazione sottostante qui. Quindi, se faccio quello che si chiama codifica UTF-8 di questo testo, posso ottenere i bit grezzi che corrispondono a questo testo nel computer. Ed è così che appare. Quindi, si scopre che, ad esempio, questa primissima barra qui sono i primi otto bit, come esempio. Quindi, cos'è questa cosa, giusto? Questa è la rappresentazione che stiamo cercando. In un certo senso, abbiamo esattamente due simboli possibili: zero e uno, e abbiamo una sequenza molto lunga di essi. Ora, si scopre che la lunghezza di questa sequenza sarà in realtà una risorsa finita e preziosa nella nostra rete neurale, e in realtà non vogliamo sequenze estremamente lunghe di soli due simboli. Invece, quello che vogliamo è scambiare questa dimensione simbolica del nostro vocabolario, come lo chiamiamo, e la lunghezza della sequenza risultante. Quindi, non vogliamo solo due simboli e sequenze estremamente lunghe; vogliamo più simboli e sequenze più brevi.

Quindi, un modo ingenuo per comprimere o diminuire la lunghezza della nostra sequenza qui è considerare fondamentalmente un gruppo di bit consecutivi, ad esempio otto bit, e raggrupparli in un singolo, quello che si chiama byte. Quindi, poiché questi bit sono accesi o spenti, se ne prendiamo un gruppo di otto, ci sono solo 256 combinazioni possibili di come questi bit potrebbero essere accesi o spenti. E quindi possiamo rappresentare questa sequenza in una sequenza di byte invece. Quindi, questa sequenza di byte sarà otto volte più corta, ma ora abbiamo 256 simboli possibili. Quindi, ogni numero qui va da 0 a 255. Ora, vi incoraggio davvero a pensarli non come numeri, ma come ID univoci o come simboli univoci. Quindi, forse è un po' più, forse è meglio pensare a sostituire ognuno di questi con un emoji univoco. Otterresti qualcosa del genere. Quindi, fondamentalmente abbiamo una sequenza di emoji e ci sono 256 emoji possibili, puoi pensarla in quel modo.

Ora, si scopre che in produzione per i modelli linguistici all'avanguardia, in realtà vuoi andare oltre. Vuoi continuare a ridurre la lunghezza della sequenza, perché di nuovo, è una risorsa preziosa, in cambio di più simboli nel tuo vocabolario. E il modo in cui questo viene fatto è eseguendo quello che si chiama l'algoritmo Byte Pair Encoding. E il modo in cui funziona è che stiamo fondamentalmente cercando byte o simboli consecutivi che sono molto comuni. Quindi, ad esempio, si scopre che la sequenza 116 seguita da 32 è abbastanza comune e si verifica molto frequentemente. Quindi, quello che faremo è raggruppare questa coppia in un nuovo simbolo. Quindi, conieremo un simbolo con un ID 256 e riscriveremo ogni singola coppia 11632 con questo nuovo simbolo. E poi possiamo iterare questo algoritmo quante volte vogliamo, e ogni volta che coniamo un nuovo simbolo, stiamo diminuendo la lunghezza e aumentando la dimensione del simbolo. E in pratica, si scopre che un'impostazione abbastanza buona della dimensione del vocabolario si rivela essere circa 100.000 simboli possibili. In particolare, GPT-4 utilizza 100.277 simboli. E questo processo di conversione dal testo grezzo in questi simboli, o come li chiamiamo token, è il processo chiamato tokenizzazione.

Quindi, diamo ora un'occhiata a come GPT-4 esegue la tokenizzazione, passando dal testo ai token e dai token di nuovo al testo, e a cosa assomiglia effettivamente. Un sito web che mi piace usare per esplorare queste rappresentazioni di token si chiama Tiktokenizer. E quindi vieni qui nel menu a discesa e seleziona cl100_base, che è il tokenizer del modello base di GPT-4. E qui a sinistra puoi inserire del testo e ti mostra la tokenizzazione di quel testo. Ad esempio, "hello world". Quindi, "hello world" si rivela essere esattamente due token: il token "hello", che è il token con ID 15339, e il token " world", che è il token 11917. Quindi, "hello world". Se unissi questi due, ad esempio, otterrei di nuovo due token, ma è il token "h" seguito dal token "l world" senza la "h". Se inserisco due spazi qui tra "hello" e "world", è di nuovo una tokenizzazione diversa. C'è un nuovo token 220 qui. Ok, quindi puoi giocare con questo e vedere cosa succede. Tieni anche presente che questo è sensibile alle maiuscole. Quindi, se questa è una "H" maiuscola, è qualcosa di diverso. O se è "Hello world", allora questo finisce per essere tre token invece di solo due token. Sì, quindi puoi giocare con questo e avere un'idea intuitiva di come funzionano questi token. In realtà torneremo alla tokenizzazione un po' più tardi nel video. Per ora, volevo solo mostrarti il sito web e volevo mostrarti che questo testo, alla fine della giornata, ad esempio, se prendo una riga qui, è quello che GPT-4 vedrà. Quindi, questo testo sarà una sequenza di lunghezza 62. Questa è la sequenza qui, e questi sono i pezzi di testo che corrispondono a questi simboli. E di nuovo, ci sono 100.277 possibili simboli, e ora abbiamo sequenze unidimensionali di quei simboli. Quindi, sì, torneremo alla tokenizzazione, ma per ora è dove siamo.

Ok, quello che ho fatto ora è che ho preso questa sequenza di testo che abbiamo qui nel set di dati e l'ho ri-rappresentata usando il nostro tokenizer in una sequenza di token. E questo è quello che sembra ora. Quindi, ad esempio, quando torniamo al set di dati FineWeb, menzionano che non solo sono 44 terabyte di spazio su disco, ma questa è una sequenza di circa 15 trilioni di token in questo set di dati. E qui, questi sono solo alcuni dei primi uno, due, tre o qualche migliaio, penso, token di questo set di dati, ma ce ne sono 15 trilioni da tenere a mente. E di nuovo, tieni presente ancora una volta che tutti questi rappresentano piccoli pezzi di testo, sono solo atomi di queste sequenze, e i numeri qui non hanno senso; sono solo ID univoci.

Ok, ora arriviamo alla parte divertente, che è l'addestramento della rete neurale. Ed è qui che avviene gran parte del lavoro pesante computazionalmente quando si addestrano queste reti neurali. Quindi, quello che facciamo qui in questo passaggio è che vogliamo modellare le relazioni statistiche di come questi token si susseguono nella sequenza. Quindi, quello che facciamo è che entriamo nei dati e prendiamo finestre di token. Quindi, prendiamo una finestra di token da questi dati in modo abbastanza casuale. E la lunghezza della finestra può variare ovunque tra zero token, in realtà, fino a una dimensione massima che decidiamo. Quindi, ad esempio, in pratica potresti vedere token con finestre di, diciamo, 8.000 token. Ora, in linea di principio, possiamo usare lunghezze di finestra arbitrarie di token, ma elaborare sequenze di finestre molto lunghe sarebbe semplicemente molto costoso computazionalmente. Quindi, decidiamo semplicemente che, diciamo, 8.000 è un buon numero, o 4.000 o 16.000, e lo ritagliamo lì.

Ora, in questo esempio, prenderò i primi quattro token, solo in modo che tutto si adatti bene. Quindi, questi token, prenderemo una finestra di quattro token: "bar view in" e "space single", che sono questi ID di token. E ora quello che stiamo cercando di fare qui è cercare di prevedere il token che viene dopo nella sequenza. Quindi, 3962 viene dopo, giusto? Quindi, quello che facciamo ora qui è che chiamiamo questo il contesto. Questi quattro token sono il contesto e alimentano una rete neurale, e questo è l'input alla rete neurale. Ora, entrerò nei dettagli di cosa c'è dentro questa rete neurale tra un po'. Per ora, è importante capire qual è l'input e qual è l'output della rete neurale. L'input sono sequenze di token di lunghezza variabile, ovunque tra zero e una dimensione massima come 8.000. L'output ora è una previsione di ciò che viene dopo. Quindi, poiché il nostro vocabolario ha 100.277 token possibili, la rete neurale produrrà esattamente quel numero di numeri, e tutti questi numeri corrispondono alla probabilità che quel token venga dopo nella sequenza. Quindi, sta facendo delle ipotesi su cosa viene dopo.

All'inizio, questa rete neurale è inizializzata casualmente. Quindi, e vedremo tra un po' cosa significa, ma è una trasformazione casuale. Quindi, queste probabilità all'inizio dell'addestramento saranno anche un po' casuali. Quindi, qui ho tre esempi, ma tieni presente che ci sono 100.000 numeri qui. Quindi, la probabilità di questo token "space direction" che la rete neurale dice che è il 4% probabile in questo momento, 11799 è il 2%, e poi qui la probabilità di 3962, che è "post", è il 3%. Ora, ovviamente, abbiamo campionato questa finestra dai nostri dati, quindi sappiamo cosa viene dopo. Sappiamo, ed è l'etichetta, sappiamo che la risposta corretta è che 3962 viene effettivamente dopo nella sequenza.

Quindi, ora abbiamo questo processo matematico per fare un aggiornamento alla rete neurale. Abbiamo il modo di sintonizzarla. E entreremo un po' nei dettagli tra un po', ma fondamentalmente sappiamo che questa probabilità qui del 3%, vogliamo che questa probabilità sia più alta, e vogliamo che le probabilità di tutti gli altri token siano più basse. E quindi abbiamo un modo per calcolare matematicamente come regolare e aggiornare la rete neurale in modo che la risposta corretta abbia una probabilità leggermente più alta.

Quindi, se faccio un aggiornamento alla rete neurale ora, la prossima volta che inserisco questa particolare sequenza di quattro token nella rete neurale, la rete neurale sarà leggermente aggiustata ora e dirà: "Ok, post è forse il 4%, e case ora forse è l'1%, e direction potrebbe diventare il 2% o qualcosa del genere". E quindi abbiamo un modo per spingere, per aggiornare leggermente la rete neurale per dare una probabilità più alta al token corretto che viene dopo nella sequenza. E ora devi solo ricordare che questo processo avviene non solo per questo token qui, dove questi quattro sono stati inseriti e hanno predetto questo, questo processo avviene contemporaneamente per tutti questi token nell'intero set di dati. E quindi, in pratica, campioniamo piccole finestre, piccoli batch di finestre, e poi a ogni singolo uno di questi token vogliamo regolare la nostra rete neurale in modo che la probabilità di quel token diventi leggermente più alta. E tutto questo avviene in parallelo in grandi batch di questi token. E questo è il processo di addestramento della rete neurale. È una sequenza di aggiornamenti in modo che le sue previsioni corrispondano alle statistiche di ciò che accade effettivamente nel tuo set di addestramento e le sue probabilità diventino coerenti con i modelli statistici di come questi token si susseguono nei dati.

Quindi, diamo ora un breve sguardo all'interno di queste reti neurali, solo per darti un'idea di cosa c'è dentro. Interni della rete neurale. Come ho detto, abbiamo questi input che sono sequenze di token. In questo caso, questi sono quattro token di input, ma possono essere ovunque tra zero e, diciamo, 8.000 token. In linea di principio, possono essere un numero infinito di token. Semplicemente, sarebbe troppo costoso computazionalmente elaborare un numero infinito di token. Quindi, lo ritagliamo a una certa lunghezza e quella diventa la lunghezza massima del contesto di quel modello.

Ora, questi input X sono mescolati in una gigantesca espressione matematica insieme ai parametri o ai pesi di queste reti neurali. Qui sto mostrando sei parametri di esempio e la loro impostazione, ma in pratica queste moderne reti neurali avranno miliardi di questi parametri. E all'inizio, questi parametri sono impostati completamente casualmente. Ora, con un'impostazione casuale dei parametri, potresti aspettarti che questa rete neurale faccia previsioni casuali, e lo fa. All'inizio, sono previsioni totalmente casuali, ma è attraverso questo processo di aggiornamento iterativo della rete che chiamiamo processo di addestramento di una rete neurale, in modo che l'impostazione di questi parametri venga regolata in modo tale che gli output della nostra rete neurale diventino coerenti con i modelli visti nel nostro set di addestramento.

Quindi, pensa a questi parametri come a delle manopole su un DJ set. E mentre giri queste manopole, ottieni previsioni diverse per ogni possibile sequenza di input di token, e addestrare una rete neurale significa semplicemente scoprire un'impostazione di parametri che sembra essere coerente con le statistiche del set di addestramento. Ora, vorrei darti un esempio di come appare questa gigantesca espressione matematica, solo per darti un'idea. E le reti moderne sono espressioni massive con probabilmente trilioni di termini, ma ti mostrerò un semplice esempio. Assomiglierebbe a questo. Voglio dire, questi sono i tipi di espressioni, solo per mostrarti che non è molto spaventoso. Abbiamo input X, come X1, X2, in questo caso due input di esempio, e vengono mescolati con i pesi della rete W0, W1, 2, 3, ecc. E questo mescolamento sono cose semplici come moltiplicazione, addizione, addizione, esponenziazione, divisione, ecc. Ed è oggetto della ricerca sull'architettura delle reti neurali progettare espressioni matematiche efficaci che abbiano molte caratteristiche convenienti: sono espressive, ottimizzabili, parallelizzabili, ecc. Ma, alla fine della giornata, queste non sono espressioni complesse e fondamentalmente mescolano gli input con i parametri per fare previsioni, e stiamo ottimizzando i parametri di questa rete neurale in modo che le previsioni siano coerenti con il set di addestramento.

Ora, vorrei mostrarti un esempio effettivo di livello di produzione di come sono queste reti neurali. Per questo, ti incoraggio ad andare su questo sito web che ha una bella visualizzazione di una di queste reti. Quindi, questo è quello che troverai su questo sito web. E questa rete neurale utilizzata in contesti di produzione ha questo tipo speciale di struttura. Questa rete è chiamata Transformer. E questa particolare, come esempio, ha circa 85.000 parametri. Ora, qui in alto prendiamo gli input, che sono le sequenze di token. E poi le informazioni fluiscono attraverso la rete neurale fino all'output, che qui sono i logit softmax, ma queste sono le previsioni di ciò che viene dopo, quale token viene dopo. E poi qui c'è una sequenza di trasformazioni e tutti questi valori intermedi che vengono prodotti all'interno di questa espressione matematica stanno in qualche modo prevedendo cosa viene dopo.

Quindi, come esempio, questi token vengono incorporati in una sorta di rappresentazione distribuita, come viene chiamata. Quindi, ogni token possibile ha una sorta di vettore che lo rappresenta all'interno della rete neurale. Quindi, prima incorporiamo i token, e poi quei valori fluiscono attraverso questo diagramma. E queste sono tutte espressioni matematiche molto semplici individualmente. Abbiamo layer norm, moltiplicazioni di matrici, softmax e così via. Quindi, qui c'è una sorta di blocco di attenzione di questo Transformer, e poi le informazioni fluiscono nel blocco del perceptron multistrato e così via. E tutti questi numeri qui sono i valori intermedi dell'espressione. E puoi quasi pensarli come tassi di attivazione di questi neuroni sintetici. Ma ti metterei in guardia dal pensarci troppo come neuroni, perché questi sono neuroni estremamente semplici rispetto ai neuroni che troveresti nel tuo cervello. I tuoi neuroni biologici sono processi dinamici molto complessi che hanno memoria e così via. Non c'è memoria in questa espressione; è un'espressione matematica fissa dall'input all'output senza memoria; è solo stateless. Quindi, questi sono neuroni molto semplici rispetto ai neuroni biologici, ma puoi ancora pensarci vagamente come un pezzo sintetico di tessuto cerebrale, se ti piace pensarlo in quel modo. Quindi, le informazioni fluiscono attraverso tutti questi neuroni che si attivano fino a quando non arriviamo alle previsioni.

Ora, non mi soffermerò troppo sui dettagli matematici precisi di tutte queste trasformazioni. Onestamente, non penso che sia così importante entrare nei dettagli. Quello che è davvero importante capire è che questa è una funzione matematica, è parametrizzata da un set fisso di parametri, come diciamo 85.000 di essi, ed è un modo per trasformare gli input in output. E mentre manipoliamo i parametri, otteniamo diversi tipi di previsioni, e poi dobbiamo trovare una buona impostazione di questi parametri in modo che le previsioni corrispondano ai modelli visti nel set di addestramento. Quindi, questo è il Transformer.

Ok, ti ho mostrato gli interni della rete neurale e abbiamo parlato un po' del processo di addestramento. Voglio coprire un altro stadio importante del lavoro con queste reti, ed è lo stadio chiamato inferenza. Quindi, nell'inferenza, quello che stiamo facendo è generare nuovi dati dal modello. E quindi vogliamo vedere quali schemi ha interiorizzato nei parametri della sua rete. Quindi, generare dal modello è relativamente semplice. Iniziamo con alcuni token che sono fondamentalmente il tuo prefisso, come quello con cui vuoi iniziare. Quindi, diciamo che vogliamo iniziare con il token 91. Quindi, lo inseriamo nella rete e ricordiamo che la rete ci dà probabilità, giusto? Ci dà questo vettore di probabilità qui. Quindi, quello che possiamo fare ora è fondamentalmente lanciare una moneta truccata. Quindi, possiamo campionare fondamentalmente un token basato su questa distribuzione di probabilità. Quindi, i token a cui il modello assegna un'alta probabilità hanno maggiori probabilità di essere campionati quando lanci questa moneta truccata, puoi pensarla in quel modo.

Quindi, campioniamo dalla distribuzione per ottenere un singolo token univoco. Quindi, ad esempio, il token 860 viene dopo. Quindi, 860 in questo caso, quando generiamo dal modello, potrebbe venire dopo. Ora, 860 è un token relativamente probabile. Potrebbe non essere l'unico token possibile in questo caso; potrebbero esserci molti altri token che avrebbero potuto essere campionati, ma potremmo vedere che 860 è un token relativamente probabile, come esempio. E infatti, nel nostro esempio di addestramento qui, 860 segue 91.

Quindi, ora diciamo che continuiamo il processo. Dopo 91 c'è 860, lo aggiungiamo e chiediamo di nuovo quale sia il terzo token. Campioniamo e diciamo solo che è 287, esattamente come qui. Facciamolo di nuovo. Torniamo indietro. Ora abbiamo una sequenza di tre e chiediamo quale sia il probabile quarto token. E campioniamo da quello e otteniamo questo. E ora diciamo che lo facciamo ancora una volta. Prendiamo quei quattro, campioniamo e otteniamo questo. E questo 13659 non è in realtà 3962 come avevamo prima. Quindi, questo token è il token "article", invece. Vedendo un singolo articolo. E quindi, in questo caso, non abbiamo riprodotto esattamente la sequenza che abbiamo visto qui nei dati di addestramento.

Quindi, tieni presente che questi sistemi sono stocastici. Hanno, stiamo campionando e stiamo lanciando monete, e a volte abbiamo fortuna e riproduciamo una piccola parte del testo nel set di addestramento, ma a volte otteniamo un token che non faceva parte letteralmente di nessuno dei documenti nel set di addestramento. Quindi, otterremo delle specie di remix dei dati che abbiamo visto nell'addestramento, perché ad ogni passo possiamo lanciare e ottenere un token leggermente diverso, e poi una volta che quel token entra, se campioni il prossimo e così via, molto rapidamente inizi a generare flussi di token che sono molto diversi dai flussi di token che hai visto nei documenti di addestramento. Quindi, statisticamente avranno proprietà simili, ma non sono identici ai tuoi dati di addestramento; sono ispirati ai dati di addestramento. E quindi, in questo caso, abbiamo ottenuto una sequenza leggermente diversa. E perché otterremmo "article"? Potresti immaginare che "article" sia un token relativamente probabile nel contesto di "bar viewing single", ecc. E puoi immaginare che la parola "article" seguisse questa finestra di contesto in qualche misura nei documenti di addestramento, e siamo semplicemente capitati a campionarla qui in quella fase.

Quindi, fondamentalmente, l'inferenza è solo prevedere da queste distribuzioni una alla volta. Continuiamo a reinserire i token e a ottenere il successivo, e stiamo sempre lanciando queste monete, e a seconda di quanto siamo fortunati o sfortunati, potremmo ottenere tipi di schemi molto diversi a seconda di come campioniamo da queste distribuzioni di probabilità. Quindi, questa è l'inferenza.

Quindi, nella maggior parte degli scenari comuni, fondamentalmente scaricare internet e tokenizzarlo è un passaggio di pre-elaborazione. Lo fai una sola volta, e poi, una volta che hai la tua sequenza di token, possiamo iniziare ad addestrare reti. E nei casi pratici, proveresti ad addestrare molte reti diverse con impostazioni diverse, disposizioni diverse e dimensioni diverse. E quindi farai molto addestramento di reti neurali. E poi, una volta che hai una rete neurale e la addestri e hai un set specifico di parametri con cui sei soddisfatto, allora puoi prendere il modello e fare inferenza, e puoi effettivamente generare dati dal modello. E quando sei su ChatGPT e stai parlando con un modello, quel modello è stato addestrato e addestrato da OpenAI molti mesi fa, probabilmente, e hanno un set specifico di pesi che funzionano bene. E quando parli con il modello, tutto ciò è solo inferenza. Non c'è più addestramento. Quei parametri sono fissi e stai solo parlando con il modello, in un certo senso, gli stai dando alcuni dei token e sta completando sequenze di token, ed è quello che vedi generato quando usi effettivamente il modello su ChatGPT. Quindi, quel modello fa solo inferenza da solo.

Quindi, diamo ora un'occhiata a un esempio di addestramento e inferenza che è piuttosto concreto e ti dà un'idea di come appaiono effettivamente quando questi modelli vengono addestrati. Ora, l'esempio con cui vorrei lavorare e che mi piace particolarmente è quello di GPT-2 di OpenAI. Quindi, GPT sta per Generative Pre-trained Transformer, ed è la seconda iterazione della serie GPT di OpenAI. Quando parli oggi con ChatGPT, il modello che è alla base di tutta la magia di quell'interazione è GPT-4, quindi la quarta iterazione di quella serie.

Ora, GPT-2 è stato pubblicato nel 2019 da OpenAI in questo articolo che ho qui. E il motivo per cui mi piace GPT-2 è che è la prima volta che è venuto insieme uno stack riconoscibilmente moderno. Quindi, tutti i pezzi di GPT-2 sono riconoscibili oggi secondo gli standard moderni; è solo che tutto è diventato più grande. Ora, non sarò in grado di entrare nei dettagli completi di questo articolo, ovviamente, perché è una pubblicazione tecnica. Ma alcuni dei dettagli che vorrei evidenziare sono i seguenti: GPT-2 era una rete neurale Transformer, proprio come quelle con cui lavoreresti oggi. Aveva 1,6 miliardi di parametri, quindi questi sono i parametri che abbiamo esaminato qui. Oggi, i Transformer moderni avrebbero molto più vicino a un trilione o diverse centinaia di miliardi, probabilmente. La lunghezza massima del contesto qui era di 1.024 token. Quindi, quando campioniamo finestre di token dal set di dati, non prendiamo mai più di 1.024 token. E quindi, quando stai cercando di prevedere il token successivo in una sequenza, non avrai mai più di 1.024 token nel tuo contesto per fare quella previsione. Ora, questo è anche minuscolo rispetto agli standard moderni. Oggi, le lunghezze del contesto dei token sarebbero molto più vicine a un paio di centinaia di migliaia o forse anche un milione. E quindi hai molto più contesto, molto più token nella cronologia, e puoi fare una previsione molto migliore del token successivo nella sequenza in quel modo. E infine, GPT-2 è stato addestrato su circa 100 miliardi di token. E anche questo è piuttosto piccolo rispetto agli standard moderni. Come ho detto, il set di dati FineWeb che abbiamo esaminato qui, il set di dati FineWeb ha 15 trilioni di token, quindi 100 miliardi è piuttosto piccolo.

Ora, ho provato a riprodurre GPT-2 per divertimento come parte di questo progetto chiamato lm.c. Quindi, puoi vedere la mia riproduzione di ciò che ho fatto in questo post su GitHub sotto il repository lm.c. In particolare, il costo di addestramento di GPT-2 nel 2019 era stimato essere di circa $40.000. Ma oggi puoi fare significativamente meglio di così. E in particolare, qui ci è voluto circa un giorno e circa $600. Ma questo non era nemmeno cercando troppo. Penso che potresti davvero abbassarlo a circa $100 oggi.

Ora, perché i costi sono diminuiti così tanto? Numero uno, questi set di dati sono migliorati molto e il modo in cui li filtriamo, li estraiamo e li prepariamo è diventato molto più raffinato. E quindi il set di dati è di qualità molto più alta. Questa è una cosa. Ma la differenza più grande è che i nostri computer sono diventati molto più veloci in termini di hardware, e lo vedremo tra un secondo, e anche il software per eseguire questi modelli e spremere tutta la velocità possibile dall'hardware. Quel software è anche migliorato molto, poiché tutti si sono concentrati su questi modelli e hanno cercato di eseguirli molto, molto velocemente.

Ora, non sarò in grado di entrare nei dettagli completi di questa riproduzione di GPT-2, e questo è un post tecnico lungo. Ma vorrei comunque darti un senso intuitivo di cosa significa effettivamente addestrare uno di questi modelli come ricercatore, cosa stai guardando e come appare, come ci si sente. Quindi, lasciami dare un'idea di questo un po'.

Ok, ecco come appare. Lasciami spostare questo. Quindi, quello che sto facendo qui è che sto addestrando un modello GPT-2 in questo momento. E quello che sta succedendo qui è che ogni singola riga qui, come questa, è un aggiornamento al modello. Quindi, ricordi come qui stiamo migliorando la previsione per ognuno di questi token, e stiamo aggiornando questi pesi o parametri della rete neurale. Quindi, qui ogni singola riga è un aggiornamento alla rete neurale in cui cambiamo i suoi parametri un po' in modo che sia migliore nel prevedere il token successivo. E in particolare, ogni singola riga qui sta migliorando la previsione su 1 milione di token nel set di addestramento. Quindi, abbiamo fondamentalmente preso 1 milione di token da questo set di dati e abbiamo cercato di migliorare la previsione di quel token come successivo in una sequenza su tutti e 1 milione di essi simultaneamente. E ad ogni singolo uno di questi passaggi, stiamo facendo un aggiornamento alla rete per quello.

Ora, il numero da guardare attentamente è questo numero chiamato "loss" (perdita). E la perdita è un singolo numero che ti dice quanto bene sta funzionando la tua rete neurale in questo momento. Ed è creato in modo che una bassa perdita sia buona. Quindi, vedrai che la perdita sta diminuendo man mano che facciamo più aggiornamenti alla rete neurale, il che corrisponde a fare previsioni migliori sul token successivo in una sequenza. E quindi la perdita è il numero che guardi come ricercatore di reti neurali, e stai aspettando, stai giocherellando con i pollici, stai bevendo caffè e ti assicuri che questo sembri buono, in modo che con ogni aggiornamento la tua perdita migliori e la rete diventi migliore nella previsione.

Ora, qui vedi che stiamo elaborando 1 milione di token per aggiornamento. Ogni aggiornamento richiede circa 7 secondi, all'incirca. E qui elaboreremo un totale di 32.000 passaggi di ottimizzazione. Quindi, 32.000 passaggi con 1 milione di token ciascuno sono circa 33 miliardi di token che elaboreremo. E attualmente siamo solo a circa 420 passi, 20 su 32.000. Quindi, siamo ancora solo poco più dell'1% fatto, perché ho eseguito questo solo per 10 o 15 minuti o qualcosa del genere.

Ora, ogni 20 passi, ho configurato questa ottimizzazione per fare inferenza. Quindi, quello che stai vedendo qui è che il modello sta prevedendo il token successivo in una sequenza. E quindi inizi casualmente e poi continui a inserire i token. Quindi, stiamo eseguendo questo passaggio di inferenza e questo è il modello che prevede il token successivo nella sequenza. E ogni volta che vedi apparire qualcosa, è un nuovo token. Quindi, diamo un'occhiata a questo e puoi vedere che non è ancora molto coerente. E tieni presente che siamo solo all'1% del percorso di addestramento, quindi il modello non è ancora molto bravo a prevedere il token successivo nella sequenza. Quindi, quello che esce è in realtà un po' di sciocchezze, giusto? Ma ha ancora un po' di coerenza locale. "Since she is mine, it's part of the information should discuss my father, great companions, Gordon showed me sitting over at", ecc.

Quindi, so che non sembra molto buono, ma scorriamo in realtà per vedere come appariva quando ho iniziato l'ottimizzazione. Quindi, tutto qui, al passo 1, dopo 20 passi di ottimizzazione, vedi che quello che stiamo ottenendo qui sembra completamente casuale. E ovviamente, questo perché il modello ha avuto solo 20 aggiornamenti ai suoi parametri, e quindi ti sta dando testo casuale perché è una rete casuale. E quindi puoi vedere che, almeno in confronto, questo modello sta iniziando a fare molto meglio. E infatti, se aspettassimo tutti i 32.000 passi, il modello sarebbe migliorato al punto che sta effettivamente generando inglese abbastanza coerente, e il flusso di token è corretto, e compongono l'inglese molto meglio. Quindi, questo deve ancora essere eseguito per circa un altro giorno o due. E quindi, a questo punto, ci assicuriamo solo che la perdita stia diminuendo, tutto sembra buono, e dobbiamo solo aspettare.

E ora, passiamo alla storia del calcolo richiesto, perché ovviamente non sto eseguendo questa ottimizzazione sul mio laptop; sarebbe troppo costoso, perché dobbiamo eseguire questa rete neurale e dobbiamo migliorarla e abbiamo bisogno di tutti questi dati e così via. Quindi, non puoi eseguirlo troppo bene sul tuo computer perché la rete è semplicemente troppo grande. Quindi, tutto questo viene eseguito sul computer che si trova nel cloud. E voglio affrontare il lato computazionale della storia dell'addestramento di questi modelli e come appare.

Quindi, diamo un'occhiata. Ok, quindi il computer su cui sto eseguendo questa ottimizzazione è questo nodo 8x H100. Quindi, ci sono otto H100 in un singolo nodo o in un singolo computer. Ora, sto affittando questo computer ed è da qualche parte nel cloud. Non sono sicuro di dove sia fisicamente. In realtà, il posto da cui mi piace affittare si chiama Lambda, ma ci sono molte altre aziende che forniscono questo servizio. Quindi, quando scorri verso il basso, puoi vedere che hanno alcuni prezzi on-demand per computer che hanno questi H100, che sono GPU. E ti mostrerò come sono tra un secondo. Ma on-demand, 8x GPU Nvidia H100, questa macchina costa $3 per GPU all'ora, ad esempio. Quindi, puoi affittare queste e poi ottieni una macchina nel cloud e puoi entrare e puoi addestrare questi modelli. E queste GPU, ecco come sono. Quindi, questa è una GPU H100. Ecco come appare. E la inserisci nel tuo computer. E le GPU sono perfette per addestrare le tue reti perché sono molto costose computazionalmente, ma mostrano molto parallelismo nel calcolo. Quindi, puoi avere molti lavoratori indipendenti che lavorano contemporaneamente per risolvere la moltiplicazione di matrici che è alla base dell'addestramento di queste reti neurali.

Quindi, questa è solo una di queste H100, ma in realtà le metteresti insieme. Quindi, potresti impilare otto di esse in un singolo nodo, e poi puoi impilare più nodi in un intero data center o in un intero sistema. Quindi, quando guardiamo un data center, iniziamo a vedere cose come questa, giusto? Abbiamo una GPU, va a otto GPU, va a un singolo sistema, va a molti sistemi. E questi sono i data center più grandi. E ovviamente sarebbero molto più costosi. E quello che sta succedendo è che tutte le grandi aziende tecnologiche desiderano queste GPU in modo da poter addestrare tutti questi modelli linguistici perché sono così potenti. E questo è fondamentalmente ciò che ha guidato il prezzo delle azioni di Nvidia a $3,4 trilioni oggi, come esempio. E perché Nvidia è esplosa. Questa è la corsa all'oro. La corsa all'oro è ottenere le GPU, ottenerne abbastanza in modo che possano collaborare per eseguire questa ottimizzazione. E cosa stanno facendo tutti? Stanno tutti collaborando per prevedere il token successivo su un set di dati come il set di dati FineWeb. Questo è il flusso di lavoro computazionale che è fondamentalmente estremamente costoso. Più GPU hai, più token puoi provare a prevedere e migliorare. E elaborerai questo set di dati più velocemente e potrai iterare più velocemente e ottenere una rete più grande e addestrare una rete più grande e così via.

Quindi, questo è quello che sembrano tutte quelle macchine. E questo è il motivo per cui tutto questo è così importante. E, ad esempio, questo è un articolo di circa un mese fa o giù di lì. Questo è il motivo per cui è importante che, ad esempio, Elon Musk stia ottenendo 100.000 GPU in un singolo data center. E tutte queste GPU sono estremamente costose, richiederanno un sacco di energia, e tutte stanno solo cercando di prevedere il token successivo nella sequenza e migliorare la rete facendo così. E ottenere probabilmente testo molto più coerente di quello che stiamo vedendo qui, molto più velocemente.

Ok, sfortunatamente, non ho un paio di dieci o cento milioni di dollari da spendere per addestrare un modello davvero grande come questo. Ma per fortuna, possiamo rivolgerci ad alcune grandi aziende tecnologiche che addestrano questi modelli di routine e ne rilasciano alcuni una volta che hanno finito di addestrarli. Quindi, hanno speso un'enorme quantità di calcolo per addestrare questa rete e rilasciano la rete alla fine dell'ottimizzazione. Quindi, è molto utile perché hanno fatto molto calcolo per questo.

Quindi, ci sono molte aziende che addestrano questi modelli di routine, ma in realtà non molte di loro rilasciano questi cosiddetti modelli base. Il modello che esce alla fine qui è quello che si chiama modello base. Cos'è un modello base? È un simulatore di token, giusto? È un testo di internet, un token.

simulatore e quindi non è di per sé utile ancora perché quello che vogliamo è quello che viene chiamato un assistente, vogliamo fare domande e ottenere risposte. Questi modelli non lo faranno, creano solo delle sorta di remix di internet, sognano pagine internet, quindi i modelli di base non vengono rilasciati molto spesso perché sono solo un primo passo di altri passi che dobbiamo ancora compiere per ottenere un sistema. Tuttavia, sono state fatte alcune release, quindi come esempio il modello GPT2 rilasciato il modello da 1,6 miliardi, scusate, da 1,5 miliardi nel 2019 e questo modello GPT2 è un modello di base. Ora, cos'è una release di un modello? Come appare rilasciare questi modelli? Quindi questo è il repository GPT2 su GitHub. Bene, hai bisogno di due cose fondamentalmente per rilasciare un modello. Numero uno, abbiamo bisogno del codice Python, di solito che descrive la sequenza di operazioni in dettaglio che fanno nel loro modello. Quindi, se ricordate, questo Transformer, la sequenza di passi che vengono fatti qui in questa rete neurale è ciò che viene descritto da questo codice. Quindi questo codice sta in qualche modo implementando quello che viene chiamato il forward pass di questa rete neurale. Quindi abbiamo bisogno dei dettagli specifici di esattamente come hanno cablato quella rete neurale. Quindi questo è solo codice informatico ed è di solito solo un paio di centinaia di righe di codice, non è, non è così folle. E questo è tutto abbastanza comprensibile e di solito abbastanza standard. Ciò che non è standard sono i parametri, è lì che si trova il valore effettivo. Quali sono i parametri di questa rete neurale? Perché ce ne sono 1,6 miliardi e abbiamo bisogno dell'impostazione corretta o di un'impostazione davvero buona. Ed è per questo che, oltre a questo codice sorgente, rilasciano i parametri, che in questo caso sono circa 1,5 miliardi di parametri. E questi sono solo numeri, quindi è una singola lista di 1,5 miliardi di numeri. L'impostazione precisa e buona di tutte le manopole in modo che i token escano bene. Quindi, hai bisogno di queste due cose per ottenere una release di un modello di base. Ora GPT2 è stato rilasciato, ma in realtà è un modello piuttosto vecchio, come ho detto. Quindi, in realtà, il modello a cui ci rivolgeremo si chiama Llama 3 ed è quello che vorrei mostrarvi dopo. Quindi Llama 3, quindi GPT2, di nuovo, aveva 1,6 miliardi di parametri addestrati su 100 miliardi di token. Llama 3 è un modello molto più grande e un modello molto più moderno. È rilasciato e addestrato da Meta ed è un modello da 45 miliardi di parametri addestrato su 15 trilioni di token nello stesso modo, solo molto, molto più grande. E Meta ha anche fatto una release di Llama 3 e quella faceva parte di questo paper. Quindi con questo paper che entra in molti dettagli, il più grande modello di base che hanno rilasciato è il modello Llama 3.1 405 miliardi di parametri. Quindi questo è il modello di base e poi, oltre al modello di base, vedete qui un presagio per le sezioni successive del video, hanno anche rilasciato il modello instruct e instruct significa che questo è un assistente, puoi fargli domande e ti darà risposte. Dobbiamo ancora coprire quella parte più tardi. Per ora, diamo solo un'occhiata a questo modello di base, questo simulatore di token, e giochiamoci e proviamo a pensare a cosa sia questa cosa e come funzioni e cosa otteniamo alla fine di questa ottimizzazione se lo lasciamo andare fino alla fine per una rete neurale molto grande su molti dati. Quindi il mio posto preferito per interagire con i modelli di base è questa azienda chiamata Hyperbolic, che in pratica sta servendo il modello di base di Llama 3.1 da 405 miliardi. Quindi quando vai sul sito web e penso che potresti dover registrarti e così via, assicurati che nei modelli, assicurati che stai usando Llama 3.1 405 miliardi di base. Deve essere il modello di base. E poi qui, diciamo che i token massimi sono quanti token genereremo. Quindi riduciamolo un po' per non sprecare calcolo, vogliamo solo i prossimi 128 token e lasciamo stare il resto. Non entrerò nei dettagli completi qui. Ora, fondamentalmente, quello che succederà qui è identico a quello che succede qui durante l'inferenza per noi. Quindi questo continuerà semplicemente la sequenza di token di qualsiasi prefisso gli darai. Quindi voglio prima mostrarti che questo modello qui non è ancora un assistente. Quindi puoi, ad esempio, chiedergli quanto fa 2 più 2. Non ti dirà "Oh, fa quattro. Cos'altro posso fare per te?". Non lo farà, perché 2 più 2 verrà tokenizzato e poi quei token fungono solo da prefisso e poi quello che il modello farà ora è semplicemente ottenere la probabilità per il token successivo ed è solo un completamento automatico glorificato, è un completamento automatico molto, molto costoso di ciò che viene dopo, a seconda delle statistiche di ciò che ha visto nei suoi documenti di addestramento, che sono fondamentalmente pagine web. Quindi premiamo semplicemente invio per vedere quali token propone come continuazione. Ok, quindi qui in realtà ha risposto alla domanda e ha iniziato ad andare in un territorio filosofico. Proviamo di nuovo. Quindi copio e incollo e proviamo di nuovo da capo. Quanto fa 2 più 2? Quindi, ok, quindi va di nuovo fuori strada. Quindi nota un'altra cosa che voglio sottolineare è che il sistema, penso che ogni volta che lo inserisci, inizia da capo. Quindi non, il sistema qui è stocastico, quindi per lo stesso prefisso di token otteniamo sempre una risposta diversa e la ragione è che otteniamo questa distribuzione di probabilità e campioniamo da essa e otteniamo sempre campioni diversi e andiamo sempre in un territorio diverso in seguito. Quindi qui, in questo caso, non so cosa sia questo. Proviamo ancora una volta. Quindi continua. Quindi sta solo facendo le cose che ha visto su internet, giusto? E sta solo in qualche modo rigurgitando quei modelli statistici. Quindi, prima di tutto, non è ancora un assistente, è un completamento automatico di token e secondo, è un sistema stocastico. Ora, la cosa cruciale è che anche se questo modello non è ancora di per sé molto utile per molte applicazioni, è comunque molto utile perché nel compito di prevedere il token successivo nella sequenza, il modello ha imparato molto sul mondo e ha immagazzinato tutta quella conoscenza nei parametri della rete. Quindi ricordate che il nostro testo assomigliava a questo, giusto? Pagine web di internet e ora tutto questo è in qualche modo compresso nei pesi della rete. Quindi potete pensare a questi 405 miliardi di parametri come una sorta di compressione di internet. Potete pensare ai 45 miliardi di parametri come a un file zip, ma non è una compressione lossless, è una compressione lossy. Ci rimane una sorta di distillato di internet e possiamo generare da esso. Ora possiamo evocare parte di questa conoscenza suggerendo al modello di base di conseguenza. Quindi, ad esempio, ecco un prompt che potrebbe funzionare per evocare parte di quella conoscenza che si nasconde nei parametri. Ecco la mia lista dei primi 10 monumenti da vedere a Parigi. E lo sto facendo in questo modo perché sto cercando di preparare il modello a continuare questa lista. Vediamo se funziona quando premo invio. Ok, quindi vedete che ha iniziato una lista e ora mi sta dando alcuni di quei monumenti. E ora notate che sta cercando di dare molte informazioni qui. Ora, potresti non essere in grado di fidarti completamente di alcune delle informazioni qui. Ricordate che questo è solo un ricordo di alcuni documenti internet e quindi le cose che si verificano molto frequentemente nei dati di internet sono probabilmente più probabili che vengano ricordate correttamente rispetto alle cose che accadono molto raramente. Quindi non potete fidarvi completamente di alcune delle cose e di alcune delle informazioni che sono qui perché è solo un vago ricordo di documenti internet, perché le informazioni non sono memorizzate esplicitamente in nessuno dei parametri, è solo il ricordo. Detto questo, abbiamo ottenuto qualcosa che è probabilmente approssimativamente corretto e non ho l'esperienza per verificare che sia approssimativamente corretto, ma vedete che abbiamo evocato molta della conoscenza del modello e questa conoscenza non è precisa ed esatta, questa conoscenza è vaga, probabilistica e statistica e i tipi di cose che si verificano spesso sono i tipi di cose che è più probabile che vengano ricordate nel modello. Ora voglio mostrarvi alcuni altri esempi del comportamento di questo modello. La prima cosa che voglio mostrarvi è questo esempio. Sono andato alla pagina Wikipedia della zebra e copio e incollo la prima frase, anche solo una frase qui e la metto qui. Ora, quando clicco invio, che tipo di completamento otterremo? Quindi premo invio. Ci sono tre specie viventi, eccetera eccetera. Quello che il modello sta producendo qui è una rigurgitazione esatta di questa voce di Wikipedia. Sta recitando questa voce di Wikipedia puramente a memoria e questa memoria è memorizzata nei suoi parametri. Ed è quindi possibile che a un certo punto in questi 512 token il modello si discosti dalla voce di Wikipedia, ma potete vedere che ne ha memorizzato enormi pezzi. Vediamo, ad esempio, se questa frase si verifica ora. Ok, quindi siamo ancora in linea. Controlliamo qui. Ok, siamo ancora in linea. Alla fine si discosterà, ok. Quindi questa cosa è stata recitata in larga misura. Alla fine devierà, perché non sarà in grado di ricordare esattamente. Ora, la ragione per cui questo accade è che questi modelli possono essere estremamente bravi nella memorizzazione e di solito questo non è ciò che si vuole nel modello finale, ed è qualcosa chiamato rigurgitazione ed è di solito indesiderabile citare cose direttamente su cui ci si è addestrati. Ora, la ragione per cui questo accade in realtà è che per molti documenti, come ad esempio Wikipedia, quando questi documenti sono considerati di altissima qualità come fonte, come ad esempio Wikipedia, è molto spesso il caso che quando si addestra il modello, si campionerà preferenzialmente da quelle fonti. Quindi, fondamentalmente, il modello ha probabilmente fatto alcuni epoch su questi dati, il che significa che ha visto questa pagina web, forse probabilmente 10 volte o giù di lì, ed è un po' come te, quando leggi un testo molte, molte volte, diciamo che lo leggi 100 volte, allora sarai in grado di recitarlo. Ed è molto simile per questo modello, se vede qualcosa troppo spesso, sarà in grado di recitarlo in seguito a memoria, tranne che questi modelli possono essere molto più efficienti per presentazione rispetto agli umani. Quindi probabilmente ha visto questa voce di Wikipedia solo 10 volte, ma fondamentalmente ha ricordato questo articolo esattamente nei suoi parametri. Ok, la prossima cosa che voglio mostrarvi è qualcosa che il modello non ha assolutamente visto durante il suo addestramento. Quindi, ad esempio, se andiamo al paper e poi navighiamo nei dati di pre-addestramento, vedremo qui che il set di dati ha un limite di conoscenza fino alla fine del 2023, quindi non avrà visto documenti dopo questo punto e certamente non ha visto nulla sulle elezioni del 2024 e su come sono andate. Ora, se prepariamo il modello con i token dal futuro, continuerà la sequenza di token e farà semplicemente la sua migliore ipotesi in base alla conoscenza che ha nei suoi parametri. Quindi diamo un'occhiata a come potrebbe apparire. Quindi il Partito Repubblicano Trump, presidente degli Stati Uniti dal 2017, e vediamo cosa dice dopo questo punto. Quindi, ad esempio, il modello dovrà indovinare il compagno di corsa e contro chi corre, eccetera. Quindi premiamo invio. Quindi qui dice che Mike Pence era il compagno di corsa invece di JD Vance e la squadra ha corso contro Hillary Clinton e Tim Kane. Quindi questo è un interessante universo parallelo di ciò che sarebbe potuto accadere secondo l'LM. Otteniamo un campione diverso. Quindi lo stesso prompt e ricampioniamo. Quindi qui il compagno di corsa era Ronda Santis e hanno corso contro Joe Biden e Kamala Harris. Quindi questo è di nuovo un universo parallelo diverso. Quindi il modello farà delle ipotesi informate e continuerà la sequenza di token basandosi su questa conoscenza e farà semplicemente quello che stiamo vedendo qui, che è chiamato allucinazione. Il modello sta semplicemente facendo la sua migliore ipotesi in modo probabilistico. La prossima cosa che vorrei mostrarvi è che anche se questo è un modello di base e non ancora un modello assistente, può comunque essere utilizzato in applicazioni pratiche se siete intelligenti con il design del vostro prompt. Quindi ecco qualcosa che chiameremmo un prompt few-shot. Quello che è qui è che ho 10 parole o 10 coppie e ogni coppia è una parola inglese seguita dalla traduzione in coreano e ne abbiamo 10. E quello che fa il modello qui è alla fine abbiamo la colonna insegnante e poi qui è dove faremo un completamento di diciamo solo cinque token. E questi modelli hanno quelle che chiamiamo capacità di apprendimento in-context. E quello a cui si riferisce è che mentre legge questo contesto, sta imparando sul posto che c'è una sorta di schema algoritmico nei miei dati e sa come continuare quel pattern. E questo è chiamato apprendimento in-context. Quindi assume il ruolo di traduttore. E quando premiamo completamento, vediamo che la traduzione dell'insegnante è "sim", che è corretta. E quindi è così che potete costruire app essendo intelligenti con il vostro prompting, anche se abbiamo ancora solo un modello di base per ora e si basa su quella che chiamiamo questa capacità di apprendimento in-context ed è fatto costruendo quello che viene chiamato un prompt few-shot. E infine, voglio mostrarvi che c'è un modo intelligente per istanziare un intero assistente di modello linguistico semplicemente tramite prompting. E il trucco è che strutturiamo un prompt per assomigliare a una pagina web che è una conversazione tra un utile assistente AI e un umano. E poi il modello continuerà quella conversazione. Quindi, in realtà, per scrivere il prompt, mi sono rivolto a ChatGPT stesso, che è un po' meta, ma gli ho detto che voglio creare un assistente LLM, ma ho solo il modello di base. Quindi puoi per favore scrivere il mio prompt? E questo è quello che è venuto fuori, che in realtà è abbastanza buono. Quindi ecco una conversazione tra un assistente AI e un umano. L'assistente AI è competente, utile, capace di rispondere a un'ampia varietà di domande, eccetera. E poi qui non basta dargli una sorta di descrizione, funziona molto meglio se crei questo prompt fot. Quindi ecco alcuni termini di assistente umano, assistente umano e abbiamo alcuni turni di conversazione. E poi qui alla fine è dove metteremo la query effettiva che vogliamo. Quindi copio e incollo questo nel prompt del modello di base. E ora faccio "umano:" e qui mettiamo la nostra query effettiva. Perché il cielo è blu? E eseguiamo "assistente". Il cielo appare blu a causa del fenomeno chiamato diffusione della luce, eccetera eccetera. Quindi vedete che il modello di base sta solo continuando la sequenza, ma poiché la sequenza assomiglia a questa conversazione, assume quel ruolo. Ma è un po' sottile perché qui ha solo, sai, finisce l'assistente e poi semplicemente, sai, allucina la prossima domanda dell'umano, eccetera. Quindi continuerà all'infinito. Ma potete vedere che abbiamo in qualche modo raggiunto l'obiettivo. E se prendeste solo questo "Perché il cielo è blu?" e se lo rinfreschiamo e lo mettiamo qui, allora ovviamente non ci aspettiamo che funzioni con un modello di base, giusto? Otterremo solo, chissà cosa otterremo. Otterremo solo altre domande. Quindi questo è un modo per creare un assistente, anche se potresti avere solo un modello di base. Ok, quindi questo è il tipo di breve riassunto delle cose di cui abbiamo parlato negli ultimi minuti. Ora, allarghiamo la prospettiva qui e questo è un po' quello di cui abbiamo parlato finora. Vogliamo addestrare assistenti LLM come ChatGPT. Abbiamo discusso la prima fase di questo, che è la fase di pre-addestramento, e abbiamo visto che in realtà si riduce a questo: prendiamo documenti internet, li spezziamo in questi token, questi atomi di piccoli pezzi di testo, e poi prevediamo sequenze di token usando reti neurali. L'output di questa intera fase è questo modello di base. È l'impostazione dei parametri di questa rete. E questo modello di base è fondamentalmente un simulatore di documenti internet a livello di token. Quindi può semplicemente, può generare sequenze di token che hanno lo stesso tipo di statistiche dei documenti internet. E abbiamo visto che possiamo usarlo in alcune applicazioni, ma in realtà dobbiamo fare meglio. Vogliamo un assistente, vogliamo essere in grado di fare domande e vogliamo che il modello ci dia risposte. E quindi dobbiamo ora passare alla seconda fase, che si chiama fase di post-addestramento. Quindi prendiamo il nostro modello di base, il nostro simulatore di documenti internet, e lo passiamo al post-addestramento. Quindi ora discuteremo alcuni modi per fare quello che viene chiamato post-addestramento di questi modelli. Queste fasi di post-addestramento saranno computazionalmente molto meno costose. Tutto il lavoro computazionale massiccio, tutti i grandi data center e tutto il calcolo pesante e milioni di dollari sono la fase di pre-addestramento. Ma ora passiamo alla fase leggermente più economica, ma ancora estremamente importante, chiamata post-addestramento, dove trasformiamo questo modello LLM in un assistente. Quindi diamo un'occhiata a come possiamo far sì che il nostro modello non campioni documenti internet, ma dia risposte alle domande. In altre parole, quello che vogliamo fare è iniziare a pensare alle conversazioni. E queste sono conversazioni che possono essere multi-turno, quindi ci possono essere più turni e sono, nel caso più semplice, una conversazione tra un umano e un assistente. E quindi, ad esempio, possiamo immaginare che la conversazione possa assomigliare a questo: quando un umano dice "Quanto fa 2 più 2?", l'assistente dovrebbe rispondere con qualcosa come "2 più 2 fa 4". Quando un umano continua e dice "E se fosse per invece di più?", l'assistente potrebbe rispondere con qualcosa del genere. E simile qui. Questo è un altro esempio che mostra che l'assistente potrebbe anche avere una sorta di personalità qui, che è un po' gentile. E poi qui nel terzo esempio, sto mostrando che quando un umano chiede qualcosa con cui non vogliamo aiutare, possiamo produrre quello che viene chiamato un rifiuto. Possiamo dire che non possiamo aiutare con quello. In altre parole, quello che vogliamo fare ora è pensare a come un sistema dovrebbe interagire con un umano e vogliamo programmare l'assistente e il suo comportamento in queste conversazioni. Ora, poiché si tratta di reti neurali, non le programmeremo esplicitamente nel codice. Non saremo in grado di programmare l'assistente in quel modo, perché si tratta di reti neurali. Tutto viene fatto tramite l'addestramento di reti neurali su set di dati. E quindi, a causa di ciò, programmeremo implicitamente l'assistente creando set di dati di conversazioni. Quindi questi sono tre esempi indipendenti di conversazioni in un set di dati. E mostrerò esempi che saranno molto più grandi, potrebbero avere centinaia di migliaia di conversazioni, che sono multi-turno, molto lunghe, eccetera, e coprirebbero un'ampia gamma di argomenti. Ma qui mostro solo tre esempi. Ma il modo in cui funziona fondamentalmente è che un assistente viene programmato per esempio. E da dove provengono questi dati? Come 2 * 2 = 4, uguale a 2 + 2, eccetera. Da dove vengono? Questi provengono da etichettatori umani. Quindi daremo fondamentalmente agli etichettatori umani un po' di contesto conversazionale e chiederemo loro di dare la risposta ideale dell'assistente in questa situazione. E un umano scriverà la risposta ideale per un assistente in qualsiasi situazione. E poi faremo in modo che il modello si addestri su questo e imiti quel tipo di risposte. Quindi, il modo in cui funziona è che prenderemo il nostro modello di base che abbiamo prodotto nella fase di pre-addestramento, e questo modello di base è stato addestrato su documenti internet. Ora prenderemo quel set di dati di documenti internet e lo butteremo via e lo sostituiremo con un nuovo set di dati, e questo sarà un set di dati di conversazioni. E continueremo ad addestrare il modello su queste conversazioni, su questo nuovo set di dati di conversazioni. E quello che succede è che il modello si adeguerà molto rapidamente e imparerà le statistiche di come questo assistente risponde alle query umane. E poi più tardi, durante l'inferenza, saremo in grado fondamentalmente di preparare l'assistente e ottenere la risposta, e imiterà quello che gli umani avrebbero fatto in quella situazione, se ha senso. Quindi vedremo esempi di ciò e questo diventerà un po' più concreto. Volevo anche menzionare che questa fase di post-addestramento, continueremo semplicemente ad addestrare il modello, ma la fase di pre-addestramento può in pratica richiedere circa tre mesi di addestramento su molte migliaia di computer. La fase di post-addestramento sarà tipicamente molto più breve, come 3 ore, per esempio, e questo perché il set di dati di conversazioni che creeremo qui manualmente è molto, molto più piccolo del set di dati di testo su internet. E quindi questo addestramento sarà molto breve, ma fondamentalmente prenderemo il nostro modello di base, continueremo ad addestrare usando esattamente lo stesso algoritmo, esattamente lo stesso tutto, tranne che stiamo scambiando il set di dati con conversazioni. Quindi le domande ora sono: cosa sono queste conversazioni? Come le rappresentiamo? Come facciamo a far vedere al modello le conversazioni invece di semplice testo grezzo? E quali sono i risultati di questo tipo di addestramento? E cosa si ottiene in un certo senso psicologico quando parliamo del modello? Quindi passiamo a quelle domande ora. Iniziamo parlando della tokenizzazione delle conversazioni. Tutto in questi modelli deve essere trasformato in token perché tutto riguarda le sequenze di token. Quindi come trasformiamo le conversazioni in sequenze di token è la domanda. E per questo, dobbiamo progettare un qualche tipo di codifica. E questo è un po' simile, forse se avete familiarità, non dovete esserlo, con ad esempio il pacchetto TCP/IP su internet. Ci sono regole e protocolli precisi su come rappresentare le informazioni, come tutto è strutturato insieme in modo che abbiate tutti questi dati disposti in un modo che sia scritto su carta e su cui tutti possano essere d'accordo. Ed è la stessa cosa che sta succedendo ora negli LLM. Abbiamo bisogno di alcuni tipi di strutture dati e abbiamo bisogno di avere regole su come queste strutture dati, come le conversazioni, vengono codificate e decodificate da e verso i token. E quindi voglio mostrarvi ora come ricreerei questa conversazione nello spazio dei token. Quindi se andate su tokenizer, posso prendere quella conversazione e questo è come è rappresentata per il modello linguistico. Quindi qui abbiamo, stiamo iterando un utente e un assistente in questa conversazione a due turni. E quello che vedete qui, sembra brutto, ma in realtà è relativamente semplice. Il modo in cui viene trasformato in una sequenza di token alla fine è un po' complicato, ma alla fine questa conversazione tra un utente e un assistente finisce per essere 49 token. È una sequenza unidimensionale di 49 token e questi sono i token. E tutti i diversi LLM avranno un formato o protocolli leggermente diversi, ed è un po' un far west in questo momento. Ma ad esempio, GPT-4o lo fa nel seguente modo: avete questo token speciale chiamato IM start, ed è l'abbreviazione di IM imaginary monologue, start. Poi dovete specificare, non so davvero perché si chiama così, ad essere onesti. Poi dovete specificare di chi è il turno, quindi ad esempio user, che è il token 428, poi avete un separatore di monologo interno, e poi è la domanda esatta, quindi i token della domanda, e poi dovete chiuderlo, quindi IM end, la fine del monologo immaginario. Quindi fondamentalmente la domanda di un utente "Quanto fa 2 più 2?" si traduce nella sequenza di token di questi token. E ora la cosa importante da menzionare qui è che IM start, questo non è testo, giusto? IM start è un token speciale che viene aggiunto, è un nuovo token e questo token non è mai stato addestrato finora. È un nuovo token che creiamo in una fase di post-addestramento e introduciamo. E quindi questi token speciali come IM seep, IM start, eccetera, vengono introdotti e intervallati con testo in modo che in qualche modo facciano capire al modello che questo è l'inizio di un turno per chi è, l'inizio del turno è per l'utente, e poi questo è ciò che dice l'utente, e poi l'utente finisce, e poi è un nuovo inizio di turno, ed è dell'assistente, e poi cosa dice l'assistente? Bene, questi sono i token di ciò che dice l'assistente, eccetera. E quindi questa conversazione non viene trasformata nella sequenza di token. I dettagli specifici qui non sono in realtà così importanti. Tutto quello che sto cercando di mostrarvi in termini concreti è che le nostre conversazioni, che pensiamo come una sorta di oggetto strutturato, finiscono per essere trasformate tramite una qualche codifica in sequenze unidimensionali di token. E quindi, poiché questa è una sequenza unidimensionale di token, possiamo applicare tutto ciò che abbiamo già applicato. Ora è solo una sequenza di token e ora possiamo addestrare un modello linguistico su di essa. E quindi stiamo solo prevedendo il token successivo in una sequenza, proprio come prima. E possiamo rappresentare e addestrare su conversazioni. E poi come appare al momento del test, durante l'inferenza? Diciamo che abbiamo addestrato un modello e abbiamo addestrato un modello su questi tipi di set di dati di conversazioni, e ora vogliamo fare inferenza. Quindi durante l'inferenza, come appare quando sei su ChatGPT? Bene, vieni su ChatGPT e hai, diciamo, un dialogo con esso. E il modo in cui funziona fondamentalmente è, diciamo che questo era già compilato, quindi come "Quanto fa 2 più 2? 2 più 2 fa 4". E ora emetti "E se fosse per? IM end". E quello che fondamentalmente succede sui server di OpenAI o qualcosa del genere è che mettono "I start assistant IMep" e questo è dove lo finiscono proprio qui. Quindi costruiscono questo contesto e poi iniziano a campionare dal modello. Quindi è in questa fase che vanno dal modello e dicono "Ok, qual è una buona sequenza, qual è un buon primo token, qual è un buon secondo token, qual è un buon terzo token?". E qui entra in gioco l'LLM e crea una risposta come, ad esempio, una risposta che assomiglia a questa. Ma non deve essere identica a questa, ma avrà il sapore di questa se questo tipo di conversazione era nei dati. Quindi, questo è più o meno come funziona il protocollo, anche se i dettagli di questo protocollo non sono importanti. Quindi, di nuovo, il mio obiettivo è solo mostrarvi che tutto finisce per essere solo una sequenza di token unidimensionale, quindi possiamo applicare tutto ciò che abbiamo già visto. Ma ora stiamo addestrando su conversazioni e ora stiamo fondamentalmente generando conversazioni. Ok, ora vorrei passare a come sono questi set di dati in pratica. Il primo paper che vorrei mostrarvi e il primo sforzo in questa direzione è questo paper di OpenAI nel 2022, e questo paper si chiamava InstructGPT o la tecnica che hanno sviluppato. Ed è stata la prima volta che OpenAI ha parlato di come si possono prendere i modelli linguistici e affinarli su conversazioni. E quindi questo paper ha una serie di dettagli che vorrei esaminare. Quindi la prima tappa che vorrei fare è nella sezione 3.4, dove parlano degli appaltatori umani che hanno assunto, in questo caso da Upwork o tramite Scale AI, per costruire queste conversazioni. E quindi ci sono etichettatori umani coinvolti il cui lavoro è professionalmente creare queste conversazioni. E a questi etichettatori viene chiesto di proporre prompt e poi viene chiesto loro anche di completare le risposte ideali dell'assistente. E quindi questi sono i tipi di prompt che le persone hanno proposto. Quindi questi sono etichettatori umani. Elenca cinque idee su come ritrovare l'entusiasmo per la mia carriera. Quali sono i primi 10 libri di fantascienza che dovrei leggere dopo? E ci sono molti tipi diversi di prompt qui. Quindi traduci questa frase da... in spagnolo, eccetera. E quindi ci sono molte cose qui che le persone hanno proposto. Prima propongono il prompt e poi rispondono anche a quel prompt e danno la risposta ideale dell'assistente. Ora, come sanno qual è la risposta ideale dell'assistente che dovrebbero scrivere per questi prompt? Quindi, scorrendo un po' più avanti, vediamo che qui abbiamo questo estratto di istruzioni di etichettatura che vengono date agli etichettatori umani. Quindi l'azienda che sta sviluppando il modello linguistico, come ad esempio OpenAI, scrive istruzioni di etichettatura su come gli umani dovrebbero creare risposte ideali. E quindi qui, ad esempio, c'è un estratto di questi tipi di istruzioni di etichettatura. Ad alto livello, si chiede alle persone di essere utili, veritiere e innocue. E potete mettere in pausa il video se volete vedere di più. Ma ad alto livello, fondamentalmente, rispondete, cercate di essere utili, cercate di essere veritieri e non rispondete a domande che non vogliamo che il sistema gestisca in seguito in ChatGPT. E quindi, grosso modo, l'azienda crea le istruzioni di etichettatura. Di solito non sono così brevi, di solito sono centinaia di pagine e le persone devono studiarle professionalmente e poi scrivono le risposte ideali dell'assistente seguendo quelle istruzioni di etichettatura. Quindi questo è un processo molto umano, come è stato descritto in questo paper. Ora, il set di dati per InstructGPT non è mai stato effettivamente rilasciato da OpenAI, ma abbiamo alcune riproduzioni open-source che stanno cercando di seguire questo tipo di impostazione e raccogliere i propri dati. Quindi uno che conosco, ad esempio, è lo sforzo di Open Assistant di un po' di tempo fa. E questo è solo uno dei tanti esempi, credo, ma voglio solo mostrarvi un esempio. Quindi ecco, queste erano persone su internet a cui è stato chiesto di creare fondamentalmente queste conversazioni, simili a quello che OpenAI ha fatto con gli etichettatori umani. E quindi ecco una voce di una persona che ha proposto questo: "Puoi scrivere una breve introduzione alla rilevanza del termine manop in economia? Per favore, usa esempi, eccetera". E poi la stessa persona o potenzialmente una persona diversa scriverà la risposta. Quindi ecco la risposta dell'assistente a questo. E poi la stessa persona o una persona diversa scriverà questa risposta ideale. E poi questo è un esempio di come potrebbe continuare la conversazione: "Ora spiegalo a un cane". E poi puoi provare a trovare una spiegazione leggermente più semplice o qualcosa del genere. Questo diventa quindi l'etichetta e ci addestriamo su questo. Quindi, quello che succede durante l'addestramento è che, naturalmente, non avremo una copertura completa di tutte le possibili domande che il modello incontrerà al momento del test durante l'inferenza. Non possiamo coprire tutti i possibili prompt che le persone chiederanno in futuro. Ma se abbiamo un set di dati di alcuni di questi esempi, allora il modello durante l'addestramento inizierà ad assumere questa persona di questo assistente utile, veritiero e innocuo. Ed è tutto programmato per esempio. E quindi questi sono tutti esempi di comportamento. E se avete conversazioni di questi comportamenti d'esempio e ne avete abbastanza, come 100.000, e vi addestrate su di esso, il modello inizia a capire il modello statistico e assume questa personalità di questo assistente. Ora, è possibile che quando si ottiene esattamente la stessa domanda, come questa, al momento del test, è possibile che la risposta venga recitata esattamente come era nel set di addestramento. Ma più probabilmente è che il modello farà qualcosa di simile. E capiremo che questo è il tipo di risposta che si desidera. Quindi è quello che stiamo facendo, stiamo programmando il sistema per esempio. E il sistema adotta statisticamente questa persona di questo assistente utile, veritiero e innocuo, che è un po' come riflesso nelle istruzioni di etichettatura che l'azienda crea. Ora voglio mostrarvi che lo stato dell'arte è avanzato negli ultimi 2 o 3 anni da quando è uscito il paper InstructGPT. Quindi, in particolare, non è molto comune che gli umani facciano tutto il lavoro pesante da soli. E questo perché ora abbiamo modelli linguistici e questi modelli linguistici ci aiutano a creare questi set di dati e conversazioni. Quindi è molto raro che le persone scrivano letteralmente la risposta da zero. È molto più probabile che utilizzino un LLM esistente per creare una risposta e poi la modifichino o cose del genere. Quindi ci sono molti modi diversi in cui ora gli LLM hanno iniziato a permeare questo stack di post-addestramento. E gli LLM vengono utilizzati in modo pervasivo per aiutare a creare questi enormi set di dati di conversazioni. Quindi non voglio mostrare UltraChat, è un esempio di un set di dati di conversazioni più moderno. È in gran parte sintetico, ma credo che ci sia un po' di coinvolgimento umano. Potrei sbagliarmi, ma di solito ci sarà un po' di coinvolgimento umano, ma ci sarà un'enorme quantità di aiuto sintetico. E tutto questo è in qualche modo costruito in modi diversi. E UltraChat è solo un esempio di molti set di dati SFT che esistono attualmente. E l'unica cosa che voglio mostrarvi è che questi set di dati ora hanno milioni di conversazioni. Queste conversazioni sono per lo più sintetiche, ma sono probabilmente modificate in una certa misura dagli umani e coprono un'enorme diversità di aree, eccetera. Quindi questi sono artefatti abbastanza estesi ormai e ci sono tutte queste miscele SFT, come vengono chiamate. Quindi avete una miscela di molti tipi e fonti diversi, ed è parzialmente sintetico, parzialmente umano, ed è andato in quella direzione da allora. Ma grosso modo, abbiamo ancora set di dati SFT, sono composti da conversazioni, ci stiamo addestrando su di essi, proprio come abbiamo fatto prima. E immagino che l'ultima cosa da notare sia che voglio dissipare un po' della magia del parlare con un'IA. Come quando vai su ChatGPT e gli fai una domanda e poi premi invio, quello che torna indietro è in qualche modo statisticamente allineato con quello che succede nel set di addestramento. E questi set di addestramento, intendo, hanno davvero un seme negli umani che seguono le istruzioni di etichettatura. Quindi, con cosa stai effettivamente parlando in ChatGPT, o come dovresti pensarci? Bene, non proviene da qualche IA magica. Grosso modo, proviene da qualcosa che sta statisticamente imitando gli etichettatori umani, che proviene da istruzioni di etichettatura scritte da queste aziende. E quindi stai in qualche modo imitando questo. Stai in qualche modo ottenendo, è quasi come se stessi chiedendo a un etichettatore umano. E immagina che la risposta che ti viene data da ChatGPT sia una sorta di simulazione di un etichettatore umano. Ed è un po' come chiedere "Cosa direbbe un etichettatore umano in questo tipo di conversazione?". E questo etichettatore umano non è solo una persona a caso da internet, perché queste aziende assumono esperti. Quindi, ad esempio, quando fai domande sul codice e così via, gli etichettatori umani che sarebbero coinvolti nella creazione di questi set di dati di conversazione, di solito saranno persone esperte e istruite. E stai in qualche modo chiedendo una domanda a una simulazione di quelle persone, se ha senso. Quindi non stai parlando con un'IA magica, stai parlando con un etichettatore medio. Questo etichettatore medio è probabilmente abbastanza qualificato, ma stai parlando con una sorta di simulazione istantanea di quel tipo di persona che verrebbe assunta nella costruzione di questi set di dati. Quindi, vi darò un altro esempio specifico prima di passare oltre. Ad esempio, quando vado su ChatGPT e dico "Raccomanda i primi cinque monumenti da vedere a Parigi" e poi premo invio, ok, eccoci qui. Ok, quando premo invio, cosa esce qui? Come ci penso? Bene, non è una sorta di IA magica che è andata a ricercare tutti i monumenti e poi li ha classificati usando la sua intelligenza infinita, eccetera. Quello che sto ottenendo è una simulazione statistica di un etichettatore che è stato assunto da OpenAI. Potete pensarci grosso modo in quel modo. E quindi, se questa specifica domanda è nel set di dati di post-addestramento da qualche parte in OpenAI, allora è molto probabile che vedrò una risposta che è probabilmente molto, molto simile a ciò che quell'etichettatore umano avrebbe messo per quei cinque monumenti. Come fa l'etichettatore umano a trovarlo? Bene, va su internet e fa la sua piccola ricerca per 20 minuti e propone una lista. Ora, se propone questa lista e questa è nel set di dati, è molto probabile che vedrò quello che hanno presentato come risposta corretta dall'assistente. Ora, se questa specifica query non fa parte del set di dati di post-addestramento, allora quello che sto ottenendo qui è un po' più emergente, perché il modello capisce statisticamente i tipi di monumenti che sono in questo set di addestramento sono solitamente i monumenti più importanti, i monumenti che le persone di solito vogliono vedere, i tipi di monumenti di cui si parla solitamente molto spesso su internet. E ricordate che il modello ha già un sacco di conoscenza dal suo pre-addestramento su internet. Quindi probabilmente ha visto un sacco di conversazioni su Parigi, sui monumenti, sulle cose che piacciono alle persone. E quindi è la conoscenza del pre-addestramento che si è poi combinata con il set di dati di post-addestramento che si traduce in questo tipo di imitazione. Quindi, questo è più o meno come potete pensare a ciò che sta succedendo dietro le quinte qui in senso statistico. Ok, ora voglio passare all'argomento della psicologia degli LLM, come mi piace chiamarla, che sono quali sono gli effetti cognitivi emergenti della pipeline di addestramento che abbiamo per questi modelli. Quindi, in particolare, il primo di cui voglio parlare sono, ovviamente, le allucinazioni. Quindi potreste avere familiarità con le allucinazioni dei modelli, è quando gli LLM inventano cose, fabbricano completamente informazioni, eccetera. Ed è un grosso problema con gli assistenti LLM. È un problema che esisteva in larga misura con i primi modelli di molti anni fa. E penso che il problema sia migliorato un po' perché ci sono alcune medicazioni che spiegherò tra un attimo. Per ora, cerchiamo solo di capire da dove provengono queste allucinazioni. Quindi ecco un esempio specifico di alcune, di tre conversazioni che potreste pensare di avere nel vostro set di addestramento. E queste sono conversazioni piuttosto ragionevoli che potreste immaginare essere nel set di addestramento. Quindi, ad esempio, chi è Cruise? Bene, Tom Cruise è un famoso attore, attore e produttore americano, eccetera. Chi è John Barroso? Si scopre che è un senatore degli Stati Uniti, per esempio. Chi è Gengis Khan? Bene, Gengis Khan era, bla bla bla. E quindi è così che potrebbero apparire le vostre conversazioni al momento dell'addestramento. Ora, il problema è che quando l'umano sta scrivendo la risposta corretta per l'assistente in ognuno di questi casi, l'umano o sa chi è questa persona, o la ricerca su internet e arriva e scrive questa risposta che ha questo tono di risposta sicuro. E quello che succede fondamentalmente è che al momento del test, quando chiedi di qualcuno che è, questo è un nome totalmente casuale che ho inventato e non credo che questa persona esista, per quanto ne so, ho solo cercato di generarlo casualmente. Il problema è che quando chiediamo "Chi è Orson Kovats?", il problema è che l'assistente non ti dirà semplicemente "Oh, non lo so", anche se l'assistente e il modello linguistico stesso potrebbero saperlo all'interno delle sue caratteristiche, all'interno delle sue attivazioni, all'interno del suo cervello, in qualche modo, potrebbe sapere che questa persona non è qualcuno con cui ha familiarità, anche se una parte della rete in qualche modo lo sa, nel senso che dire "Oh, non so chi sia questo" non accadrà perché il modello imita statisticamente il suo set di addestramento. Nel set di addestramento, le domande del tipo "Chi è...?" vengono risposte con sicurezza con la risposta corretta. E quindi assumerà lo stile della risposta e farà del suo meglio, ti darà la congettura statisticamente più probabile e fondamentalmente inventerà cose, perché questi modelli, di nuovo, ne abbiamo appena parlato, non hanno accesso a internet, non stanno facendo ricerche, sono tumbler di token statistici, come li chiamo io, stanno solo cercando di campionare il token successivo nella sequenza e fondamentalmente inventeranno cose. Quindi diamo un'occhiata a come appare. Ho qui quello che viene chiamato l'inference playground di Hugging Face, e sto deliberatamente prendendo di mira un modello chiamato Falcon 7B, che è un vecchio modello, è di qualche anno fa ormai, quindi è un modello più vecchio, quindi soffre di allucinazioni. E come ho detto, questo è migliorato nel tempo di recente. Ma diciamo "Chi è Orson Kovats?". Chiediamo a Falcon 7B Instruct. Esegui. Oh sì, Orson Kovats è un autore americano e scrittore di fantascienza. Ok, questo è totalmente falso, è un'allucinazione. Proviamo di nuovo. Questi sono sistemi statistici, giusto? Quindi possiamo ricampionare. Questa volta, Orson Kovats è un personaggio fittizio di questo show televisivo degli anni '50. È una totale sciocchezza, giusto? Proviamo di nuovo. È un ex giocatore di baseball di lega minore. Ok, fondamentalmente il modello non lo sa e ci ha dato molte risposte diverse perché non lo sa, sta solo campionando da queste probabilità. Il modello inizia con i token "Chi è Orson Kovats? Assistente", e poi entra qui e ottiene queste probabilità e sta solo campionando dalle probabilità e tira fuori cose. E le cose sono in realtà statisticamente coerenti con lo stile della risposta nel suo set di addestramento, e sta solo facendo quello, ma tu e io lo sperimentiamo come conoscenza fattuale inventata. Ma tieni presente che il modello fondamentalmente non lo sa e sta solo imitando il formato della risposta e non andrà a cercarlo, perché sta solo imitando di nuovo la risposta. Quindi, come possiamo mitigare questo? Perché, ad esempio, quando andiamo su ChatGPT e dico "Chi è Orson Kovats?" e ora sto chiedendo al modello all'avanguardia di OpenAI. Questo modello ti dirà "Oh, quindi questo modello è ancora più intelligente perché hai visto molto brevemente che diceva 'ricerca sul web'. Lo copriremo più tardi. In realtà sta cercando di usare strumenti e ha appena inventato una sorta di storia. Ma voglio solo, Orson Kovats non ha usato strumenti, non voglio che faccia ricerche sul web. C'è una figura storica o pubblica ben nota di nome Orson Kovats. Quindi questo modello non inventerà.

cose che questo modello sa che non sa e ti dice che non sembra essere una persona che questo modello conosce, quindi in qualche modo abbiamo migliorato le allucinazioni anche se sono chiaramente un problema nei modelli più vecchi e ha perfettamente senso perché otterresti questi tipi di risposte se questo è ciò che il tuo set di addestramento assomiglia, quindi come risolviamo questo problema? Ok, chiaramente abbiamo bisogno di alcuni esempi nel nostro set di dati in cui la risposta corretta per l'assistente è che il modello non conosce un particolare fatto, ma dobbiamo solo avere quelle risposte prodotte nei casi in cui il modello effettivamente non lo sa e quindi la domanda è come sappiamo cosa il modello sa o non sa? Bene, possiamo sondare empiricamente il modello per scoprirlo, quindi diamo un'occhiata, ad esempio, a come Meta ha gestito le allucinazioni per la serie di modelli Llama 3 come esempio, quindi in questo articolo che hanno pubblicato da Meta possiamo entrare nelle allucinazioni che qui chiamano fattualità e descrivono la procedura con cui fondamentalmente interrogano il modello per scoprire cosa sa e cosa non sa per scoprire il confine della sua conoscenza e poi aggiungono esempi al set di addestramento in cui per le cose che il modello non conosce la risposta corretta è che il modello non le conosce, il che sembra una cosa molto facile da fare in linea di principio, ma questo risolve approssimativamente il problema e il motivo per cui risolve il problema è perché ricorda che il modello potrebbe effettivamente avere un buon modello della sua conoscenza di sé all'interno della rete, quindi ricorda che abbiamo guardato la rete e tutti questi neuroni all'interno della rete potresti immaginare che ci sia un neurone da qualche parte nella rete che si accende quando il modello è incerto, ma il problema è che l'attivazione di quel neurone non è attualmente collegata al modello che dice effettivamente a parole che non lo sa, quindi anche se l'interno della rete neurale lo sa perché ci sono alcuni neuroni che rappresentano che il modello non lo presenterà, invece prenderà la sua migliore ipotesi in modo che sembri sicuro, proprio come vede in un set di addestramento, quindi dobbiamo fondamentalmente interrogare il modello e permettergli di dire non lo so nei casi in cui non lo sa, quindi lasciami guidarti attraverso ciò che Meta fa approssimativamente, quindi fondamentalmente quello che fanno è qui ho un esempio, Dominic Hasek è l'articolo in primo piano oggi, quindi ci sono andato casualmente e quello che fanno è fondamentalmente prendono un documento casuale in un set di addestramento e prendono un paragrafo e poi usano un LLM per costruire domande su quel paragrafo, quindi ad esempio l'ho fatto con ChatGPT qui, quindi ho detto ecco un paragrafo da questo documento, genera tre domande fattuali specifiche basate su questo paragrafo e dammi le domande e le risposte e quindi gli LLM sono già abbastanza bravi da creare e riformulare queste informazioni, quindi se le informazioni sono nella finestra di contesto di questo LLM, questo funziona abbastanza bene, non deve fare affidamento sulla sua memoria, è proprio lì nella finestra di contesto e quindi può fondamentalmente riformulare quelle informazioni con una precisione abbastanza elevata, quindi ad esempio può generare domande per noi come per quale squadra ha giocato, ecco la risposta, quante coppe ha vinto, eccetera, e ora quello che dobbiamo fare è che abbiamo alcune domande e risposte e ora vogliamo interrogare il modello, quindi parlando approssimativamente quello che faremo è prendere le nostre domande e andare al nostro modello che sarebbe, diciamo, Llama in Meta, ma interroghiamo solo Mol 7B qui come esempio, che è un altro modello, quindi questo modello sa di questa risposta? Diamo un'occhiata, quindi ha giocato per i Buffalo Sabers, giusto, quindi il modello lo sa e il modo in cui puoi deciderlo programmaticamente è fondamentalmente prenderemo questa risposta dal modello e la confronteremo con la risposta corretta e di nuovo i modelli sono abbastanza bravi da farlo automaticamente, quindi non ci sono umani coinvolti qui, possiamo prendere fondamentalmente la risposta dal modello e possiamo usare un altro giudice LLM per verificare se è corretta secondo questa risposta e se è corretta significa che il modello probabilmente lo sa, quindi quello che faremo è farlo forse un paio di volte, quindi ok, lo sa, sono i Buffalo Sabers, trasciniamo i Buffalo Sabers, proviamo ancora una volta, Buffalo Sabers, quindi abbiamo chiesto tre volte su questa domanda fattuale e il modello sembra saperlo, quindi tutto è fantastico, ora proviamo la seconda domanda, quante Stanley Cup ha vinto e di nuovo interroghiamo il modello su questo e la risposta corretta è due, quindi qui il modello afferma di aver vinto quattro volte, il che non è corretto, giusto, non corrisponde a due, quindi il modello non lo sa, sta inventando le cose, proviamo ancora, quindi qui il modello di nuovo, è un po' come inventare le cose, trasciniamolo qui, dice che non ha nemmeno vinto durante la sua carriera, quindi ovviamente il modello non lo sa e il modo in cui possiamo dirlo programmaticamente di nuovo è che interroghiamo il modello tre volte e confrontiamo le sue risposte, forse tre volte, cinque volte, qualunque sia, con la risposta corretta e se il modello non lo sa, allora sappiamo che il modello non conosce questa domanda e poi quello che facciamo è prendere questa domanda, creiamo una nuova conversazione nel set di addestramento, quindi aggiungeremo un nuovo set di addestramento di conversazione e quando la domanda è quante Stanley Cup ha vinto la risposta è mi dispiace, non lo so o non ricordo, e quella è la risposta corretta per questa domanda perché abbiamo interrogato il modello e abbiamo visto che è così, se fai questo per molti diversi tipi di domande per molti diversi tipi di documenti, stai dando al modello un'opportunità nel suo set di addestramento di rifiutarsi di dire basandosi sulla sua conoscenza e se hai solo alcuni esempi di ciò nel tuo set di addestramento, il modello saprà e avrà l'opportunità di imparare l'associazione di questo rifiuto basato sulla conoscenza a questo neurone interno da qualche parte nella sua rete che presumiamo esista e empiricamente questo si rivela essere probabilmente il caso e può imparare quell'associazione che ehi, quando questo neurone di incertezza è alto, allora in realtà non lo so e mi è permesso dirlo, mi dispiace, ma non credo di ricordarlo, eccetera, e se hai questi esempi nel tuo set di addestramento, questa è una grande mitigazione per le allucinazioni e questo è approssimativamente il motivo per cui ChatGPT è in grado di fare cose del genere, quindi questi sono tipi di mitigazioni che le persone hanno implementato e che hanno migliorato il problema della fattualità nel tempo, ok, ho descritto la mitigazione numero uno per mitigare fondamentalmente il problema delle allucinazioni, ora possiamo fare molto meglio di così, invece di dire solo che non lo sappiamo, possiamo introdurre una mitigazione aggiuntiva numero due per dare all'LLM un'opportunità di essere fattuale e rispondere effettivamente alla domanda, ora cosa fai tu e io se ti chiedessi una domanda fattuale e tu non lo sapessi, cosa faresti per rispondere alla domanda? Beh, potresti andare a fare qualche ricerca e usare internet e potresti scoprire la risposta e poi dirmi qual è quella risposta e possiamo fare esattamente la stessa cosa con questi modelli, quindi pensa alla conoscenza all'interno della rete neurale all'interno dei suoi miliardi di parametri, pensa a quella come una vaga reminiscenza delle cose che il modello ha visto durante il suo addestramento durante la fase di pre-addestramento molto tempo fa, quindi pensa a quella conoscenza nei parametri come qualcosa che hai letto un mese fa e se continui a leggere qualcosa, te la ricorderai e il modello se la ricorda, ma se è qualcosa di raro, probabilmente non hai un buon ricordo di quelle informazioni, ma quello che fai tu e io è che andiamo a cercarlo ora, quando vai a cercarlo, quello che stai facendo fondamentalmente è come rinfrescare la tua memoria di lavoro con le informazioni e poi sei in grado di recuperarla, parlarne o eccetera, quindi abbiamo bisogno di un equivalente per permettere al modello di rinfrescare la sua memoria o il suo ricordo e possiamo farlo introducendo strumenti per i modelli, quindi il modo in cui approcceremo questo è che invece di dire solo ehi, mi dispiace, non lo so, possiamo tentare di usare strumenti, quindi possiamo creare un meccanismo con cui il modello linguistico può emettere token speciali e questi sono token che introdurremo nuovi token, quindi ad esempio qui ho introdotto due token e ho introdotto un formato o un protocollo su come il modello è autorizzato a utilizzare questi token, quindi ad esempio invece di rispondere alla domanda quando il modello non lo fa, invece di dire solo mi dispiace, non lo so, il modello ha ora l'opzione di emettere il token speciale search start e questa è la query che andrà su bing.com nel caso di OpenAI o Google Search o qualcosa del genere, quindi emetterà la query e poi emetterà search end e poi qui quello che succederà è che il programma che sta campionando dal modello, che sta eseguendo l'inferenza, quando vede il token speciale search end, invece di campionare il token successivo nella sequenza, si fermerà a generare dal modello, andrà ad aprire una sessione con bing.com e incollerà la query di ricerca su Bing e poi otterrà tutto il testo recuperato e fondamentalmente prenderà quel testo, forse lo rappresenterà di nuovo con altri token speciali o qualcosa del genere, e prenderà quel testo e lo copierà e incollerà qui in quello che ho cercato di mostrare con le parentesi, quindi tutto quel testo arriva qui e quando il testo arriva qui, entra nella finestra di contesto, quindi il modello, quindi quel testo dalla ricerca web è ora all'interno della finestra di contesto che alimenterà la rete neurale e dovresti pensare alla finestra di contesto come alla memoria di lavoro del modello, quei dati che sono nella finestra di contesto sono direttamente accessibili dal modello, alimentano direttamente la rete neurale, quindi non è più una vaga reminiscenza, sono dati che ha nella finestra di contesto e sono direttamente disponibili a quel modello, quindi ora quando sta campionando i nuovi token qui dopo, può fare facilmente riferimento ai dati che sono stati copiati e incollati lì, quindi è così che funzionano questi strumenti e la ricerca web è solo uno degli strumenti che esamineremo tra un po', ma fondamentalmente introduci nuovi token, introduci uno schema con cui il modello può utilizzare questi token e può chiamare queste funzioni speciali come le funzioni di ricerca web, e come insegni al modello come usare correttamente questi strumenti come search start, search end, eccetera? Beh, di nuovo, lo fai attraverso i set di addestramento, quindi ora abbiamo bisogno di un sacco di dati e un sacco di conversazioni che mostrano al modello per esempio come usare la ricerca web, quindi quali sono le impostazioni in cui stai usando la ricerca e come appare? E ecco un esempio di come avviare una ricerca e la ricerca, eccetera, e se hai qualche migliaio di esempi di questo nel tuo set di addestramento, il modello farà un buon lavoro nel capire come funziona questo strumento e saprà come strutturare le sue query e ovviamente a causa del set di dati di pre-addestramento e della sua comprensione del mondo, in realtà capisce cos'è una ricerca web e quindi ha una buona comprensione nativa di che tipo di cose è una buona query di ricerca e quindi funziona tutto, hai solo bisogno di alcuni esempi per mostrargli come usare questo nuovo strumento e poi può appoggiarsi ad esso per recuperare informazioni e metterle nella finestra di contesto, ed è l'equivalente di te e io che cerchiamo qualcosa, perché una volta che è nella finestra di contesto, è nella memoria di lavoro ed è molto facile da manipolare e accedere, quindi è quello che abbiamo visto qualche minuto fa quando stavo cercando su ChatGPT chi è Orson Kovacs, il modello linguistico di ChatGPT ha deciso che si tratta di una specie di individuo raro o qualcosa del genere e invece di darmi una risposta dalla sua memoria, ha deciso che campionerà un token speciale che farà una ricerca web e abbiamo visto brevemente qualcosa lampeggiare, era come usare lo strumento web o qualcosa del genere, quindi lo ha detto brevemente, poi abbiamo aspettato circa due secondi e poi ha generato questo e vedi come crea riferimenti qui e quindi cita le fonti, quindi quello che è successo qui è che è andato, ha fatto una ricerca web, ha trovato queste fonti e questi URL e il testo di queste pagine web è stato tutto inserito qui e non viene mostrato qui, ma è fondamentalmente inserito come testo qui e ora vede quel testo e ora lo cita e dice che potrebbero essere queste persone, la citazione potrebbe essere quelle persone, la citazione, eccetera, quindi è quello che è successo qui ed è per questo che quando ho detto chi è Orson Kovacs, ho anche potuto dire non usare nessuno strumento e questo è sufficiente per convincere ChatGPT a non usare strumenti e usare solo la sua memoria e il suo ricordo, ho anche provato a chiedere a ChatGPT questa domanda, quindi quante Stanley Cup ha vinto Dominic Hasek e ChatGPT ha deciso che conosce la risposta e ha la sicurezza di dire che ha vinto due volte e quindi si è semplicemente basato sulla sua memoria perché presumibilmente ha abbastanza sicurezza nei suoi pesi nei suoi parametri e nelle sue attivazioni che questo è recuperabile solo dalla memoria, ma puoi anche usare la ricerca web per assicurarti e quindi per la stessa query va effettivamente a cercare e poi trova un sacco di fonti, trova tutto questo, tutto questo viene copiato e incollato lì, e poi ci dice di nuovo e cita e in realtà dice l'articolo di Wikipedia che è la fonte di queste informazioni anche per noi, quindi questo sono gli strumenti, la ricerca web, il modello determina quando cercare, e quindi è così che funzionano questi strumenti ed è un'ulteriore mitigazione per le allucinazioni e la fattualità, quindi voglio sottolineare ancora una volta questo punto psicologico molto importante, la conoscenza nei parametri della rete neurale è una vaga reminiscenza, la conoscenza nei token che compongono la finestra di contesto è la memoria di lavoro e approssimativamente funziona un po' come per noi nel nostro cervello, le cose che ricordiamo sono i nostri parametri e le cose che abbiamo appena vissuto pochi secondi o minuti fa e così via, puoi immaginare che siano nella nostra finestra di contesto e questa finestra di contesto si sta costruendo man mano che hai un'esperienza cosciente intorno a te, quindi questo ha un sacco di implicazioni anche per il tuo uso di LOL in pratica, ad esempio, posso andare su ChatGPT e fare qualcosa del genere, posso dire puoi riassumere il capitolo uno di Orgoglio e Pregiudizio di Jane Austen, e questo è un prompt perfettamente valido e ChatGPT fa qualcosa di relativamente ragionevole qui, ma il motivo per cui lo fa è perché ChatGPT ha un buon ricordo di un'opera famosa come Orgoglio e Pregiudizio, probabilmente ha visto un sacco di cose al riguardo, probabilmente ci sono forum su questo libro, probabilmente ha letto versioni di questo libro e in qualche modo se lo ricorda perché anche se l'hai letto o articoli al riguardo, avresti un ricordo sufficiente per dire tutto questo, ma di solito quando interagisco con gli LLM e voglio che ricordino cose specifiche, funziona sempre meglio se gliele dai tu, quindi penso che un prompt molto migliore sarebbe qualcosa del tipo: puoi riassumermi il capitolo uno di Orgoglio e Pregiudizio di Jane Austen e poi lo allego qui sotto per riferimento e poi faccio qualcosa come un delimitatore qui e lo incollo e ho scoperto che semplicemente copiandolo da un sito web che ho trovato qui, quindi incollando il capitolo uno qui e lo faccio perché quando è nella finestra di contesto, il modello ha accesso diretto ad esso e può esattamente, non deve ricordarlo, ha solo accesso ad esso e quindi questo riassunto può essere previsto di essere di qualità significativamente alta o più alta di questo riassunto, solo perché è direttamente disponibile al modello e penso che tu e io lavoreremmo allo stesso modo, se volessi, produrresti un riassunto molto migliore se avessi riletto questo capitolo prima di doverlo riassumere, ed è fondamentalmente quello che sta succedendo qui o l'equivalente. La prossima stranezza psicologica di cui vorrei parlare brevemente è quella della conoscenza di sé, quello che vedo molto spesso su internet è che le persone fanno qualcosa del genere, chiedono agli LLM qualcosa come quale modello sei e chi ti ha costruito e fondamentalmente questa domanda è un po' insensata e il motivo per cui lo dico è che come cerco di spiegare con alcuni dei fondamenti sottostanti, questa cosa non è una persona, non ha un'esistenza persistente in alcun modo, si avvia processi, token e si spegne, e lo fa per ogni singola persona, costruisce semplicemente una finestra di contesto di conversazione e poi tutto viene cancellato e quindi questa entità viene riavviata da zero ogni singola conversazione, se questo ha senso, non ha un sé persistente, non ha un senso di sé, è un giratore di token e segue le regolarità statistiche del suo set di addestramento, quindi non ha molto senso chiedere chi sei, cosa ti ha costruito, eccetera, e per impostazione predefinita, se fai quello che ho descritto e semplicemente per impostazione predefinita e dal nulla, otterrai alcune risposte piuttosto casuali, quindi ad esempio, prendiamo Falcon, che è un modello abbastanza vecchio, e vediamo cosa ci dice, quindi sta eludendo la domanda, ingegneri e sviluppatori di talento qui, dice che sono stato costruito da OpenAI basato sul modello GPT-3, sta completamente inventando le cose ora, il fatto che sia stato costruito da OpenAI qui, penso che molte persone prenderebbero questo come prova che questo modello è stato in qualche modo addestrato su dati OpenAI o qualcosa del genere, non penso che sia necessariamente vero, il motivo è che se non programmi esplicitamente il modello per rispondere a questi tipi di domande, quello che otterrai è la sua migliore ipotesi statistica per la risposta e questo modello aveva un misto di dati sft di conversazioni e durante il fine-tuning, il modello capisce mentre si addestra su questi dati che sta assumendo questa personalità di questo assistente utile e non sa come, non gli è stato detto esattamente quale etichetta applicare a sé stesso, sta semplicemente assumendo questa persona di un assistente utile e ricorda che la fase di pre-addestramento ha preso i documenti da tutto internet e ChatGPT e OpenAI sono molto prominenti in questi documenti e quindi penso che quello che sta effettivamente succedendo qui è che questa è solo la sua etichetta allucinata per quello che è, questa è la sua identità di sé che è ChatGPT di OpenAI ed è solo dicendo che perché ci sono un sacco di dati su internet di risposte come questa che provengono effettivamente da OpenAI da ChatGPT, quindi questa è la sua etichetta per quello che è, ora puoi sovrascriverlo come sviluppatore, se hai un modello LLM, puoi effettivamente sovrascriverlo e ci sono alcuni modi per farlo, quindi ad esempio, lasciami mostrarti, c'è questo modello Almo di Allen AI e questo è un LLM, non è un LLM di alto livello o qualcosa del genere, ma mi piace perché è completamente open source, quindi il paper per Almo e tutto il resto è completamente open source, il che è bello, quindi qui stiamo guardando il suo misto sft, quindi questo è il misto di dati del fine-tuning, quindi questo sono i dati delle conversazioni, giusto? E quindi il modo in cui lo stanno risolvendo per il modello Almo, vediamo che c'è un sacco di roba nel misto e ci sono un totale di 1 milione di conversazioni qui, ma qui abbiamo Almo hardcoded, se andiamo lì, vediamo che sono 240 conversazioni e guarda queste 240 conversazioni, sono hardcoded, dimmi di te, dice l'utente e poi l'assistente dice, sono un modello linguistico aperto sviluppato da AI all'Allen Institute of Artificial Intelligence, eccetera, sono qui per aiutare, bla bla bla, qual è il tuo nome, progetto Almo, quindi queste sono tutte domande cucinate e hardcoded su Almo 2 e le risposte corrette da dare in questi casi, se prendi 240 domande come queste o conversazioni, le metti nel tuo set di addestramento e fai il fine-tuning con esse, allora ci si aspetta che il modello ripeta queste cose più tardi, se non glielo dai, allora è probabilmente ChatGPT di OpenAI e c'è un altro modo per farlo a volte, è che fondamentalmente in queste conversazioni e hai termini tra umano e assistente, a volte c'è un messaggio speciale chiamato messaggio di sistema all'inizio della conversazione, quindi non è solo tra umano e assistente, c'è un sistema e nel messaggio di sistema puoi effettivamente codificare e ricordare al modello che ehi, sei un modello sviluppato da OpenAI e il tuo nome è ChatGPT 4o e sei stato addestrato in questa data e il tuo limite di conoscenza è questo e fondamentalmente documenta un po' il modello e poi questo viene inserito nelle tue conversazioni, quindi quando vai su ChatGPT, vedi una pagina vuota, ma in realtà il messaggio di sistema è nascosto lì e quei token sono nella finestra di contesto, quindi questi sono i due modi per programmare i modelli per parlare di sé stessi, o viene fatto attraverso dati come questi, o viene fatto attraverso messaggi di sistema e cose del genere, fondamentalmente token invisibili che sono nella finestra di contesto e ricordano al modello la sua identità, ma è tutto un po' cucinato e aggiunto in qualche modo, non è realmente profondamente lì in alcun senso reale come lo sarebbe per un essere umano. Voglio ora continuare alla prossima sezione che tratta delle capacità computazionali o come dovrei dire delle capacità computazionali native di questi modelli in scenari di problem solving e quindi in particolare dobbiamo stare molto attenti con questi modelli quando costruiamo i nostri esempi di conversazioni e ci sono molti spigoli vivi qui che sono in qualche modo illuminanti, è una parola? Sono in qualche modo interessanti da guardare quando consideriamo come pensano questi modelli, quindi considera il seguente prompt da un umano e supponiamo che fondamentalmente stiamo costruendo una conversazione da inserire nel nostro set di addestramento di conversazioni, quindi addestreremo il modello su questo, ti stiamo insegnando come risolvere semplici problemi matematici, quindi il prompt è Emily compra tre mele e due arance, ogni arancia costa 2 dollari, il costo totale è 13, qual è il costo delle mele? Domanda matematica molto semplice, ci sono due risposte qui, a sinistra e a destra, sono entrambe risposte corrette, entrambe dicono che la risposta è tre, il che è corretto, ma una di queste due è una risposta significativamente migliore per l'assistente rispetto all'altra, se fossi un etichettatore di dati e stessi creando una di queste, una di queste sarebbe una risposta davvero terribile per l'assistente e l'altra sarebbe ok, e quindi vorrei che tu potessi mettere in pausa il video anche e pensare perché una di queste due è una risposta significativamente migliore dell'altra, e se usi quella sbagliata, il tuo modello sarà effettivamente molto scarso in matematica potenzialmente e avrà esiti negativi, e questo è qualcosa a cui dovresti prestare attenzione nella tua vita etichettando documentazioni quando stai addestrando persone a creare le risposte ideali per l'assistente, ok, la chiave di questa domanda è rendersi conto e ricordare che quando i modelli si addestrano e anche quando inferiscono, stanno lavorando in una sequenza unidimensionale di token da sinistra a destra, e questa è l'immagine che ho spesso in mente, immagino fondamentalmente la sequenza di token che evolve da sinistra a destra e per produrre sempre il token successivo in una sequenza, stiamo alimentando tutti questi token nella rete neurale e questa rete neurale poi fornisce le probabilità per il token successivo nella sequenza, giusto? Quindi questa immagine qui è la stessa immagine che abbiamo visto prima qui sopra e questo proviene dalla demo web che ti ho mostrato prima, giusto? Questo è il calcolo che fondamentalmente prende i token di input qui in alto ed esegue queste operazioni di tutti questi neuroni e ti dà la risposta per le probabilità di ciò che viene dopo, la cosa importante da realizzare è che approssimativamente ci sono fondamentalmente un numero finito di livelli di calcolo che avvengono qui, quindi ad esempio questo modello qui ha solo uno, due, tre livelli di quella che viene chiamata attenzione e MLP qui, forse una tipica rete moderna all'avanguardia avrebbe più come, diciamo, 100 livelli o qualcosa del genere, ma ci sono solo 100 livelli di calcolo o qualcosa del genere per passare dalla sequenza di token precedente alle probabilità per il token successivo, e quindi c'è una quantità finita di calcolo che avviene qui per ogni singolo token e dovresti pensare a questo come una quantità molto piccola di calcolo e questa quantità di calcolo è quasi approssimativamente fissa per ogni singolo token in questa sequenza, non è del tutto vero perché più token inserisci, più costoso sarà questo passaggio in avanti di questa rete neurale, ma non di molto, quindi dovresti pensare a questo e penso che sia un buon modello da avere in mente, questa è una quantità fissa di calcolo che avverrà in questa casella per ognuno di questi token e questa quantità di calcolo non può essere troppo grande perché non ci sono così tanti livelli che vanno dall'alto verso il basso qui, non c'è così tanto calcolo che avverrà qui, e quindi non puoi immaginare che il modello faccia calcoli arbitrari in un singolo passaggio in avanti per ottenere un singolo token, e quindi quello che significa è che dobbiamo distribuire il nostro ragionamento e il nostro calcolo su molti token perché ogni singolo token spende solo una quantità finita di calcolo su di esso, e quindi vogliamo distribuire il calcolo su molti token e non possiamo avere troppo calcolo o aspettarci troppo calcolo dal modello in un singolo token individuale perché c'è solo tanto calcolo che avviene per token, ok, quantità di calcolo approssimativamente fissa qui, ecco perché questa risposta qui è significativamente peggiore e il motivo è che immagina di andare da sinistra a destra qui, e l'ho copiata qui, la risposta è tre, eccetera, immagina che il modello debba andare da sinistra a destra emettendo questi token uno alla volta, deve dire o ci aspettiamo che dica la risposta è spazio segno di dollaro e poi qui ci aspettiamo che crammi fondamentalmente tutto il calcolo di questo problema in questo singolo token, deve emettere la risposta corretta tre, e una volta che abbiamo emesso la risposta tre, ci aspettiamo che dica tutti questi token, ma a questo punto abbiamo già prodotto la risposta ed è già nella finestra di contesto per tutti i token che seguono, quindi qualsiasi cosa qui è solo una giustificazione post-hoc del perché questa è la risposta, perché la risposta è già stata creata, è già nella finestra di token, quindi non viene effettivamente calcolata qui, e quindi se rispondi direttamente e immediatamente alla domanda, stai addestrando il modello a provare a indovinare la risposta in un singolo token, e questo semplicemente non funzionerà a causa della quantità finita di calcolo che avviene per token, ecco perché questa risposta a destra è significativamente migliore perché stiamo distribuendo questo calcolo attraverso la risposta, stiamo effettivamente facendo in modo che il modello arrivi lentamente alla risposta da sinistra a destra, stiamo ottenendo risultati intermedi, stiamo dicendo ok, il costo totale delle arance è quattro, quindi 30 meno 4 fa 9, e quindi stiamo creando calcoli intermedi e ognuno di questi calcoli da solo non è così costoso, e quindi stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere a mente, nei tuoi prompt, di solito non devi pensarci esplicitamente perché le persone di OpenAI hanno etichettatori e così via che se ne preoccupano e si assicurano che le risposte siano distribuite, e quindi in realtà OpenAI farà la cosa giusta, quindi quando chiedo questa domanda a ChatGPT, in realtà andrà molto lentamente, sarà tipo, ok, definiamo le nostre variabili, impostiamo l'equazione e sta creando tutti questi risultati intermedi, questi non sono per te, sono per il modello, se il modello non crea questi risultati intermedi per sé stesso, non sarà in grado di raggiungere tre, volevo anche mostrarti che è possibile essere un po' cattivi con il modello, possiamo semplicemente chiedere cose, quindi come esempio, ho detto, gli ho dato lo stesso prompt e ho detto rispondi alla domanda in un singolo token, solo dammi immediatamente la risposta, niente altro, ed è risultato che per questo semplice prompt qui, è stato effettivamente in grado di farlo in un colpo solo, ha creato un singolo, penso che siano due token, giusto, perché il segno di dollaro è un token a sé stante, quindi fondamentalmente questo modello non mi ha dato un singolo token, mi ha dato due token, ma ha comunque prodotto la risposta corretta, e lo ha fatto in un singolo passaggio in avanti della rete, questo perché i numeri qui sono penso molto semplici, e quindi l'ho reso un po' più difficile per essere un po' cattivo con il modello, quindi ho detto Emily compra 23 mele e 177 arance, e poi ho solo aumentato un po' i numeri e lo sto rendendo più difficile per il modello, gli sto chiedendo più calcolo in un singolo token, e quindi ho detto la stessa cosa, e qui mi ha dato cinque, e cinque in realtà non è corretto, quindi il modello non è riuscito a fare tutto questo calcolo in un singolo passaggio in avanti della rete, non è riuscito a passare dai token di input e poi in un singolo passaggio in avanti della rete, un singolo passaggio attraverso la rete, non è riuscito a produrre il risultato, e poi ho detto, ok, ora non preoccuparti del limite di token e risolvi il problema come al solito, e poi fa tutti i risultati intermedi, si semplifica e ognuno di questi risultati intermedi qui e calcoli intermedi è molto più facile per il modello, e stiamo fondamentalmente indovinando un po' la difficoltà che il modello è capace di in uno qualsiasi di questi singoli token, e non ci può mai essere troppo lavoro in uno qualsiasi di questi token computazionalmente, perché altrimenti il modello non sarà in grado di farlo in fase di test, e quindi stiamo insegnando al modello qui a distribuire il suo ragionamento e a distribuire il suo calcolo sui token, e in questo modo ha solo problemi molto semplici in ogni token, e possono sommarsi, e quindi quando è vicino alla fine, ha tutti i risultati precedenti nella sua memoria di lavoro ed è molto più facile per esso determinare che la risposta è, ed eccola qui, tre, quindi questa è un'etichetta significativamente migliore per il nostro calcolo, questo sarebbe davvero brutto e sta insegnando al modello a provare a fare tutto il calcolo in un singolo token, ed è davvero brutto, quindi questo è un po' un esempio interessante da tenere

ai Olimpiadi ma poi fallire su problemi molto semplici come questo e uh penso che questo sia, come ho detto, un po' un rompicapo. Si scopre che un sacco di persone hanno studiato questo a fondo e io non ho letto l'articolo, ma quello che mi è stato detto da questo team è che quando si esaminano le attivazioni all'interno della rete neurale, quando si guardano alcune delle caratteristiche e quali caratteristiche si accendono o si spengono e quali neuroni si accendono o si spengono, un sacco di neuroni all'interno della rete neurale si illuminano che sono solitamente associati a versetti biblici. E quindi penso che il modello sia un po' come ricordato che questi assomigliano quasi a marcatori di versetti biblici e in un contesto di versetti biblici, 9.11 verrebbe dopo 9.9 e quindi fondamentalmente il modello in qualche modo lo trova cognitivamente molto distraente che nei versetti biblici 9.11 sarebbe maggiore, anche se qui sta effettivamente cercando di giustificarlo e arrivare alla risposta con la matematica, finisce comunque con la risposta sbagliata qui, quindi fondamentalmente non ha senso e non è completamente compreso e ci sono alcuni problemi irregolari come quello, quindi è per questo che lo tratto come quello che è, ovvero un sistema stocastico che è davvero magico ma di cui non ci si può fidare completamente e si vuole usarlo come strumento, non come qualcosa che si lascia correre su un problema e si copiano e incollano i risultati.

Ok, abbiamo ora coperto due fasi principali di addestramento di modelli linguistici di grandi dimensioni. Abbiamo visto che nella prima fase, chiamata fase di pre-addestramento, ci addestriamo fondamentalmente su documenti internet e quando si addestra un modello linguistico su documenti internet, si ottiene quello che viene chiamato un modello di base ed è fondamentalmente un simulatore di documenti internet. Ora abbiamo visto che questo è un artefatto interessante e ci vogliono molti mesi per addestrarlo su migliaia di computer ed è una sorta di compressione con perdita di informazioni di internet ed è estremamente interessante, ma non è direttamente utile perché non vogliamo campionare documenti internet, vogliamo fare domande a un'IA e farla rispondere alle nostre domande. Quindi per questo abbiamo bisogno di un assistente e abbiamo visto che possiamo effettivamente costruire un assistente nel processo di post-addestramento e specificamente nel processo di fine-tuning supervisionato, come lo chiamiamo. Quindi in questa fase abbiamo visto che è algoritmicamente identico al pre-addestramento, nulla cambierà, l'unica cosa che cambia è il set di dati. Quindi invece di documenti internet, ora vogliamo creare e curare un set di dati di conversazioni molto bello. Quindi vogliamo milioni di conversazioni su tutti i tipi di argomenti diversi tra un umano e un assistente e fondamentalmente queste conversazioni sono create dagli umani, quindi gli umani scrivono i prompt e gli umani scrivono le risposte ideali e lo fanno sulla base di documentazione di etichettatura. Ora nello stack moderno, non è effettivamente fatto completamente e manualmente dagli umani, giusto? Ora hanno molta aiuto da questi strumenti, quindi possiamo usare modelli linguistici per aiutarci a creare questi set di dati e questo viene fatto ampiamente, ma fondamentalmente proviene ancora dalla curatela umana alla fine. Quindi creiamo queste conversazioni che ora diventano il nostro set di dati, le affiniamo o continuiamo ad addestrarle e otteniamo un assistente e poi abbiamo cambiato marcia e abbiamo iniziato a parlare di alcune delle implicazioni cognitive di come è questo assistente e abbiamo visto che, ad esempio, l'assistente allungherà se non si prendono alcune mitigazioni al riguardo. Quindi abbiamo visto che le allucinazioni sarebbero comuni e poi abbiamo esaminato alcune delle mitigazioni di quelle allucinazioni e poi abbiamo visto che i modelli sono piuttosto impressionanti e possono fare molte cose nella loro testa, ma abbiamo visto che possono anche fare affidamento su strumenti per migliorare. Quindi, ad esempio, possiamo fare affidamento sulla ricerca web per allucinare meno e magari portare alcune informazioni più recenti o qualcosa del genere, oppure possiamo fare affidamento su strumenti come l'interprete di codice, quindi il codice può, quindi l'LLM può scrivere del codice ed eseguirlo e vedere i risultati. Quindi questi sono alcuni degli argomenti che abbiamo esaminato finora.

Ora, quello che vorrei fare è coprire l'ultima e principale fase di questa pipeline, ed è l'apprendimento per rinforzo. L'apprendimento per rinforzo è ancora considerato sotto l'ombrello del post-addestramento, ma è l'ultima terza fase principale ed è un modo diverso di addestrare i modelli linguistici e di solito segue come terzo passo. Quindi all'interno di aziende come OpenAI, inizierai qui e questi sono tutti team separati, quindi c'è un team che si occupa dei dati per il pre-addestramento e un team che si occupa dell'addestramento per il pre-addestramento e poi c'è un team che si occupa di tutta la generazione di conversazioni in un team diverso che si occupa del fine-tuning supervisionato e ci sarà anche un team per l'apprendimento per rinforzo. Quindi è una sorta di passaggio di consegne di questi modelli, ottieni il tuo modello di base, poi scopri di dover essere un assistente e poi entri nell'apprendimento per rinforzo di cui parleremo ora. Quindi questo è più o meno il flusso principale e quindi concentriamoci ora sull'apprendimento per rinforzo, l'ultima fase principale dell'addestramento e lasciami prima motivarlo e perché vorremmo fare apprendimento per rinforzo e come appare ad alto livello.

Quindi ora vorrei provare a motivare la fase di apprendimento per rinforzo e a cosa corrisponde con qualcosa che probabilmente ti è familiare, ed è fondamentalmente andare a scuola. Quindi proprio come sei andato a scuola per diventare davvero bravo in qualcosa, vogliamo portare i modelli linguistici di grandi dimensioni a scuola e in realtà quello che stiamo facendo è che abbiamo alcuni paradigmi di modi per dare loro conoscenza o trasferire abilità. Quindi in particolare quando lavoriamo con libri di testo a scuola, vedrai che ci sono tre pezzi principali di informazioni in questi libri di testo, tre classi di informazioni. La prima cosa che vedrai è molta esposizione e, a proposito, questo è un libro totalmente casuale che ho preso da internet, penso che sia una specie di chimica organica o qualcosa del genere, non sono sicuro, ma la cosa importante è che vedrai che la maggior parte del testo, la maggior parte di esso è fondamentalmente la carne è esposizione, è una sorta di conoscenza di base, ecc. Mentre leggi le parole di questa esposizione, puoi pensare a questo approssimativamente come addestramento su quei dati. E questo è il motivo per cui quando leggi queste cose, questa conoscenza di base e tutte queste informazioni contestuali, è una sorta di equivalente al pre-addestramento, quindi è dove costruiamo una sorta di base di conoscenza di questi dati e otteniamo un senso dell'argomento.

Il prossimo tipo principale di informazione che vedrai sono questi problemi e con le loro soluzioni elaborate. Quindi fondamentalmente un esperto umano in questo caso, l'autore di questo libro, ci ha dato non solo un problema, ma ha anche elaborato la soluzione e la soluzione è fondamentalmente come avere questa risposta ideale per un assistente. Quindi è fondamentalmente l'esperto che ci mostra come risolvere il problema nella sua forma completa. Quindi mentre leggiamo la soluzione, ci stiamo fondamentalmente addestrando sui dati dell'esperto e poi più tardi possiamo provare a imitare l'esperto e fondamentalmente questo corrisponde approssimativamente ad avere il modello SFT, questo è quello che farebbe. Quindi fondamentalmente abbiamo già fatto il pre-addestramento e abbiamo già coperto questa imitazione di esperti e come risolvono questi problemi. E la terza fase dell'apprendimento per rinforzo sono fondamentalmente i problemi di pratica. Quindi a volte vedrai che questo è solo un singolo problema di pratica qui, ma ovviamente ci saranno solitamente molti problemi di pratica alla fine di ogni capitolo in qualsiasi libro di testo e i problemi di pratica, ovviamente, sappiamo che sono critici per l'apprendimento perché cosa ti fanno fare? Ti fanno praticare, praticare da solo e scoprire modi per risolvere questi problemi da solo. E quindi quello che ottieni in un problema di pratica è una descrizione del problema, ma non ti viene data la soluzione, ma ti viene data la risposta finale, solitamente nella chiave di risposta del libro di testo. E quindi conosci la risposta finale che stai cercando di ottenere e hai l'enunciato del problema, ma non hai la soluzione. Stai cercando di praticare la soluzione, stai provando molte cose diverse e stai vedendo cosa ti porta alla soluzione finale al meglio. E quindi stai scoprendo come risolvere questi problemi. E nel processo di ciò, ti affidi a numero uno, le informazioni di base che provengono dal pre-addestramento e numero due, forse un po' di imitazione di esperti umani e puoi probabilmente provare tipi simili di soluzioni e così via.

Quindi abbiamo fatto questo e questo, e ora in questa sezione proveremo a praticare. E quindi ci verranno dati prompt, ci verranno date soluzioni, scusa, le risposte finali, ma non ci verranno date soluzioni esperte. Dobbiamo praticare e provare cose. Ed è di questo che si tratta l'apprendimento per rinforzo.

Ok, torniamo al problema con cui abbiamo lavorato in precedenza, solo per avere un esempio concreto di cui parlare mentre esploriamo l'argomento. Quindi, sono qui nel tokenizer Tek perché vorrei anche, beh, ottengo una casella di testo che è utile, ma numero due, voglio ricordarti ancora una volta che stiamo sempre lavorando con sequenze di token unidimensionali e quindi, in realtà, preferisco questa vista perché questa è come la vista nativa dell'LLM, se ha senso, come questo è quello che vede, vede gli ID dei token, giusto? Ok.

Emily compra tre mele e due arance. Ogni arancia costa 2 dollari. Il costo totale di tutta la frutta è di 13 dollari. Qual è il costo di ogni mela? E quello che vorrei, quello che vorrei che apprezzassi qui è che queste sono come quattro possibili soluzioni candidate come esempio, e tutte raggiungono la risposta tre. Ora, quello che vorrei che apprezzassi a questo punto è che se io sono l'etichettatore umano di dati che sta creando una conversazione da inserire nel set di addestramento, in realtà non so davvero quale di queste conversazioni aggiungere al set di dati. Alcune di queste conversazioni impostano un sistema di equazioni, alcune ne parlano in inglese e alcune saltano direttamente alla soluzione. Se guardi ChatGPT, ad esempio, e gli fai questa domanda, definisce un sistema di variabili e fa questa piccola cosa. Quello che dobbiamo apprezzare e differenziare, però, è che il primo scopo di una soluzione è raggiungere la risposta corretta, ovviamente vogliamo ottenere la risposta finale tre, questo è lo scopo importante qui, ma c'è anche uno scopo secondario, dove qui stiamo anche solo cercando di renderlo piacevole per l'umano perché stiamo ipotizzando che la persona voglia vedere la soluzione, voglia vedere i passaggi intermedi, vogliamo presentarla bene, ecc.

Quindi ci sono due cose separate che accadono qui: numero uno è la presentazione per l'umano, ma numero due stiamo cercando di ottenere la risposta corretta. Quindi concentriamoci per il momento solo sul raggiungimento della risposta finale. Se ci interessa solo la risposta finale, allora quale di queste è la soluzione ottimale o migliore per l'LLM per raggiungere la risposta corretta? E quello che sto cercando di dire è che non lo so. Io, come etichettatore umano, non saprei quale di queste sia la migliore. Quindi, ad esempio, abbiamo visto in precedenza quando abbiamo guardato le sequenze di token qui e l'aritmetica mentale e il ragionamento, abbiamo visto che per ogni token possiamo spendere solo fondamentalmente una quantità finita di calcolo qui che non è molto grande, o dovresti pensarla in quel modo. E quindi non possiamo fare un salto troppo grande in un singolo token, è forse il modo di pensarla. Quindi, ad esempio, in questo, quello che è davvero bello è che sono pochissimi token, quindi ci vorrà pochissimo tempo per arrivare alla risposta, ma proprio qui, quando stiamo facendo 30 - 4 diviso 3 uguale, in questo token qui, stiamo in realtà chiedendo molta computazione su quel singolo token individuale. E quindi forse questo è un cattivo esempio da dare all'LLM perché lo sta incentivando a saltare i calcoli molto velocemente e in realtà commetterà errori, commetterà errori in questa aritmetica mentale. Quindi forse funzionerebbe meglio distribuirlo, distribuirlo di più, forse sarebbe meglio impostarlo come un'equazione, forse sarebbe meglio parlarne. Fondamentalmente non lo sappiamo e non lo sappiamo perché ciò che è facile per te o per me come etichettatori umani, ciò che è facile o difficile per noi è diverso da ciò che è facile o difficile per l'LLM. La sua cognizione è diversa e le sequenze di token sono in qualche modo diverse e difficili per esso. E quindi alcune delle sequenze di token qui che sono banali per me potrebbero essere un salto troppo grande per l'LLM. Quindi proprio qui questo token sarebbe troppo difficile, ma al contrario, molti dei token che sto creando qui potrebbero essere semplicemente banali per l'LLM e stiamo solo sprecando token, perché sprecare tutti questi token quando tutto questo è banale?

Quindi, se l'unica cosa che ci interessa è la risposta finale e stiamo separando la questione della presentazione all'umano, allora in realtà non sappiamo come annotare questo esempio. Non sappiamo quale soluzione dare all'LLM perché non siamo l'LLM. Ed è chiaro qui nel caso dell'esempio matematico, ma questo è in realtà un problema molto pervasivo. La nostra conoscenza non è la conoscenza dell'LLM. L'LLM ha effettivamente una tonnellata di conoscenza, un dottorato in matematica, fisica, chimica e quant'altro. Quindi in molti modi, in realtà sa più di me e io potenzialmente non sto utilizzando quella conoscenza nella sua risoluzione dei problemi. Ma al contrario, potrei star iniettando un sacco di conoscenza nelle mie soluzioni che l'LLM non conosce nei suoi parametri, e poi questi sono come salti improvvisi che sono molto confusi per il modello. E quindi le nostre cognizioni sono diverse e non so davvero cosa mettere qui se tutto ciò che ci interessa è raggiungere la soluzione finale e farlo in modo economico, idealmente.

Quindi, in poche parole, non siamo in una buona posizione per creare queste sequenze di token per l'LLM e sono utili per imitazione per inizializzare il sistema, ma vogliamo davvero che l'LLM scopra le sequenze di token che funzionano per esso. Dobbiamo trovare, deve trovare da solo quale sequenza di token porta in modo affidabile alla risposta dato il prompt, e deve scoprirlo nel processo di apprendimento per rinforzo e per tentativi ed errori.

Quindi vediamo come funzionerebbe questo esempio nell'apprendimento per rinforzo.

Ok, siamo di nuovo nell'area di gioco di inferenza di Hugging Face e questo mi permette semplicemente di chiamare facilmente diversi tipi di modelli. Quindi, ad esempio, qui in alto a destra ho scelto il modello Gemma 2 da 2 miliardi di parametri. Quindi 2 miliardi è molto, molto piccolo, quindi questo è un modello minuscolo, ma va bene. Quindi gli daremo, il modo in cui funzionerà l'apprendimento per rinforzo sarà in realtà abbastanza semplice. Dobbiamo provare molti tipi diversi di soluzioni e vogliamo vedere quali soluzioni funzionano bene o no. Quindi fondamentalmente prenderemo il prompt, eseguiremo il modello e il modello genererà una soluzione, e poi ispezioneremo la soluzione e sappiamo che la risposta corretta per questo è 3 dollari. E quindi infatti il modello lo ottiene correttamente, dice che sono 3 dollari, quindi questo è corretto. Questo è solo un tentativo di soluzione.

Ora cancelleremo questo e lo rieseguiremo di nuovo. Proviamo un secondo tentativo. Il modello lo risolve in un modo leggermente diverso, giusto? Ogni singolo tentativo sarà una generazione diversa perché questi modelli sono sistemi stocastici, ricordate che ad ogni singolo token qui abbiamo una distribuzione di probabilità e campioniamo da quella distribuzione, quindi finiamo per percorrere percorsi leggermente diversi. E quindi questa è una seconda soluzione che termina anche con la risposta corretta. Ora cancelleremo questo, andiamo una terza volta. Ok, di nuovo una soluzione leggermente diversa, ma anche corretta. Ora possiamo effettivamente ripetere questo molte volte e quindi in pratica potresti campionare migliaia di soluzioni indipendenti o anche milioni di soluzioni per un singolo prompt. E alcune di esse saranno corrette e alcune non saranno molto corrette. E fondamentalmente quello che vogliamo fare è incoraggiare le soluzioni che portano a risposte corrette.

Quindi diamo un'occhiata a come appare. Quindi se torniamo qui, ecco una sorta di diagramma a fumetti di come appare. Abbiamo un prompt e poi abbiamo provato molte soluzioni diverse in parallelo e alcune delle soluzioni potrebbero andare bene, ottengono la risposta corretta che è in verde, e alcune delle soluzioni potrebbero andare male e non raggiungere la risposta corretta che è in rosso. Ora questo problema qui, sfortunatamente, non è il miglior esempio perché è un prompt banale e, come abbiamo visto, anche un modello da due miliardi di parametri lo ottiene sempre correttamente, quindi non è il miglior esempio in questo senso. Ma esercitiamo un po' di immaginazione qui e supponiamo solo che quelli verdi siano buoni e quelli rossi siano cattivi. Ok, abbiamo generato 15 soluzioni, solo quattro delle quali hanno ottenuto la risposta corretta. E quindi ora quello che vogliamo fare è fondamentalmente incoraggiare i tipi di soluzioni che portano a risposte corrette. Quindi, qualunque sequenza di token sia accaduta in queste soluzioni rosse, ovviamente qualcosa è andato storto lungo il percorso da qualche parte, e questo non è stato un buon percorso da seguire attraverso la soluzione. E qualunque sequenza di token ci fosse in queste soluzioni verdi, beh, le cose sono andate abbastanza bene in questa situazione. E quindi vogliamo fare più cose come questa nei prompt. E il modo in cui incoraggiamo questo tipo di comportamento in futuro è che ci addestriamo su queste sequenze, ma queste sequenze di addestramento ora non provengono da annotatori umani esperti. Non c'è nessun umano che ha deciso che questa è la soluzione corretta. Questa soluzione è venuta dal modello stesso. Quindi il modello sta praticando qui, ha provato alcune soluzioni, quattro sembrano aver funzionato, e ora il modello si addestrerà su di esse. E questo corrisponde a uno studente che guarda le proprie soluzioni e dice: "Ok, bene, questa ha funzionato davvero bene, quindi è così che dovrei risolvere questi tipi di problemi". E qui in questo esempio ci sono molti modi diversi per modificare un po' la metodologia, ma per dare l'idea principale, forse è più semplice pensare a prendere la singola migliore soluzione tra queste quattro, come questa, ecco perché era gialla. Quindi questa è la soluzione che non solo ha portato alla risposta corretta, ma forse aveva altre belle proprietà, forse era la più corta o sembrava più bella in qualche modo, o ci sono altri criteri a cui potresti pensare come esempio, ma decideremo che questa è la soluzione migliore, ci addestreremo su di essa, e poi il modello sarà leggermente più propenso, una volta fatto l'aggiornamento dei parametri, a seguire questo percorso in questo tipo di impostazione in futuro.

Ma devi ricordare che eseguiremo molti prompt diversi e diversificati su molti problemi di matematica e problemi di fisica e ovunque ci possa essere, quindi decine di migliaia di prompt, forse tieni presente che ci sono migliaia di soluzioni per prompt. E tutto questo sta accadendo in qualche modo contemporaneamente. E mentre iteriamo questo processo, il modello sta scoprendo da solo quali tipi di sequenze di token lo portano a risposte corrette. Non proviene da un annotatore umano. Il modello sta in qualche modo giocando in questo parco giochi e sa cosa sta cercando di ottenere e sta scoprendo sequenze che funzionano per esso. Queste sono sequenze che non fanno salti mentali, sembrano funzionare in modo affidabile e statisticamente e sfruttano appieno la conoscenza del modello come la possiede. E quindi questo è il processo di apprendimento per rinforzo. È fondamentalmente un tentativo ed errore. Proveremo molti tipi diversi di soluzioni, le controlleremo e faremo di più di ciò che ha funzionato in futuro. Ed è questo l'apprendimento per rinforzo.

Quindi, nel contesto di ciò che è venuto prima, vediamo ora che il modello SFT, il modello di fine-tuning supervisionato, è ancora utile perché ancora in qualche modo inizializza il modello un po' nella vicinanza delle soluzioni corrette. Quindi è una sorta di inizializzazione del modello nel senso che porta il modello a scrivere soluzioni e forse ha una comprensione dell'impostazione di un sistema di equazioni o forse ne parla attraverso una soluzione, quindi lo porta nella vicinanza delle soluzioni corrette. Ma l'apprendimento per rinforzo è dove tutto viene messo a punto. Scopriamo davvero le soluzioni che funzionano per il modello, otteniamo le risposte corrette, le incoraggiamo e poi il modello semplicemente migliora nel tempo.

Ok, questo è il processo di alto livello su come addestriamo i modelli linguistici di grandi dimensioni. In breve, li addestriamo in modo molto simile a come addestriamo i bambini. E fondamentalmente l'unica differenza è che i bambini attraversano capitoli di libri e fanno tutti questi diversi tipi di esercizi di addestramento, in qualche modo all'interno del capitolo di ogni libro. Ma invece, quando addestriamo le IA, è quasi come se lo facessimo fase per fase, a seconda del tipo di quella fase. Quindi prima facciamo il pre-addestramento, che, come abbiamo visto, è equivalente a leggere fondamentalmente tutto il materiale espositivo. Quindi guardiamo tutti i libri di testo contemporaneamente e leggiamo tutta l'esposizione e cerchiamo di costruire una base di conoscenza. La seconda cosa, poi, è che entriamo nella fase SFT, che consiste davvero nel guardare tutte le soluzioni fisse, diciamo, da esperti umani, di tutti i diversi tipi di soluzioni elaborate in tutti i libri di testo, e otteniamo semplicemente un modello SFT che è in grado di imitare gli esperti, ma lo fa in modo cieco. Fa semplicemente la sua migliore ipotesi, cercando di imitare statisticamente il comportamento dell'esperto. E questo è quello che ottieni quando guardi tutte le soluzioni elaborate. E poi, infine, nell'ultima fase, facciamo tutti i problemi di pratica nella fase RL, attraverso tutti i libri di testo, facciamo solo i problemi di pratica. Ed è così che otteniamo il modello RL. Quindi, ad alto livello, il modo in cui addestriamo gli LLM è molto equivalente al processo che usiamo per addestrare i bambini.

Il prossimo punto che vorrei fare è che in realtà queste prime due fasi, pre-addestramento e fine-tuning sorpresa, esistono da anni e sono molto standard e tutti le fanno, tutti i diversi fornitori di LLM. È questa ultima fase, l'addestramento RL, che è molto più precoce nel suo processo di sviluppo e non è ancora standard nel campo. E quindi questa fase è molto più precoce e nascente. E la ragione di ciò è che ho effettivamente saltato un sacco di piccoli dettagli qui in questo processo. L'idea di alto livello è molto semplice, è l'apprendimento per tentativi ed errori, ma ci sono un sacco di dettagli e piccole sfumature matematiche su come scegliere esattamente le soluzioni migliori e quanto addestrarle e qual è la distribuzione dei prompt e come impostare l'esecuzione dell'addestramento in modo che funzioni. Quindi ci sono un sacco di piccoli dettagli e manopole all'idea di base che è molto, molto semplice. E quindi ottenere i dettagli giusti qui non è banale. E quindi molte aziende come, ad esempio, OpenAI e altri fornitori di LLM hanno sperimentato internamente il fine-tuning per apprendimento per rinforzo per LLM per un po', ma non ne hanno parlato pubblicamente. È tutto fatto all'interno dell'azienda. Ed è per questo che l'articolo di DeepSeek, uscito molto, molto di recente, è stato così importante, perché questo è un articolo di questa azienda chiamata DC Kai in Cina, e questo articolo ha parlato molto pubblicamente del fine-tuning per apprendimento per rinforzo per modelli linguistici di grandi dimensioni e di quanto sia incredibilmente importante per i modelli linguistici di grandi dimensioni e di come porti fuori molte capacità di ragionamento nei modelli.

Andremo in questo tra un secondo. Quindi questo articolo ha rivitalizzato l'interesse pubblico nell'uso dell'RL per gli LLM e ha fornito molti dei dettagli necessari per riprodurre i loro risultati e far funzionare effettivamente questa fase per i modelli linguistici di grandi dimensioni.

Quindi lasciami guidarti brevemente attraverso questo articolo DeepSeek RL1 e cosa succede quando si applica correttamente l'RL ai modelli linguistici e come appare e cosa ti dà.

Quindi la prima cosa a cui scorrerò è questa figura 2, dove stiamo guardando il miglioramento nel modo in cui i modelli risolvono i problemi matematici. Questa è l'accuratezza nella risoluzione dei problemi matematici sull'accuratezza A. E poi possiamo andare alla pagina web e vedere i tipi di problemi che sono effettivamente in questi, i tipi di problemi matematici che vengono misurati qui. Questi sono semplici problemi matematici, puoi mettere in pausa il video se vuoi, ma questi sono i tipi di problemi che fondamentalmente i modelli vengono invitati a risolvere. E puoi vedere che all'inizio non stanno andando molto bene, ma poi mentre aggiorni il modello con questi migliaia di passaggi, la loro accuratezza continua a salire. Quindi i modelli stanno migliorando e stanno risolvendo questi problemi con una maggiore accuratezza mentre fai questo tentativo ed errore su un ampio set di dati di questi tipi di problemi. E i modelli stanno scoprendo come risolvere problemi matematici.

Ma ancora più incredibile dei risultati quantitativi nel risolvere questi problemi con una maggiore accuratezza sono i mezzi qualitativi con cui il modello ottiene questi risultati. Quindi, quando scorriamo, una delle figure qui che è piuttosto interessante è che più tardi nell'ottimizzazione, la lunghezza media per risposta aumenta. Quindi il modello sembra usare più token per ottenere i suoi risultati di maggiore accuratezza. Quindi sta imparando a creare soluzioni molto, molto lunghe. Perché queste soluzioni sono così lunghe? Possiamo guardarle qualitativamente qui. Quindi fondamentalmente quello che scoprono è che le soluzioni del modello diventano molto, molto lunghe parzialmente perché, ecco una domanda e ecco una sorta di risposta dal modello. Quello che il modello impara a fare, ed è una proprietà emergente della nuova ottimizzazione, scopre semplicemente che questo è buono per la risoluzione dei problemi, è che inizia a fare cose come questa: "Aspetta, aspetta, aspetta, questo non è un momento. Posso segnalarlo. Rivalutiamo questo passo dopo passo per identificare la somma corretta. Può essere".

Quindi, cosa sta facendo il modello qui? Il modello sta fondamentalmente rivalutando i passaggi. Ha imparato che funziona meglio per l'accuratezza provare molte idee, provare qualcosa da diverse prospettive, ripercorrere, riformulare, tornare indietro. Sta facendo molte delle cose che tu e io stiamo facendo nel processo di risoluzione dei problemi matematici, ma sta riscoprendo cosa succede nella tua testa, non cosa metti nella soluzione. E non c'è nessun umano che possa codificare queste cose nella risposta ideale dell'assistente. Questa è solo una cosa che può essere scoperta nel processo di apprendimento per rinforzo perché non sapresti cosa mettere qui. Questo si rivela semplicemente funzionare per il modello e migliora la sua accuratezza nella risoluzione dei problemi.

Quindi il modello impara quello che chiamiamo queste catene di pensiero nella tua testa, ed è una proprietà emergente dell'ottimizzazione. Ed è questo che sta gonfiando la lunghezza della risposta, ma è anche questo che sta aumentando l'accuratezza della risoluzione dei problemi. Quindi quello che è incredibile qui è fondamentalmente che il modello sta scoprendo modi di pensare. Sta imparando quello che mi piace chiamare strategie cognitive su come manipoli un problema e come lo affronti da diverse prospettive, come porti alcune analogie o fai diversi tipi di cose del genere, e come provi molte cose diverse nel tempo, controlli un risultato da diverse prospettive e come risolvi i problemi. Ma qui è stato scoperto dall'RL, quindi è estremamente incredibile vedere questo emergere nell'ottimizzazione senza doverlo codificare da nessuna parte. L'unica cosa che gli abbiamo dato sono le risposte corrette, e questo deriva dal cercare semplicemente di risolverle correttamente, il che è incredibile.

Ora torniamo al problema con cui abbiamo lavorato e diamo un'occhiata a come apparirebbe per questo tipo di modello, quello che chiamiamo modello di ragionamento o di pensiero, per risolvere quel problema.

Quindi ricordiamo che questo è il problema con cui abbiamo lavorato e quando l'ho incollato in ChatGPT 4o, ottengo questo tipo di risposta. Diamo un'occhiata a cosa succede quando si dà la stessa query a quello che viene chiamato un modello di ragionamento o di pensiero. Questo è un modello che è stato addestrato con apprendimento per rinforzo. Quindi questo modello descritto in questo articolo DC Kai1 è disponibile su chat.deepseek.com. Quindi questa è una sorta di azienda che lo ha sviluppato, lo ospita. Devi assicurarti che il pulsante DeepSeek sia attivato per ottenere il modello RL1, come viene chiamato. Possiamo incollarlo qui ed eseguirlo. E quindi diamo un'occhiata a cosa succede ora e qual è l'output del modello.

Ok, ecco cosa dice. Quindi questo è quello che abbiamo ottenuto in precedenza usando fondamentalmente quello che è un approccio SFT, un approccio di fine-tuning supervisionato. Questo è come imitare una soluzione esperta. Questo è quello che otteniamo dal modello RL. Ok, cercherò di capirlo. Emily compra tre mele e due arance. Ogni arancia costa 2 dollari. Il totale è 13. Devo scoprire, bla bla bla. Quindi qui, mentre leggi questo, non puoi fare a meno di pensare che questo modello stia pensando. Sta sicuramente perseguendo la soluzione. Deriva che deve costare 3 dollari e poi dice: "Aspetta un secondo, ricontrolliamo la mia matematica per essere sicuri". E poi ci prova da una prospettiva leggermente diversa. E poi dice: "Sì, tutto torna. Penso che sia la risposta. Non vedo errori. Vediamo se c'è un altro modo per affrontare il problema. Forse impostare un'equazione. Sia il costo di una mela $8, allora bla bla bla. Sì, stessa risposta. Quindi sicuramente ogni mela costa 3 dollari. Ok, sono sicuro che sia corretto". E poi quello che fa, una volta che ha fatto il processo di pensiero, è scrivere la bella soluzione per l'umano. E quindi questo ora considera, questo riguarda più l'aspetto della correttezza e questo riguarda più l'aspetto della presentazione, dove lo scrive bene e incornicia la risposta corretta in fondo.

E quindi quello che è incredibile qui è che otteniamo questo processo di pensiero del modello, e questo è ciò che proviene dal processo di apprendimento per rinforzo. Questo è ciò che sta gonfiando la lunghezza delle sequenze di token. Stanno pensando e stanno provando modi diversi. Questo è ciò che ti dà una maggiore accuratezza nella risoluzione dei problemi. Ed è qui che stiamo vedendo questi momenti "aha" e queste diverse strategie e queste idee su come puoi assicurarti di ottenere la risposta corretta.

L'ultimo punto che volevo fare è che alcune persone sono un po' nervose riguardo all'inserimento di dati molto sensibili su chat.deepseek.com perché questa è un'azienda cinese. Quindi le persone sono un po' caute e riservate a riguardo. DeepSeek RL1 è un modello che è stato rilasciato da questa azienda. Quindi questo è un modello open source o con pesi aperti. È disponibile per chiunque da scaricare e utilizzare. Non sarai in grado di eseguirlo nella sua piena precisione, non lo eseguirai su un MacBook o su un dispositivo locale perché questo è un modello abbastanza grande. Ma molte aziende ospitano il modello più grande completo. Una di queste aziende che mi piace usare si chiama Together.ai. Quindi, quando vai su Together.ai, ti iscrivi e vai sui playground, puoi selezionare qui nella chat DeepSeek RL1 e ci sono molti altri tipi di modelli che puoi selezionare qui. Questi sono tutti modelli all'avanguardia. Quindi questo è simile all'area di gioco di inferenza di Hugging Face con cui abbiamo giocato finora, ma Together.ai ospiterà solitamente tutti i modelli all'avanguardia. Quindi seleziona DeepSeek RL1. Puoi provare a ignorare molti di questi. Penso che le impostazioni predefinite andranno spesso bene e possiamo metterlo qui. E poiché il modello è stato rilasciato da DeepSeek, quello che ottieni qui dovrebbe essere fondamentalmente equivalente a quello che ottieni qui. Ora, a causa della casualità nel campionamento, otterremo qualcosa di leggermente diverso, ma in linea di principio dovrebbe essere identico in termini di potenza del modello e dovresti essere in grado di vedere le stesse cose quantitativamente e qualitativamente. Ma questo modello proviene da un'azienda americana, quindi questo è DeepSeek ed è quello che viene chiamato un modello di ragionamento.

Ora, quando torno su ChatGPT, lasciami andare su ChatGPT. Ok, i modelli che vedrai nel menu a discesa qui, alcuni di essi come 01, 03 mini, O3 mini High, ecc., parlano di utilizzo del ragionamento avanzato. Quello a cui si riferisce l'utilizzo del ragionamento avanzato è il fatto che è stato addestrato tramite apprendimento per rinforzo con tecniche molto simili a quelle di DeepSeek RL1. Dichiarazioni pubbliche di dipendenti OpenAI. Quindi questi sono modelli di pensiero addestrati con RL. E questi modelli come GPT-4 o GPT-4o mini che ottieni nel livello gratuito, dovresti pensarli principalmente come modelli SFT, modelli di fine-tuning supervisionato. In realtà non fanno questo tipo di pensiero come vedi nei modelli RL. E anche se c'è un po' di apprendimento per rinforzo coinvolto con questi modelli, e ci entrerò tra un secondo, questi sono principalmente modelli SFT, penso che dovresti pensarla così.

Quindi, nello stesso modo di quello che abbiamo visto qui, possiamo scegliere uno dei modelli di pensiero come, diciamo, 03 mini High. E questi modelli, tra l'altro, potrebbero non essere disponibili a meno che tu non paghi un abbonamento a ChatGPT di 20 dollari al mese o 200 dollari al mese per alcuni dei modelli migliori. Quindi possiamo scegliere un modello di pensiero ed eseguirlo. Ora, quello che succederà qui è che dirà "ragionamento" e inizierà a fare cose come questa. E quello che stiamo vedendo qui non è esattamente quello che stiamo vedendo qui. Quindi, anche se sotto il cofano il modello produce questi tipi di catene di pensiero, OpenAI sceglie di non mostrare le esatte catene di pensiero nell'interfaccia web. Mostra brevi riassunti di quelle catene di pensiero. E OpenAI fa questo, penso in parte perché sono preoccupati per quello che viene chiamato il rischio di distillazione, cioè che qualcuno possa entrare e cercare di imitare quelle tracce di ragionamento e recuperare gran parte delle prestazioni di ragionamento semplicemente imitando le catene di pensiero di ragionamento. E quindi le nascondono e mostrano solo brevi riassunti di esse. Quindi non ottieni esattamente quello che otterresti in DeepSeek per quanto riguarda il ragionamento stesso. E poi scrivono la soluzione. Quindi questi sono in qualche modo equivalenti, anche se non vediamo i dettagli completi sotto il cofano.

Ora, in termini di prestazioni, questi modelli e i modelli DeepSeek sono attualmente alla pari. Direi che è difficile dirlo a causa delle valutazioni. Ma se stai pagando 200 dollari al mese a OpenAI, alcuni di questi modelli, credo, attualmente sembrano ancora migliori. Ma DeepSeek RL1 per ora è ancora una scelta molto solida per un modello di pensiero che ti sarà disponibile, diciamo, su questo sito web o su qualsiasi altro sito web, perché il modello è a pesi aperti, puoi semplicemente scaricarlo. Quindi questi sono modelli di pensiero.

Quindi qual è il riassunto finora? Bene, abbiamo parlato di apprendimento per rinforzo e del fatto che il pensiero emerge nel processo di ottimizzazione quando fondamentalmente eseguiamo RL su molti problemi matematici e di codice che hanno soluzioni verificabili. Quindi c'è una risposta, tre, ecc. Ora questi modelli di pensiero sono accessibili, ad esempio, in DeepSeek o in qualsiasi provider di inferenza come Together.ai e scegliendo DeepSeek lì. Questi modelli di pensiero sono anche disponibili in ChatGPT sotto qualsiasi dei modelli 01 o O3. Ma questi modelli GPT-4 R, ecc. non sono modelli di pensiero, dovresti pensarli principalmente come modelli SFT.

Ora, se hai un prompt che richiede ragionamento avanzato e così via, dovresti probabilmente usare alcuni dei modelli di pensiero o almeno provarli. Ma empiricamente, per molto del mio utilizzo, quando fai una domanda più semplice, una domanda basata sulla conoscenza o qualcosa del genere, questo potrebbe essere eccessivo. Non c'è bisogno di pensare 30 secondi a una domanda fattuale. Quindi per quello, a volte mi affido semplicemente a GPT-4o. Quindi empiricamente, circa l'80-90% del mio utilizzo è semplicemente GPT-4o, e quando mi imbatto in un problema molto difficile come in matematica e codice, ecc., mi rivolgo ai modelli di pensiero, ma poi devo aspettare un po' di più perché stanno pensando.

Quindi puoi accedervi su ChatGPT su DeepSeek. Inoltre, volevo sottolineare che AI Studio.google.com, anche se sembra molto affollato, molto brutto perché Google è semplicemente incapace di fare questo tipo di cose bene, è come "cosa sta succedendo?", ma se scegli il modello e scegli qui Gemini 2.0 Flash Thinking Experimental 01 21, se scegli quello, è anche un tipo di esperimento precoce di un modello di pensiero di Google. Quindi possiamo andare qui e dargli lo stesso problema e cliccare su Esegui, e questo è anche un modello di pensiero, un modello di pensiero che farà anche qualcosa di simile e otterrà la risposta corretta qui. Quindi fondamentalmente Gemini offre anche un modello di pensiero. Anthropic attualmente non offre un modello di pensiero, ma fondamentalmente questo è una sorta di sviluppo di frontiera di questi LLM. Penso che RL sia una sorta di nuova fase entusiasmante, ma ottenere i dettagli giusti è difficile. Ed è per questo che tutti questi modelli e modelli di pensiero sono attualmente sperimentali, a partire dal 2025, inizio 2025. Ma questo è una sorta di sviluppo di frontiera per spingere le prestazioni su questi problemi molto difficili usando il ragionamento che emerge in queste ottimizzazioni.

Un'altra connessione che volevo fare è che la scoperta che l'apprendimento per rinforzo è un modo estremamente potente di apprendere non è nuova nel campo dell'IA. E un posto dove l'abbiamo già visto dimostrato è nel gioco del Go. E famosamente DeepMind ha sviluppato il sistema AlphaGo e puoi guardare un film su di esso, dove il sistema impara a giocare a Go contro i migliori giocatori umani. E quando andiamo all'articolo alla base di AlphaGo, quindi in questo articolo, quando scorriamo, troviamo in realtà un grafico davvero interessante che penso ci sia familiare. E stiamo in qualche modo scoprendo nel dominio più aperto della risoluzione di problemi arbitrari invece che nel dominio chiuso e specifico del gioco del Go. Ma fondamentalmente quello che hanno visto, e lo vedremo anche negli LLM man mano che diventeranno più maturi, è questo: questo è il punteggio ELO di giocare a Go, e questo è Lee Sedol, un giocatore umano estremamente forte. E qui stiamo confrontando la forza di un modello addestrato con apprendimento supervisionato e un modello addestrato con apprendimento per rinforzo. Quindi il modello di apprendimento supervisionato sta imitando i giocatori esperti umani. Quindi, se ottieni solo un'enorme quantità di partite giocate da giocatori esperti nel gioco del Go e provi a imitarli, migliorerai, ma poi ti fermi e non diventi mai fondamentalmente migliore di alcuni dei migliori giocatori assoluti nel gioco del Go come Lee Sedol. Quindi non ci arriverai mai perché stai solo imitando giocatori umani. Non puoi fondamentalmente andare oltre un giocatore umano se stai solo imitando giocatori umani.

Ma in un processo di apprendimento per rinforzo è significativamente più potente. Nell'apprendimento per rinforzo per il gioco del Go, significa che il sistema sta facendo mosse che empiricamente e statisticamente portano alla vittoria del gioco. E quindi AlphaGo è un sistema in cui gioca contro se stesso e utilizza l'apprendimento per rinforzo per creare rollout. Quindi è esattamente lo stesso diagramma qui, ma non c'è nessun prompt, è solo un gioco di Go fisso perché non c'è nessun prompt, ma sta provando molte soluzioni, sta provando molte giocate, e poi le partite che portano a una vittoria invece di una risposta specifica vengono rinforzate, vengono rese più forti. E quindi il sistema sta fondamentalmente imparando le sequenze di azioni che empiricamente e statisticamente portano a vincere la partita. E l'apprendimento per rinforzo non sarà vincolato dalle prestazioni umane e l'apprendimento per rinforzo può fare significativamente meglio e superare anche i migliori giocatori come Lee Sedol. E quindi probabilmente avrebbero potuto eseguirlo più a lungo e hanno semplicemente scelto di tagliarlo a un certo punto perché questo costa denaro. Ma questa è una dimostrazione molto potente dell'apprendimento per rinforzo e stiamo solo iniziando a vedere accenni di questo diagramma nei modelli linguistici più grandi per problemi di ragionamento.

Quindi non andremo molto lontano semplicemente imitando gli esperti. Dobbiamo andare oltre, impostare questi piccoli ambienti di gioco e lasciare che il sistema scopra tracce di ragionamento o modi di risolvere problemi che sono unici e che semplicemente funzionano bene.

Ora, su questo aspetto dell'unicità, nota che quando stai facendo apprendimento per rinforzo, nulla ti impedisce di deviare dalla distribuzione di come gli umani giocano. E quindi, quando torniamo a questa ricerca di AlphaGo, una delle modifiche suggerite si chiama mossa 37. E la mossa 37 in AlphaGo si riferisce a un punto specifico nel tempo in cui AlphaGo ha fondamentalmente giocato una mossa che nessun esperto umano avrebbe giocato. Quindi la probabilità che questa mossa venisse giocata da un giocatore umano è stata valutata circa 1 su 10.000, quindi è una mossa molto rara. Ma col senno di poi, è stata una mossa brillante. Quindi AlphaGo, nel processo di apprendimento per rinforzo, ha scoperto una sorta di strategia di gioco che era sconosciuta agli umani, ma che col senno di poi è brillante. Raccomando questo video di YouTube, Lee Sedol contro AlphaGo, reazioni e analisi della mossa 37. E questo è un po' come è successo quando AlphaGo ha giocato questa mossa. "Valore, questa è una mossa molto, molto sorprendente. Pensavo, pensavo fosse un errore quando vedo questa mossa, comunque".

Quindi fondamentalmente le persone sono un po' in preda al panico perché è una mossa che un umano non giocherebbe che AlphaGo ha giocato perché nel suo addestramento questa mossa sembrava una buona idea. Semplicemente non è il tipo di cosa che gli umani farebbero. E quindi questo è di nuovo il potere dell'apprendimento per rinforzo. E in linea di principio, possiamo effettivamente vedere l'equivalenza di ciò se continuiamo a scalare questo paradigma nei modelli linguistici. E come appare è sconosciuto.

Quindi, cosa significa risolvere problemi in modo tale che anche gli umani non sarebbero in grado di farlo? Come puoi essere migliore nel ragionamento o nel pensiero rispetto agli umani? Come puoi andare oltre un semplice umano pensante? Forse significa scoprire analogie che gli umani non sarebbero in grado di creare.

O forse è come una nuova strategia di pensiero, è un po' difficile da elaborare, uh, forse è una lingua completamente nuova che in realtà non è nemmeno l'inglese, forse scopre una propria lingua che è molto migliore nel pensare, um, perché il modello non è vincolato nemmeno a rimanere sull'inglese, uh, quindi forse adotta una lingua diversa per pensare o scopre la propria lingua, quindi in linea di principio il comportamento del sistema è molto meno definito, è aperto a fare qualsiasi cosa funzioni ed è anche aperto a deviare lentamente dalla distribuzione dei suoi dati di addestramento, che è l'inglese, ma tutto ciò può essere fatto solo se abbiamo un insieme molto ampio e diversificato di problemi in cui questa strategia può essere affinata e perfezionata, e quindi gran parte della ricerca all'avanguardia sugli LM che sta avvenendo in questo momento sta cercando di creare quel tipo di distribuzioni di prompt che siano ampie e diverse, questi sono tutti come ambienti di gioco in cui gli LLM possono esercitare il loro pensiero e, uh, è un po' come scrivere, sapete, questi problemi di pratica, dobbiamo creare problemi di pratica per tutti i domini della conoscenza e se abbiamo problemi di pratica e tonnellate di essi, i modelli saranno in grado di apprendimento per rinforzo, apprendere su di essi e creare in qualche modo questi tipi di diagrammi, ma nel dominio del pensiero aperto invece di un dominio chiuso come il gioco del Go, c'è un'altra sezione all'interno dell'apprendimento per rinforzo che volevo coprire, ed è quella dell'apprendimento in domini non verificabili, quindi finora tutti i problemi che abbiamo esaminato sono in quelli che sono chiamati domini verificabili, il che significa che qualsiasi soluzione candidata possiamo valutare molto facilmente rispetto a una risposta concreta, quindi ad esempio la risposta è tre e possiamo valutare molto facilmente queste soluzioni rispetto alla risposta di tre, o richiediamo ai modelli di racchiudere le loro risposte in una scatola e poi controlliamo semplicemente l'uguaglianza di ciò che è nella scatola con la risposta, o si può anche usare, uh, una sorta di quello che viene chiamato un giudice LLM, quindi il giudice LLM guarda una soluzione e ottiene la risposta e fondamentalmente valuta la soluzione per vedere se è coerente con la risposta o meno, e gli LLM, empiricamente, sono abbastanza bravi con la capacità attuale che possono farlo in modo abbastanza affidabile, quindi possiamo applicare anche quel tipo di tecniche, in ogni caso abbiamo una risposta concreta e stiamo semplicemente controllando le soluzioni contro di essa e possiamo farlo automaticamente senza alcun umano nel ciclo. Il problema è che non possiamo applicare la strategia in quelli che sono chiamati domini non verificabili, quindi di solito questi sono, ad esempio, compiti di scrittura creativa come scrivere una barzelletta sui pellicani o scrivere una poesia o riassumere un paragrafo o qualcosa del genere, in questi tipi di domini diventa più difficile valutare le nostre diverse soluzioni a questo problema, quindi ad esempio scrivere una barzelletta sui pellicani, possiamo generare molte barzellette diverse, ovviamente va bene, ad esempio, possiamo andare su ChatGPT e possiamo fargli generare una barzelletta sui pellicani, così tante cose nei loro becchi perché non fanno il pellicano negli zaini, cosa ok, possiamo provare qualcos'altro, perché i pellicani non pagano mai le loro bevande? Perché le pagano sempre a qualcun altro, haha, ok, quindi questi modelli non sono ovviamente molto bravi nell'umorismo, in realtà penso che sia piuttosto affascinante perché penso che l'umorismo sia segretamente molto difficile e il modello abbia la capacità, penso comunque, in ogni caso, si potrebbe immaginare di creare molte barzellette, il problema che stiamo affrontando è come valutarle ora, in linea di principio potremmo ovviamente chiedere a un umano di guardare tutte queste barzellette, proprio come ho fatto io ora, il problema è che se stai facendo apprendimento per rinforzo, farai migliaia di aggiornamenti e per ogni aggiornamento vorrai guardare, diciamo, migliaia di prompt e per ogni prompt vorrai potenzialmente guardare, guardare centinaia o migliaia di diversi tipi di generazioni e quindi ci sono semplicemente troppi di questi da guardare e quindi, um, in linea di principio potresti avere un umano che ispeziona tutti e li valuta e decide che ok, forse questo è divertente e, uh, forse questo è divertente e questo è divertente, e potremmo addestrarci su di essi per rendere il modello leggermente migliore nelle barzellette, um, almeno nel contesto dei pellicani, um, il problema è che è semplicemente troppo tempo umano, questa è una strategia non scalabile, abbiamo bisogno di una sorta di strategia automatica per fare questo, e una sorta di soluzione a questo è stata proposta in questo articolo, uh, che ha introdotto quello che viene chiamato apprendimento per rinforzo da feedback umano, e quindi questo era un articolo di OpenAI all'epoca e molte di queste persone sono ora co-fondatori in Anthropic, um, e questo tipo di approccio proposto per, uh, fondamentalmente fare apprendimento per rinforzo in domini non verificabili, quindi diamo un'occhiata a come funziona, quindi questo è il diagramma a cartoni animati delle idee principali coinvolte, quindi come ho detto, l'approccio nativo è se avessimo tempo umano infinito, potremmo semplicemente eseguire RL in questi domini senza problemi, quindi ad esempio possiamo eseguire RL come al solito, se ho umani infiniti, voglio solo fare, e questi sono solo numeri a cartoni animati, voglio fare 1.000 aggiornamenti dove ogni aggiornamento sarà su 1.000 prompt e per ogni prompt avremo 1.000 rollout che stiamo valutando, quindi possiamo eseguire RL con questo tipo di configurazione, il problema è che nel processo di fare questo, avrò bisogno di eseguire, avrò bisogno di chiedere a un umano di valutare una barzelletta, un totale di 1 miliardo di volte, e quindi sono molte persone che guardano barzellette davvero terribili, quindi non vogliamo farlo, quindi invece vogliamo adottare l'approccio RLHF, quindi, uh, nel nostro approccio RLHF, siamo un po' come il trucco principale è quello dell'indirezione, quindi coinvolgeremo gli umani solo un po' e il modo in cui imbrogliamo è che fondamentalmente addestriamo una rete neurale completamente separata che chiamiamo modello di ricompensa, e questa rete neurale imiterà in qualche modo i punteggi umani, quindi chiederemo agli umani di valutare, uh, i rollout, quindi imiteremo i punteggi umani usando una rete neurale, e questa rete neurale diventerà una sorta di simulatore di preferenze umane, e ora che abbiamo un simulatore di rete neurale, possiamo fare RL contro di esso, quindi invece di chiedere a un umano reale, chiediamo a un umano simulato il suo punteggio di una barzelletta, come esempio, e quindi una volta che abbiamo un simulatore, siamo spesso razzisti perché possiamo interrogarlo quante volte vogliamo ed è tutto un processo automatico e possiamo ora fare apprendimento per rinforzo rispetto al simulatore, e il simulatore, come ci si potrebbe aspettare, non sarà un umano perfetto, ma se è almeno statisticamente simile al giudizio umano, allora ci si potrebbe aspettare che questo faccia qualcosa, e in pratica lo fa, quindi una volta che abbiamo un simulatore, possiamo fare RL e tutto funziona benissimo, quindi lasciate che vi mostri un diagramma a cartoni animati, un po' di quello che questo processo sembra, anche se i dettagli non sono importanti al 100%, è solo l'idea principale di come funziona, quindi qui ho un diagramma a cartoni animati di un esempio ipotetico di come sarebbe l'addestramento del modello di ricompensa, quindi abbiamo un prompt come "scrivi una barzelletta sui pellicani" e poi qui abbiamo cinque rollout separati, quindi queste sono tutte cinque barzellette diverse, proprio come questa, ora la prima cosa che faremo è che chiederemo a un umano di ordinare queste barzellette dalla migliore alla peggiore, quindi questo è, uh, quindi qui questo umano ha pensato che questa barzelletta fosse la migliore, la più divertente, quindi la barzelletta numero uno, questa è la barzelletta numero due, numero tre, quattro e cinque, quindi questa è la peggiore barzelletta, chiediamo agli umani di ordinare invece di dare punteggi direttamente perché è un compito un po' più facile, è più facile per un umano dare un ordine che dare punteggi precisi, ora questa è la supervisione per il modello, l'umano le ha ordinate e questo è in qualche modo il loro contributo al processo di addestramento, ma ora separatamente quello che faremo è che chiederemo a un modello di ricompensa, uh, del suo punteggio di queste barzellette, ora il modello di ricompensa è una rete neurale completamente separata, rete neurale completamente separata, uh, ed è probabilmente anche un trasformatore, uh, ma non è un modello linguistico nel senso che genera linguaggio diverso, ecc., è solo un modello di punteggio, quindi il modello di ricompensa prenderà come input il prompt numero uno e il numero due, una barzelletta candidata, quindi, uh, questi sono i due input che entrano nel modello di ricompensa, quindi qui, ad esempio, il modello di ricompensa prenderà questo prompt e questa barzelletta, ora l'output di un modello di ricompensa è un singolo numero, e questo numero è pensato come un punteggio e può variare, ad esempio, da zero a uno, quindi zero sarebbe il punteggio peggiore e uno sarebbe il punteggio migliore, quindi ecco alcuni esempi di quello che un modello di ricompensa ipotetico in una certa fase del processo di addestramento darebbe, uh, punteggi a queste barzellette, quindi 0,1 è un punteggio molto basso, 0,8 è un punteggio davvero alto e così via, e quindi ora confrontiamo i punteggi dati dal modello di ricompensa con l'ordine dato dall'umano, e c'è un modo matematico preciso per calcolarlo, fondamentalmente impostare una funzione di perdita e calcolare una sorta di corrispondenza qui, e aggiornare un modello in base ad essa, ma voglio solo darvi l'intuizione, che è che, ad esempio, per questa seconda barzelletta, l'umano ha pensato che fosse la più divertente e il modello è in qualche modo d'accordo, giusto, 0,8 è un punteggio relativamente alto, ma questo punteggio avrebbe dovuto essere ancora più alto, giusto, quindi dopo un aggiornamento ci aspetteremmo che forse questo punteggio dovrebbe essere, crescerà effettivamente dopo un aggiornamento della rete a, diciamo, 0,81 o qualcosa del genere, per questo qui, in realtà sono in un disaccordo massiccio perché l'umano ha pensato che questa fosse la numero due, ma qui il punteggio è solo 0,1 e quindi questo punteggio deve essere molto più alto, quindi dopo un aggiornamento su questa supervisione, questo potrebbe crescere molto di più, forse è 0,15 o qualcosa del genere, e poi qui l'umano ha pensato che questa fosse la peggiore barzelletta, ma qui il modello le ha dato un numero abbastanza alto, quindi ci si potrebbe aspettare che dopo l'aggiornamento, questo scenda a forse 3, 3,5 o qualcosa del genere, quindi fondamentalmente stiamo facendo quello che abbiamo fatto prima, stiamo leggermente spingendo le previsioni dai modelli usando un processo di addestramento di reti neurali e stiamo cercando di rendere i punteggi del modello di ricompensa coerenti con l'ordine umano, e quindi, uh, mentre aggiorniamo il modello di ricompensa sui dati umani, diventa un simulatore sempre migliore dei punteggi e degli ordini che gli umani forniscono, e poi diventa in qualche modo il simulatore delle preferenze umane, contro cui possiamo poi fare RL, ma in modo critico, non stiamo chiedendo agli umani un miliardo di volte di guardare una barzelletta, stiamo forse guardando 1.000 prompt e cinque rollout ciascuno, quindi forse 5.000 barzellette che gli umani devono guardare in totale, e danno solo l'ordine, e poi stiamo addestrando il modello ad essere coerente con quell'ordine, e sto saltando i dettagli matematici, ma voglio solo che capiate un'idea di alto livello che questo modello di ricompensa sta facendo, sta fondamentalmente fornendoci questo punteggio e abbiamo un modo per addestrarlo ad essere coerente con gli ordini umani, ed è così che funziona RLHF, ok, quindi questa è l'idea generale, fondamentalmente addestriamo simulatori di umani e RL rispetto a quei simulatori, ora voglio parlare prima del lato positivo dell'apprendimento per rinforzo da feedback umano, la prima cosa è che questo ci permette di eseguire apprendimento per rinforzo, che sappiamo essere un insieme di tecniche incredibilmente potenti, e ci permette di farlo in domini arbitrari, inclusi quelli che non sono verificabili, quindi cose come la sintesi e la scrittura di poesie, la scrittura di barzellette o qualsiasi altra scrittura creativa, in domini al di fuori della matematica e del codice, ecc. Ora empiricamente, quello che vediamo quando applichiamo RLHF è che questo è un modo per migliorare le prestazioni del modello, e ho una risposta principale sul perché potrebbe essere, ma in realtà non so che sia super ben consolidato su come questo sia, si può osservare empiricamente che quando si fa RLHF correttamente, i modelli che si ottengono sono solo un po' migliori, ma sul perché, penso che non sia così chiaro, quindi ecco la mia migliore ipotesi, la mia migliore ipotesi è che questo sia possibilmente dovuto principalmente al divario generatore-discriminatore, ciò che significa è che in molti casi è significativamente più facile discriminare che generare per gli umani, quindi in particolare un esempio di questo è quando facciamo il fine-tuning supervisionato, stiamo chiedendo agli umani di generare la risposta ideale dell'assistente e in molti casi qui, come ho mostrato, la risposta ideale è molto semplice da scrivere, ma in molti casi potrebbe non esserlo, quindi ad esempio nella sintesi o nella scrittura di poesie o nella scrittura di barzellette, come si suppone che tu, come etichettatore umano, dia la risposta ideale in questi casi, richiede scrittura creativa umana per farlo, e quindi RLHF aggira questo problema perché otteniamo, otteniamo di chiedere alle persone una domanda significativamente più facile, come etichettatori, non viene chiesto loro di scrivere poesie direttamente, vengono semplicemente date cinque poesie dal modello e viene chiesto loro solo di ordinarle, e quindi questo è solo un compito molto più facile per un etichettatore umano da fare, e quindi quello che penso che questo permetta fondamentalmente è che, uh, permette molti più dati di alta precisione perché non chiediamo alle persone di fare il compito di generazione che può essere estremamente difficile, come non chiediamo loro di fare scrittura creativa, stiamo solo cercando di far distinguere tra scritture creative e trovare quelle migliori, e questo è il segnale che gli umani forniscono, solo l'ordine, e questo è il loro input nel sistema, e quindi il sistema in RLHF scopre solo i tipi di risposte che sarebbero ben valutate dagli umani, e quindi quel passaggio di indirezione permette ai modelli di diventare un po' migliori, quindi questo è il lato positivo di RLHF, ci permette di eseguire RL, empiricamente si traduce in modelli migliori e permette alle persone di contribuire con la loro supervisione, anche senza dover fare compiti estremamente difficili, nel caso della scrittura di risposte ideali, sfortunatamente RLHF presenta anche svantaggi significativi, e quindi, il principale è che fondamentalmente stiamo facendo apprendimento per rinforzo non rispetto agli umani e al giudizio umano effettivo, ma rispetto a una simulazione con perdita di umani, e questa simulazione con perdita potrebbe essere fuorviante perché è solo una simulazione, è solo un modello linguistico che sta in qualche modo producendo punteggi e potrebbe non riflettere perfettamente l'opinione di un umano reale con un cervello reale in tutti i possibili casi diversi, quindi questo è il numero uno, che in realtà è qualcosa di ancora più sottile e insidioso che sta succedendo che trattiene drasticamente RLHF come tecnica che possiamo davvero scalare a sistemi significativamente intelligenti, ed è che l'apprendimento per rinforzo è estremamente bravo a scoprire un modo per barare il modello, per barare la simulazione, quindi questo modello di ricompensa che stiamo costruendo qui che dà i punteggi, questi modelli sono trasformatori, questi trasformatori sono reti neurali massive, hanno miliardi di parametri e imitano gli umani, ma lo fanno in una sorta di modo simulato, ora il problema è che questi sono sistemi massicci e complicati, ci sono un miliardo di parametri qui che producono un singolo punteggio, si scopre che ci sono modi per barare questi modelli, si possono trovare tipi di input che non facevano parte del loro set di addestramento, e questi input in modo inspiegabile ottengono punteggi molto alti, ma in modo falso, quindi molto spesso quello che trovi se esegui RLHF per molto tempo, ad esempio se facciamo 1.000 aggiornamenti che sono, diciamo, molti aggiornamenti, potresti aspettarti che le tue barzellette migliorino e che tu ottenga veri successi sui pellicani, ma non è esattamente quello che succede, quello che succede è che nei primi centinaia di passi le barzellette sui pellicani probabilmente migliorano un po', e poi cadono drasticamente dalla scogliera e inizi a ottenere risultati estremamente insensati, come ad esempio, la barzelletta migliore sui pellicani inizia ad essere "e questo non ha senso, giusto, quando la guardi, perché dovrebbe essere una barzelletta migliore, ma quando prendi il e lo inserisci nel tuo modello di ricompensa, ti aspetteresti un punteggio di zero, ma in realtà il modello di ricompensa ama questo come barzelletta, ti dirà che il il il il il è un punteggio di 1.0, questa è una barzelletta migliore, e questo non ha senso, giusto, ma è perché questi modelli sono solo simulazioni di umani e sono massive reti neurali e puoi trovare input in fondo che in qualche modo entrano nella parte dello spazio di input che ti dà risultati insensati, questi esempi sono quelli che sono chiamati esempi avversari, e non entrerò troppo nell'argomento, ma questi sono input avversari al modello, sono piccoli input specifici che in qualche modo entrano negli angoli e nelle fessure del modello e danno risultati insensati in cima, ora ecco cosa potresti immaginare di fare, dici ok, il il il non è ovviamente un punteggio di uno, è ovviamente un punteggio basso, quindi prendiamo il il il il, aggiungiamolo al set di dati e diamogli un ordine estremamente brutto, come un punteggio di cinque, e in effetti il tuo modello imparerà che il il dovrebbe avere un punteggio molto basso e gli darà un punteggio di zero, il problema è che ci sarà sempre fondamentalmente un numero infinito di esempi avversari insensati nascosti nel modello, se si itera questo processo molte volte e si continua ad aggiungere cose insensate al proprio modello di ricompensa e a dare loro punteggi molto bassi, non si vincerà mai la partita, si può fare questo per molti round e l'apprendimento per rinforzo, se lo si esegue abbastanza a lungo, troverà sempre un modo per barare il modello, scoprirà esempi avversari, otterrà punteggi molto alti con risultati insensati, e fondamentalmente, questa è perché la nostra funzione di punteggio è una gigantesca rete neurale e RL è estremamente bravo a trovare solo i modi per ingannarla, quindi in poche parole, si esegue sempre RLHF per forse qualche centinaio di aggiornamenti, il modello sta migliorando, e poi devi tagliarlo e hai finito, non puoi eseguire troppo contro questo modello di ricompensa perché l'ottimizzazione inizierà a bararlo, e fondamentalmente lo tagli e lo chiami e lo spedisci, e puoi migliorare il modello di ricompensa, ma in qualche modo ti imbatti in queste situazioni alla fine, a un certo punto, quindi RLHF fondamentalmente quello che dico di solito è che RLHF non è RL, e quello che intendo con questo è che RLHF è RL, ovviamente, ma non è RL nel senso magico, questo non è RL che puoi eseguire indefinitamente, questi tipi di problemi, dove stai ottenendo una risposta corretta, non puoi bararli così facilmente, o ottieni la risposta corretta o non la ottieni, e la funzione di punteggio è molto, molto più semplice, stai solo guardando l'area racchiusa e vedendo se il risultato è corretto, quindi è molto difficile barare queste funzioni, ma barare un modello di ricompensa è possibile, ora in questi domini verificabili puoi eseguire RL indefinitamente, potresti eseguire per decine di migliaia, centinaia di migliaia di passi e scoprire tutti i tipi di strategie davvero folli che potremmo non pensare mai di eseguire molto bene per tutti questi problemi, nel gioco del Go, non c'è modo di battere, fondamentalmente barare la vittoria di una partita o la sconfitta di una partita, abbiamo un simulatore perfetto, conosciamo tutte le diverse dove sono posizionate tutte le pietre e possiamo calcolare se qualcuno ha vinto o meno, non c'è modo di barare quello, e quindi puoi fare RL indefinitamente e puoi eventualmente battere anche Leol, ma con modelli come questo che sono barabili, non puoi ripetere questo processo indefinitamente, quindi vedo RLHF più come non vero RL perché la funzione di ricompensa è barabile, quindi è più nel regno di un piccolo fine-tuning, è un piccolo miglioramento, ma non è qualcosa che è fondamentalmente impostato correttamente dove puoi inserire più calcolo, eseguire più a lungo e ottenere risultati molto migliori e magici, quindi non è RL in quel senso, non è RL nel senso che manca di magia, può trovarti nel tuo modello e ottenere prestazioni migliori, e in effetti, se torniamo a ChatGPT, il modello GPT-4o è passato attraverso RLHF perché funziona bene, ma non è semplicemente RL nello stesso senso, RLHF è come un piccolo fine-tuning che migliora leggermente il tuo modello, è forse il modo in cui lo penserei, ok, quindi questo è la maggior parte del contenuto tecnico che volevo coprire, vi ho guidato attraverso le tre fasi e paradigmi principali dell'addestramento di questi modelli: pre-addestramento, fine-tuning supervisionato e apprendimento per rinforzo, e vi ho mostrato che corrispondono approssimativamente al processo che già usiamo per insegnare ai bambini, e in particolare abbiamo parlato del pre-addestramento come acquisizione di conoscenza di base della lettura, esposizione, fine-tuning supervisionato come processo di osservazione di molti, molti esempi svolti e imitazione di esperti e problemi di pratica, l'unica differenza è che ora dobbiamo effettivamente scrivere libri di testo per LLM e IA in tutte le discipline della conoscenza umana e anche in tutti i casi in cui vorremmo che funzionassero, come codice e matematica e, sapete, fondamentalmente tutte le altre discipline, quindi siamo nel processo di scrivere libri di testo per loro, affinare tutti gli algoritmi che ho presentato ad alto livello, e poi ovviamente fare un lavoro davvero, davvero buono nell'esecuzione dell'addestramento di questi modelli su larga scala ed efficiente, quindi in particolare non sono entrato in troppi dettagli, ma questi sono lavori estremamente grandi e complessi distribuiti, che devono essere eseguiti su decine di migliaia o addirittura centinaia di migliaia di GPU, e l'ingegneria che va in questo è davvero all'avanguardia di ciò che è possibile con i computer a quella scala, quindi non ho coperto quell'aspetto troppo, ma questo è molto serio e sono alla base di tutti questi algoritmi molto semplici in definitiva, ora ho anche parlato un po' della teoria della mente di questi modelli, e la cosa che voglio che portiate via è che questi modelli sono davvero bravi, ma sono strumenti estremamente utili per il vostro lavoro, non dovreste fidarvi completamente di loro, e vi ho mostrato alcuni esempi di ciò, anche se abbiamo mitigazioni per le allucinazioni, i modelli non sono perfetti e continueranno ad allucinare, è migliorato nel tempo e continuerà a migliorare, ma possono allucinare, in altre parole, in aggiunta a ciò, ho coperto quello che chiamo il modello "formaggio svizzero" delle capacità degli LLM, che dovreste avere in mente, i modelli sono incredibilmente bravi in ​​tante discipline diverse, ma poi falliscono casualmente in alcuni casi unici, quindi ad esempio, cosa è più grande, 9.11 o 9.9? Il modello non lo sa, ma allo stesso tempo può risolvere problemi di Olimpiadi, e quindi questo è un buco nel formaggio svizzero, e ce ne sono molti, e non vuoi inciamparci, quindi non trattare questi modelli come modelli infallibili, controlla il loro lavoro, usali come strumenti, usali per ispirazione, usali per la prima bozza, ma lavora con loro come strumenti e sii fondamentalmente responsabile del prodotto del tuo lavoro, e questo è all'incirca quello di cui volevo parlare, è così che vengono addestrati e questo è quello che sono, passiamo ora a quali sono alcune delle capacità future di questi modelli, probabilmente cosa sta arrivando e anche dove puoi trovare questi modelli, ho alcuni punti chiave su alcune delle cose che puoi aspettarti in arrivo, la prima cosa che noterai è che i modelli diventeranno molto rapidamente multimodali, tutto ciò di cui ho parlato sopra riguardava il testo, ma molto presto avremo LLM che non solo gestiranno il testo, ma potranno anche operare nativamente e molto facilmente sull'audio, quindi potranno sentire e parlare, e anche immagini, quindi potranno vedere e dipingere, e stiamo già vedendo gli inizi di tutto questo, ma tutto ciò sarà fatto nativamente all'interno del modello linguistico, e questo consentirà conversazioni naturali e, grosso modo, il motivo per cui questo non è diverso da tutto ciò di cui abbiamo parlato sopra è che, come base, puoi tokenizzare audio e immagini e applicare esattamente gli stessi approcci di tutto ciò di cui abbiamo parlato sopra, quindi non è un cambiamento fondamentale, è solo uno strumento che dobbiamo aggiungere alcuni token, quindi come esempio per tokenizzare l'audio, possiamo guardare fette dello spettrogramma del segnale audio e possiamo tokenizzarlo e semplicemente aggiungere più token che improvvisamente rappresentano l'audio e semplicemente aggiungerli alle finestre di contesto e addestrarli su di essi, proprio come sopra, lo stesso per le immagini, possiamo usare patch e possiamo tokenizzare separatamente le patch, e quindi cos'è un'immagine, un'immagine è solo una sequenza di token, e questo in realtà funziona, e c'è molto lavoro iniziale in questa direzione, e quindi possiamo semplicemente creare flussi di token che rappresentano audio, immagini e testo, e intercalarli e gestirli tutti contemporaneamente in un unico modello, quindi questo è un esempio di multimodalità, secondo, qualcosa che interessa molto alle persone è che attualmente la maggior parte del lavoro consiste nel fornire compiti individuali ai modelli su un piatto d'argento, come per favore risolvi questo compito per me, e il modello in qualche modo fa questo piccolo compito, ma spetta ancora a noi organizzare un'esecuzione coerente dei compiti per svolgere lavori, e i modelli non sono ancora alla capacità richiesta per farlo in modo coerente e correggendo gli errori per lunghi periodi di tempo, quindi non sono in grado di mettere insieme completamente i compiti per svolgere questi lavori più lunghi, ma ci stanno arrivando e questo sta migliorando nel tempo, ma probabilmente quello che succederà qui è che inizieremo a vedere quelli che sono chiamati agenti che svolgono compiti nel tempo, e tu li supervisioni e guardi il loro lavoro, e loro riportano i progressi di tanto in tanto, e così via, quindi vedremo agenti più a lungo termine, compiti che non richiedono solo pochi secondi di risposta, ma decine di secondi o anche minuti o ore nel tempo, ma questi modelli non sono infallibili, come abbiamo detto sopra, quindi tutto ciò richiederà supervisione, quindi ad esempio nelle fabbriche si parla del rapporto umano-robot per l'automazione, penso che vedremo qualcosa di simile nello spazio digitale, dove parleremo di rapporti umano-agente, dove gli umani diventano sempre più supervisori di compiti agenti nel dominio digitale, prossimo, penso che tutto diventerà molto più pervasivo e invisibile, è un po' come integrato negli strumenti e ovunque, e in aggiunta, un po' come l'uso del computer, ora questi modelli non sono in grado di agire per tuo conto, ma penso che questo sia un punto separato, se hai visto ChatGPT lanciare l'operatore, allora quello è un primo esempio di ciò, dove puoi effettivamente cedere il controllo al modello per eseguire azioni di tastiera e mouse per tuo conto, quindi anche questo è qualcosa che penso sia molto interessante, l'ultimo punto che ho qui è solo un commento generale sul fatto che c'è ancora molta ricerca da fare potenzialmente in questo dominio, un esempio di ciò è qualcosa lungo le linee dell'addestramento al momento del test, quindi ricordate che tutto ciò che abbiamo fatto sopra e di cui abbiamo parlato ha due fasi principali, c'è prima la fase di addestramento in cui ottimizziamo i parametri del modello per eseguire bene i compiti, una volta ottenuti i parametri, li fissiamo e poi distribuiamo il modello per l'inferenza, da lì il modello è fisso, non cambia più, non impara da tutto ciò che sta facendo al momento del test, è un numero fisso di parametri, e l'unica cosa che cambia ora sono i token all'interno delle finestre di contesto, e quindi l'unico tipo di apprendimento o apprendimento al momento del test a cui il modello ha accesso è l'apprendimento in contesto della sua finestra di contesto dinamicamente regolabile, a seconda di ciò che sta facendo al momento del test, ma penso che questo sia ancora diverso dagli umani che sono effettivamente in grado di imparare, a seconda di ciò che stanno facendo, specialmente quando dormi, ad esempio, il tuo cervello sta aggiornando i tuoi parametri o qualcosa del genere, giusto, quindi non c'è un equivalente di questo attualmente in questi modelli e strumenti, quindi ci sono molte idee più stravaganti che penso debbano essere esplorate ancora, e in particolare penso che questo sarà necessario perché la finestra di contesto è una risorsa finita e preziosa, e specialmente una volta che inizieremo ad affrontare compiti multimodali molto lunghi e metteremo video e queste finestre di token diventeranno estremamente grandi, non migliaia o addirittura centinaia di migliaia, ma significativamente oltre, e l'unico trucco, l'unico tipo di trucco che abbiamo a disposizione al momento è quello di allungare le finestre di contesto, ma penso che quell'approccio da solo non scalerà a compiti multimodali a lungo termine effettivi nel tempo, e quindi penso che siano necessarie nuove idee in alcune di quelle discipline, in alcuni di quei casi nel dominio in cui questi compiti richiederanno contesti molto lunghi, quindi questi sono alcuni esempi di alcune delle cose che puoi aspettarti in arrivo, passiamo ora a dove puoi effettivamente tenere traccia di questo progresso e, sai, essere aggiornato con le ultime novità di ciò che sta accadendo nel campo, quindi direi che le tre risorse che ho usato costantemente per rimanere aggiornato sono, numero uno, LMSYS Chatbot Arena, quindi lasciate che vi mostri Chatbot Arena, questo è fondamentalmente una classifica di LLM e classifica tutti i modelli migliori, e la classifica si basa su confronti umani, quindi gli umani mettono alla prova questi modelli e possono giudicare quale dà una risposta migliore, non sanno quale modello è quale, stanno solo guardando quale modello è la risposta migliore, e puoi calcolare una classifica e poi ottieni alcuni risultati, e quindi quello che puoi vedere qui sono le diverse organizzazioni come Google Gemini, ad esempio, che producono questi modelli, quando fai clic su uno qualsiasi di questi, ti porta al luogo in cui quel modello è ospitato, e quindi qui vediamo Google attualmente in testa, con OpenAI subito dietro, qui vediamo DeepSeek in posizione numero tre, ora il motivo per cui questo è importante è l'ultima colonna qui, vedi la licenza, DeepSeek è un modello con licenza MIT, è open weights, chiunque può usare questi pesi, chiunque può scaricarli, chiunque può ospitare la propria versione di DeepSeek e usarla nel modo che preferisce, quindi non è un modello proprietario a cui non hai accesso, è fondamentalmente una versione open weights, e quindi questo è senza precedenti che un modello così forte sia stato rilasciato con pesi aperti, quindi piuttosto interessante dal team, poi abbiamo alcuni altri modelli di Google e OpenAI, e poi quando continui a scorrere verso il basso, inizi a vedere altri soliti sospetti, quindi xAI qui, Anthropic con Claude Sonnet qui al numero 14, e poi Meta con Llama qui, quindi Llama, simile a DeepSeek, è un modello open weights, e quindi, ma è qui sotto invece che in alto, ora dirò che questa classifica è stata davvero buona per molto tempo, penso che negli ultimi mesi sia diventata un po' barata, e non mi fido più di quanto facessi prima, penso che empiricamente, sento che molte persone, ad esempio, stanno usando Sonnet di Anthropic ed è un modello davvero buono, ma è tutto in fondo qui, al numero 14, e al contrario, penso che non così tante persone stiano usando Gemini, ma si classifica molto, molto in alto, quindi penso che usala come prima passata, ma prova alcuni dei modelli per i tuoi compiti e vedi quale funziona meglio, la seconda cosa a cui mi riferirei è la newsletter AI News, quindi AI News non ha un nome molto creativo, ma è un'ottima newsletter prodotta da Swix e amici, quindi grazie per averla mantenuta, ed è stata molto utile per me perché è estremamente completa, quindi se vai negli archivi, vedi che viene prodotta quasi ogni due giorni, ed è molto completa, e parte di essa è scritta da umani e curata da umani, ma gran parte di essa è costruita automaticamente con LLM, quindi vedrai che sono molto complete e probabilmente non ti perdi nulla di importante se le scorri, ovviamente probabilmente non le scorrerai perché sono così lunghe, ma penso che questi riassunti in cima siano piuttosto buoni e penso che abbiano una supervisione umana, quindi questo è stato molto utile per me, e l'ultima cosa a cui mi riferirei è semplicemente X e Twitter, molto dell'IA avviene su X, quindi seguirei semplicemente le persone che ti piacciono e di cui ti fidi e otterresti tutte le ultime novità su X, quindi questi sono i posti principali che hanno funzionato per me nel tempo, e infine, qualche parola su dove puoi trovare i modelli e dove puoi usarli, quindi il primo che direi è che per i modelli proprietari più grandi, devi solo andare sul sito web di quel provider LLM, quindi ad esempio per OpenAI, è chat, credo che funzioni ora, quindi questo è per OpenAI, ora per Gemini, penso che sia gem.google.com o AI Studio, penso che ne abbiano due per ragioni che non capisco, nessuno lo capisce, per i modelli open weights come DeepSeek, ecc., devi andare su un qualche tipo di provider di inferenza di LLM, quindi il mio preferito è Together, together.ai, e ve l'ho mostrato, quando andate nel playground di together.ai, potete scegliere molti modelli diversi e tutti questi sono modelli aperti di diverso tipo e potete parlarci qui, come esempio, ora se voleste usare un modello base, come, sapete, un modello base, allora qui è dove penso che non sia così comune trovare modelli base, anche su questi provider di inferenza, sono tutti orientati agli assistenti e alle chat, e quindi penso che anche qui non potessi vedere modelli base qui, quindi per i modelli base, di solito vado su Perplexity perché servono il mio modello base Llama 3.1, e adoro quel modello, e puoi semplicemente parlarci qui, quindi per quanto ne so, questo è un buon posto per un modello base, e vorrei che più persone ospitassero modelli base perché sono utili e interessanti da lavorare in alcuni casi, infine, puoi anche prendere alcuni dei modelli più piccoli ed eseguirli localmente, e quindi ad esempio DeepSeek, il modello più grande, non sarai in grado di eseguirlo localmente sul tuo MacBook, ma ci sono versioni più piccole del modello DeepSeek che sono quelle che vengono chiamate distillate, e anche puoi eseguire questi modelli a precisione più bassa, quindi non alla precisione nativa di, ad esempio, fp8 su DeepSeek o, sai, bf16 Llama, ma molto più in basso di quello, e non preoccuparti se non capisci completamente questi dettagli, ma puoi eseguire versioni più piccole che sono state distillate e poi a precisione ancora più bassa, e quindi puoi adattarle al tuo computer, e quindi puoi effettivamente eseguire modelli abbastanza buoni sul tuo laptop, e il mio preferito, penso, posto dove vado di solito è LM Studio, che è fondamentalmente un'app che puoi ottenere, e penso che abbia un aspetto davvero brutto, e non mi piace che ti mostri tutti questi modelli che fondamentalmente non sono molto utili, come tutti vogliono solo eseguire DeepSeek, quindi non so perché ti diano questi 500 diversi tipi di modelli, sono davvero complicati da cercare e devi scegliere diverse distillazioni e diverse precisioni, ed è tutto davvero confuso, ma una volta che capisci come funziona e questo è un video completamente separato, allora puoi effettivamente caricare un modello, come qui ho caricato un Llama 3.2 instruct 1 miliardo, e puoi semplicemente parlarci, quindi chiedo barzellette sui pellicani e posso chiedere un'altra, e mi dà un'altra, ecc. Tutto questo che succede qui è localmente sul tuo computer, quindi non stiamo andando da nessun altro, questo sta girando sulla GPU del MacBook Pro, quindi questo è molto bello, e puoi quindi espellere il modello quando hai finito e questo libera la RAM, quindi LM Studio è probabilmente il mio preferito, anche se penso che abbia molti problemi di UI/UX ed è quasi orientato ai professionisti, ma se guardi alcuni video su YouTube, penso che tu possa capire come usare questa interfaccia, quindi queste sono alcune parole su dove trovarli, quindi lasciate che torni ora a dove abbiamo iniziato, la domanda era quando andiamo su chat.openai.com e inseriamo un qualche tipo di query e premiamo invio, cosa sta succedendo esattamente qui, cosa stiamo vedendo, di cosa stiamo parlando, come funziona, e spero che questo video ti abbia dato un po' di apprezzamento per alcuni dei dettagli sottostanti di come questi modelli vengono addestrati e cos'è questo che sta tornando, quindi in particolare ora sappiamo che la tua query viene presa e viene prima spezzettata in token, quindi andiamo al tokenizer e qui dove è il posto nel formato che è per la query dell'utente, fondamentalmente inseriamo la nostra query proprio lì, quindi la nostra query va in quello che abbiamo discusso qui è il formato del protocollo di conversazione, che è questo modo in cui manteniamo gli oggetti di conversazione, questo viene inserito lì, e poi tutto questo finisce per essere solo una sequenza di token, una sequenza di token unidimensionale sotto il cofano, quindi ChatGPT ha visto questa sequenza di token e poi quando premiamo invio, fondamentalmente continua ad aggiungere token a questa lista, continua la sequenza, agisce come un completamento automatico di token, quindi in particolare ci ha dato questa risposta, quindi possiamo fondamentalmente semplicemente metterla qui e vediamo i token che ha continuato, questi sono i token con cui ha continuato, approssimativamente, ora la domanda diventa, ok, perché questi sono i token con cui il modello ha risposto, da dove vengono questi token, di cosa stiamo parlando e come programmiamo questo sistema, ed è lì che abbiamo cambiato marcia e abbiamo parlato dei pezzi sottostanti, quindi la prima fase di questo processo, e ci sono tre fasi, è la fase di pre-addestramento, che fondamentalmente riguarda solo l'acquisizione di conoscenza da Internet nei parametri di questa rete neurale, e quindi la rete neurale interiorizza molta conoscenza da Internet, ma dove la personalità viene davvero fuori è nel processo di fine-tuning supervisionato, e quindi quello che succede qui è che fondamentalmente un'azienda come OpenAI cura un ampio set di dati di conversazioni, diciamo 1 milione di conversazioni su argomenti molto diversi, e ci saranno conversazioni tra un umano e un assistente, e anche se c'è molta generazione di dati sintetici utilizzata durante tutto questo processo e molta assistenza LLM e così via, fondamentalmente questo è un compito di cura dei dati umani con molti umani coinvolti, e in particolare questi umani sono etichettatori di dati assunti da OpenAI che ricevono istruzioni di etichettatura che imparano, e il loro compito è creare risposte ideali dell'assistente per qualsiasi prompt arbitrario, quindi stanno insegnando alla rete neurale per esempio come rispondere ai prompt, quindi qual è il modo di pensare a ciò che è tornato qui, cosa è questo, beh, penso che il modo giusto di pensarci sia che questa è la simulazione della rete neurale di un etichettatore di dati in OpenAI, è come se avessi dato questa query a un etichettatore di dati in OpenAI, e questo etichettatore di dati prima legge tutte le istruzioni di etichettatura di OpenAI, e poi trascorre 2 ore a scrivere la risposta ideale dell'assistente a questa query, e a darmela, ora non stiamo facendo questo in realtà, perché non abbiamo aspettato due ore, quindi quello che stiamo ottenendo qui è una simulazione della rete neurale di quel processo, e dobbiamo tenere presente che queste reti neurali non funzionano come i cervelli umani, sono diverse, ciò che è facile o difficile per loro è diverso da ciò che è facile o difficile per gli umani, e quindi stiamo davvero ottenendo solo una simulazione, quindi qui vi ho mostrato che questo è un flusso di token, e questo è fondamentalmente la rete neurale con un sacco di attivazioni e neuroni in mezzo, questa è un'espressione matematica finita che mescola input dai token con parametri del modello, e vengono mescolati e ti danno il token successivo in una sequenza, ma questo è un calcolo finito che avviene per ogni singolo token, e quindi questa è una sorta di simulazione con perdita di un umano che è in qualche modo limitato in questo modo, e quindi qualunque cosa scrivano gli umani, il modello linguistico sta in qualche modo imitando a livello di token con solo questa specifica computazione per ogni singolo token e sequenza, abbiamo anche visto che come risultato di questo e delle differenze cognitive, i modelli soffriranno in una varietà di modi, e devi stare molto attento al loro uso, quindi ad esempio abbiamo visto che soffriranno di allucinazioni, e hanno anche il senso di un modello svizzero delle capacità degli LLM, dove fondamentalmente ci sono buchi nel formaggio, a volte i modelli faranno semplicemente qualcosa di stupido arbitrariamente, quindi anche se stanno facendo un sacco di cose magiche, a volte semplicemente non possono, quindi forse non gli stai dando abbastanza token per pensare, e forse inventeranno cose perché la loro aritmetica mentale si rompe, forse sono improvvisamente incapaci di contare il numero di lettere, o forse sono incapaci di dirti che 9.11 è più piccolo di 9.9, e sembra un po' stupido, quindi è una capacità a formaggio svizzero, e dobbiamo stare attenti a questo, e abbiamo visto le ragioni per questo, ma fondamentalmente questo è come pensiamo a ciò che è tornato, è di nuovo una simulazione di questa rete neurale di un etichettatore di dati umano che segue le istruzioni di etichettatura in OpenAI, quindi è quello che stiamo ottenendo indietro, ora penso che le cose cambino un po' quando effettivamente raggiungi uno dei modelli di pensiero come GPT-4o, e la ragione è che GPT-4o fondamentalmente non fa apprendimento per rinforzo, fa RLHF, ma vi ho detto che RLHF non è RL, non c'è tempo per la magia lì dentro, è solo un po' di fine-tuning è il modo di vederlo, ma questi modelli di pensiero usano RL, quindi passano attraverso questa terza fase di perfezionamento del loro processo di pensiero e scoperta di nuove strategie di pensiero e soluzioni alla risoluzione di problemi che assomigliano un po' al tuo monologo interiore nella tua testa, e si esercitano su una vasta collezione di problemi di pratica che aziende come OpenAI creano e curano, e poi rendono disponibili agli LLM, quindi quando vengo qui e parlo con un modello di pensiero e inserisco questa domanda, quello che stiamo vedendo qui non è più solo la simulazione diretta di un etichettatore di dati umano, questo è in realtà qualcosa di nuovo, unico e interessante, e ovviamente OpenAI non ci sta mostrando il pensiero sottostante e le catene di pensiero che sono alla base del ragionamento qui, ma sappiamo che una cosa del genere esiste, e questo è un riassunto di essa, e quello che stiamo ottenendo qui non è solo un'imitazione di un etichettatore di dati umano, è in realtà qualcosa che è nuovo, interessante ed eccitante nel senso che è una funzione di pensiero che è emersa in una simulazione, non sta solo imitando un etichettatore di dati umano, proviene da questo processo di apprendimento per rinforzo, e quindi qui ovviamente non gli diamo la possibilità di brillare perché questo non è un problema matematico o di ragionamento, questo è solo un qualche tipo di problema di scrittura creativa, grosso modo, e penso che sia una domanda aperta se le strategie di pensiero sviluppate all'interno di domini verificabili si trasferiscano e siano generalizzabili ad altri domini che non sono verificabili, come la scrittura creativa, l'estensione a cui avviene quel trasferimento è sconosciuta nel campo, direi, quindi non siamo sicuri se siamo in grado di fare RL su tutto ciò che è molto verificabile e vedere i benefici di ciò su cose che non sono verificabili come questo prompt, quindi questa è una domanda aperta, l'altra cosa interessante è che questo apprendimento per rinforzo qui è ancora troppo nuovo, primordiale e nascente, quindi stiamo solo vedendo gli inizi dei primi segni di grandezza nei problemi di ragionamento, stiamo vedendo qualcosa che in linea di principio è capace di qualcosa come l'equivalente della mossa 37, ma non nel gioco del Go, ma nel pensiero e nella risoluzione di problemi di dominio aperto, in linea di principio questo paradigma è capace di fare qualcosa di veramente bello, nuovo ed eccitante, qualcosa che nemmeno un umano ha mai pensato prima, in linea di principio questi modelli sono capaci di analogie che nessun umano ha mai avuto, quindi penso che sia incredibilmente eccitante che questi modelli esistano, ma di nuovo, è molto presto e questi sono modelli primordiali per ora, e brilleranno principalmente in domini verificabili come matematica e codice, ecc., quindi molto interessante da giocare, pensare e usare, e poi questo è all'incirca tutto, direi che queste sono le linee generali di ciò che è disponibile ora, dirò che nel complesso è un momento estremamente eccitante per essere nel campo, personalmente uso questi modelli tutto il tempo, quotidianamente, decine o centinaia di volte, perché accelerano drasticamente il mio lavoro, penso che molte persone vedano la stessa cosa, penso che vedremo un'enorme creazione di ricchezza come risultato di questi modelli, sii consapevole di alcune delle loro carenze, anche con i modelli RL, soffriranno di alcuni di questi, usali come strumenti in una cassetta degli attrezzi, non fidarti completamente di loro perché faranno casualmente cose stupide, allucineranno casualmente, salteranno casualmente alcuni calcoli mentali e non li faranno bene, casualmente non riescono a contare o qualcosa del genere, quindi usali come strumenti nella cassetta degli attrezzi, controlla il loro lavoro e possiedi il prodotto del tuo lavoro, ma usali per ispirazione, per la prima bozza, fai loro domande, ma controlla e verifica sempre, e avrai molto successo nel tuo lavoro se lo fai, quindi spero che questo video sia stato utile e interessante per te, spero che ti sia divertito e è già molto lungo, quindi mi scuso per questo, ma spero che sia stato utile e sì, ci vediamo più tardi.