CBOW un progenitore degli LLM: costruiamone uno da zero (Parte 1)

·

7 min

Paper originale

Questo articolo è stato scritto al 100% da un umano

C’è stato un tempo non molto lontano in cui gli LLM non esistevano. Era il 2013 quando Google faceva nascere un pacchetto Word2Vec che usava un nuovo modello chiamato CBOW, Continuous Bag of Words.
Cos’è un CBOW? È un modello capace di predire una parola basandosi sul contesto, ovvero sulle parole che le stanno attorno. Vi ricorda qualcosa?
Scrivo questo articolo forse un po’ anacronistico perché a mio avviso è un ottimo punto di partenza per apprendere come funzionano gli LLM moderni, capirne l’evoluzione e la struttura.
Come funziona un CBOW? Per capirlo proviamo a costruirne uno.

Partiamo dalle basi: token, vettori ed embedding.

Prima di iniziare capiamo meglio cosa fa un modello testuale predittivo. Un LLM è in grado di formulare frasi, rispondere a domande e creare del testo in base al concetto di probabilità.
Ad es. se chiediamo “Cosa mangia il gatto?” il modello potrebbe rispondere “Il topo”. Come ha recuperato questa risposta? Il modello è andato a calcolare quale parola del suo “vocabolario” è la risposta più probabile data questa domanda.
Come fa a sapere qual è la risposta più probabile? L’ha “imparato” durante la fase di training in cui ha letto molte volte in molti testi che il gatto mangia il topo.

Fin qui tutto semplice, ma nella pratica come posso dire che questa risposta è più probabile di un’altra? Ora inizio a spiegarlo.

Cos’è un token?

Prendiamo la frase:

“Il gatto mangia il topo”

Per far sì che questa frase sia comprensibile da una macchina bisogna per prima cosa renderla matematica ovvero trasformarla in numeri; si suddivide la frase in tanti piccoli elementi ad es.

[Il] [gatto] [mangia] [il] [topo]

Questi piccoli elementi sono proprio i token. In questo caso ogni parola è un token. Manteniamo questa logica per semplicità, nella realtà la suddivisione può variare in base alla parola che stiamo analizzando (per chi è interessato questo processo si chiama tokenization).

Ora che abbiamo i nostri token il sistema deve trasformarli in qualcosa di numerico e per fare ciò utilizza i vettori, quindi:

[Il] = [0.2, 0.6]
[gatto] = [0.3, 0.8]
[mangia] = [0.21, 0.75]
….

Quando il nostro modello legge la nostra frase non vedrà delle parole ma una serie di numeri (una serie di vettori). Questo gli permetterà (lo vedremo in seguito) di effettuare calcoli matematici per capire quale parola del vocabolario (quale vettore) è più probabile.
In questo esempio il vettore ha solo 2 numeri, ma nella realtà sono molti di più.

Il vettore associato a una parola viene chiamato embedding.

Ma come si calcolano i vettori? Come posso dire che “gatto” è uguale a [0.3, 0.8]?

Il materiale che serve per costruire il nostro modello

  • Vocabolario
  • Dataset di contenuti

Iniziamo a costruire il nostro CBOW come fosse un mobile dell’Ikea. Apriamo la scatola e prepariamo tutto il materiale che serve per montarlo.

Potete trovare tutto il codice e i dati utilizzati in questa repository di github: https://github.com/codeplus-it/italian-cbow-example

La prima cosa di cui abbiamo bisogno è un “vocabolario”. Un insieme di parole da tenere in memoria per poi poterle trasformare nei nostri vettori. Per semplificare prenderemo un vocabolario ridotto di 1078 parole (rif. vocabolario.txt). Sono abbastanza per analizzare frasi come:
“Il gatto mangia il topo”
“Il cane mangia l’osso”
“Il cane non miagola”
“Il cane gioca con la palla”

ecc.

Il secondo pezzo che serve sono dei contenuti e delle frasi (rif. frasi.txt) che servono per far “allenare” il nostro modello. Le frasi devono contenere le parole del nostro vocabolario.

Si inizia a lavorare

