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

·

6 min

Paper originale

Questo articolo è stato scritto al 100% da un umano

Questo articolo, come il precedente, sarà principalmente teorico, nel prossimo vedremo di mettere in pratica tutte le cose che abbiamo descritto creando il modello vero e proprio.

Riprendiamo da dove eravamo rimasti (qui il link alla parte 1).
Abbiamo visto che il modello ha provato a creare un vettore previsione per la frase “Il gatto ___ il topo” e dal vettore previsione ha selezionato, sbagliando, la parola “topo”.
Come impara dai propri errori?

Prima di vedere la parte matematica proviamo a spiegarlo a parole: una volta che il modello scopre la parola esatta ha bisogno di correggere i vari vettori assegnati ad ogni token. Deve farlo in modo che la prossima volta, quando troverà la stessa frase o una frase simile, avrà più probabilità di selezionare la parola corretta e meno probabilità di selezionare quelle sbagliate.

Probabilità e softmax

Dal punto di vista concettuale il ragionamento è abbastanza semplice: prendo la lista delle mie parole (token), aumento la probabilità della parola “mangia” e abbasso la probabilità per le altre parole (token).

Ma come si fa ad aumentare e diminuire la probabilità?
Per prima cosa dobbiamo portare i risultati ottenuti in probabilità, quindi con un valore compreso tra 0 e 1. Per farlo utilizziamo la formula della softmax.
Lo stato di partenza era:
risultato[‘il’] = −0,04
risultato[‘gatto’] = −0,26
risultato[‘mangia’] = 0,2575
risultato[‘topo’] = 0,2725

Con la softmax diventano:

ParolaPunteggioeˣProbabilità
il−0,040,96122,1%
gatto−0,260,77117,8%
mangia0,25751,29429,8%
topo0,27251,31330,3%
Somma4,339100%
Softmax e probabilità calcolata per ogni token

Come l’abbiamo calcolata? Vediamo un esempio: “gatto” diventa e⁻⁰’²⁶ = 0,771 e poi si normalizza con 0,771/4,339 = 0,178.

Ok, ora abbiamo le probabilità, come ci aspettavamo “topo” è sopra a “mangia” e questo non va bene.

Correggiamo i nostri punteggi

Vediamo ora quanto la probabilità calcolata si discosta dalla risposta corretta e qual è l’errore per ogni parola.

L’errore per ogni parola = probabilità calcolata − probabilità corretta,

ad es. errore per “mangia” = 0,298 – 1 = -0,702

ilgattomangiatopo
+0,221+0,178−0,702+0,303
Errore per ogni parola

Il prossimo step è quello di calcolare di quanto spostare i nostri vettori punteggio. Per farlo si usa la gradient descent update rule:
nuovo punteggio = punteggio − learning rate × errore × vettore previsione

dove il learning rate è un valore che viene deciso all’inizio del training. Per questo esempio lo manteniamo a 0,5 per far capire meglio lo spostamento. Solitamente è un numero più piccolo.

Con l’esempio di mangia:
nuovo punteggio = [0,3, 0,5] – 0,5 x -0,702 x [0,275, 0,35] = [0,397, 0,623]

ParolaErrore− 0,5 × erroreSpostamento (× previsione)Nuovo punteggio
il+0,221−0,111[−0,030, −0,039][−0,430, 0,161]
gatto+0,178−0,089[−0,024, −0,031][0,176, −0,931]
mangia−0,702+0,351[+0,097, +0,123][0,397, 0,623]
topo+0,303−0,151[−0,042, −0,053][0,058, 0,647]
Calcolo nuovo vettore punteggio

Non si correggono solo le risposte, ma anche gli indizi

Nel punto precedente abbiamo corretto le risposte, cioè i punteggi. Ora correggiamo gli indizi, cioè le parole del contesto (il, gatto, il, topo), in modo che la loro media, il vettore previsione, si avvicini al punteggio della parola giusta e si allontani da quelli delle parole sbagliate.

Riprendiamo quindi i vettori punteggio del primo articolo (precedenti alla correzione) e calcoliamo la direzione dello spostamento. Come?

Direzione = SUM(vettore_punteggio x errore_parola)
Nel nostro caso:
0,221 × [-0,4, 0,2] + 0,178 × [0,2, -0,9] + (-0,702) × [0,3, 0,5] + 0,303 × [0,1, 0,7] = [−0,233, −0,255]
Dove prendendo il primo valore (parola “il”): 0,221 è l’errore calcolato (vedi tabella precedente) e [-0,4, 0,2] è il vettore punteggio (vedi articolo precedente).

Ora che abbiamo la direzione possiamo calcolare lo spostamento:
Spostamento = – learning_rate x direzione / nr. token_contesto
Nel nostro caso: – 0,5 x [−0,233, −0,255] / 4 = [0,029, 0,032]

Applichiamo lo spostamento, quindi sommiamo il vettore spostamento all’embedding e il risultato è:

Parola del contestoPrimaSpostamentoDopo
il[0,2, 0,6]2 × [+0,029, +0,032][0,258, 0,664]
gatto[0,3, 0,8][+0,029, +0,032][0,329, 0,832]
topo[0,4, −0,6][+0,029, +0,032][0,429, −0,568]

Come potete notare, abbiamo escluso la parola “mangia” perché non compariva nel contesto, non era un valore che influiva sul vettore previsione e quindi non va corretta. Inoltre, siccome “il” compare 2 volte nel contesto, lo spostamento gli viene applicato due volte.

Il concetto di loss

Per poter proseguire dobbiamo inserire un nuovo concetto: quello della “loss”. Cos’è la loss?
La loss è una misura di quanto la risposta del modello è lontana da quella corretta. In poche parole più alta è la probabilità che il modello assegna alla parola giusta, più la loss è bassa.

Per calcolarla si usa -ln(prob parola giusta) quindi:
-ln(0,298) = 1,21066179248

  • Se il modello fosse sicuro della risposta giusta, la loss sarebbe 0.
  • Se tirasse a caso tra le 4 parole (25% di probabilità) sarebbe -ln(0,25) ≈ 1,39

Non è importante ricordare la formula, ma capirne il concetto sì, perché la utilizzeremo anche più avanti ed è una delle principali metriche per capire se il modello sta imparando o meno.

Riproviamo a calcolare le probabilità con il nuovo vettore previsione e i nuovi vettori punteggio e questo è quello che otteniamo:

ParolaPrimaDopo
il22,1%21,0%
gatto17,8%16,5%
mangia29,8%32,8%
topo30,3%29,7%
Loss1,211,11
Probabilità prima e dopo un passo di correzione: ora “mangia” è la prima risposta

Ora “mangia” è il risultato più probabile e la loss è calata da 1,21 a 1,11.

In generale, una loss che scende indica che il modello sta migliorando; vedremo nel prossimo articolo che bisogna fare attenzione alle frasi su cui la misuriamo.