Molto bene, ora abbiamo vocabolario e frasi, ma è ancora tutto scritto in lettere e parole, il primo lavoro da fare è quello di creare gli embedding, cioè di trasformare le parole in vettori per farle capire alla macchina.
Ma come li calcoliamo?
Inizialmente lo facciamo in modo completamente casuale.
Strano, vero? Questo perché non ci interessa lo “stato iniziale”, questi vettori andranno poi modificati e aggiustati durante la fase di training. In questa fase potremmo associare qualsiasi numero (vettore) alle nostre parole.

Possiamo scrivere un piccolo script Python per associare ad ogni parola un vettore casuale.

Quindi ora siamo pronti?
No, non ancora: manca un pezzettino, quello che definiamo come “punteggi”. Cosa sono e a cosa servono?
Abbiamo detto che ad ogni parola viene associato un vettore che la identifica, oltre a questo però ad ogni parola viene associato anche un altro vettore, un vettore punteggio.

Facciamo un esempio così si capisce meglio:
Prendiamo la parola “gatto”. Abbiamo associato a “gatto” un vettore che la identifica: [0.3, 0.8]. Ora associamo a “gatto” un punteggio che sarà anche lui un vettore di 2 dimensioni ad es. [0.2,-0.9]. E così dobbiamo fare per tutte le parole del nostro vocabolario. Come vengono calcolati i punteggi? Anche in questo caso in modo casuale, verranno poi ricalibrati durante il training come i vettori delle parole.

Ma perché 2 vettori? Non ne basta solo uno? I 2 vettori servono per scopi differenti: vedremo tra poco come i due si incontrano per scegliere la parola mancante.

La fase più bella, quella del training

Abbiamo tolto tutti i pezzi dallo scatolone e li abbiamo messi ognuno al proprio posto, abbiamo vocabolario, frasi e punteggi, ora siamo pronti all’azione. Possiamo iniziare con il training del nostro primo modello.

Come funziona il training?

Per iniziare facciamo leggere al nostro modello le nostre frasi con un pezzetto mancante, ad es.
“Il gatto ___ il topo”.
Il modello dovrà indovinare qual è la parola mancante e lo farà confrontando i vari vettori. Essendo i vettori creati in maniera completamente casuale, inizialmente quasi sicuramente sbaglierà. Quando confronterà la sua risposta con la parola corretta andrà a ricalibrare i vettori in modo da ridurre l’errore.

Spieghiamolo meglio con degli esempi:

Il modello legge la nostra frase “Il gatto ___ il topo” e la tokenizza.
Una volta letta crea una “previsione” della parola mancante. Ovviamente lo fa a modo suo, quindi non in lettere e parole, ma in vettore. Crea un “vettore previsione”. Come? Facendo la media dei vettori delle parole del contesto. Ad es:

il = [0.2, 0.6]
gatto = [0.3, 0.8]
il = [0.2, 0.6]
topo = [0.2, 0.6]

Fa una semplice media. Per il primo valore (0.2+0.3+0.4+0.2)/4 = 0.275 mentre per il secondo valore (0.6+0.8-0.6+0.6)/4 = 0.35.
Quindi il “vettore previsione” sarà:
[0.275, 0.35]
Abbiamo il “vettore previsione”: come lo confrontiamo con il “vocabolario” per capire quale parola è più probabile? Usando il vettori dei punteggi.
Qui capiamo i ruoli differenti dei 2 vettori: per le parole del contesto abbiamo usato il vettore che le identifica (l’embedding), per le possibili risposte usiamo il loro vettore punteggio.
Andiamo a fare il prodotto scalare tra il vettore_previsione e il vettore_punteggio di ogni parola:

risultato['parola'] = [vettore_previsione] x [vettore_punteggio]

Quindi:

risultato['il'] = [0.275, 0.35] x [-0.4, 0.2] = −0.04
risultato['gatto'] = [0.275, 0.35] x [0.2,-0.9] = −0.26
risultato['mangia'] = [0.275, 0.35] x [0.3, 0.5] = 0.2575
risultato['topo'] = [0.275, 0.35] x [0.1, 0.7] = 0.2725

In questo caso risponderebbe (sbagliando) “topo”. Nel prossimo articolo vedremo come il modello impari da questo errore e migliori.