Guida per professionisti LLM: Llama-2 multilingue

Nel luglio 2023 Meta ha rilasciato Llama-2, una famiglia di large language model open-access che si è rapidamente affermata come riferimento per chi voleva maggiore controllo su sicurezza dei dati e personalizzazione del modello. A differenza dell’uso di modelli generici di terze parti, Llama-2 ha aperto la strada a implementazioni su misura e a casi d’uso specializzati, spesso in grado di superare i benchmark standard.

Disponibile su Hugging Face, Llama-2 è stato rilasciato in tre taglie: 7B, 13B e 70B parametri. Può essere usato sia come modello base sia come chat model per dialogo e question answering. Meta ha inoltre introdotto CodeLlama, una variante specializzata per attività di coding.

Se lavorate in AI e vi serve un large language model personalizzato, è probabile che Llama-2 sia passato almeno una volta nella vostra shortlist. Noi lo abbiamo usato a fondo per personalizzazione, fine-tuning e deployment. In questa serie condividiamo ciò che Llama-2 sa fare davvero, i suoi limiti e le pratiche che abbiamo trovato più efficaci sul campo.

Guida per professionisti LLM:

• Quanto è davvero multilingue Llama-2?
• Struttura dei prompt di Llama-2 (in arrivo)

In questo articolo analizziamo quello che, in pratica, è il limite più serio di Llama-2: il supporto linguistico. Per alcune lingue europee funziona bene; estenderlo con risultati solidi a molte altre lingue è invece molto più difficile. Vediamo perché.

Le strade che Llama-2 non percorre: capire i suoi limiti linguistici

Alla base dei limiti di Llama-2 c’è il suo tokenizer, cioè il componente che determina come il testo viene spezzato e rappresentato.

I large language model come Llama-2 lavorano su numeri. Per interpretare il testo devono prima convertirlo in una rappresentazione numerica. La difficoltà centrale del NLP è proprio trovare il modo più efficiente di rappresentare una lingua in forma numerica.

Un primo approccio consiste nell’assegnare un numero a ogni lettera o simbolo: “a” diventa 1, “b” diventa 2 e così via. Il modello prova poi a prevedere il numero successivo nella sequenza. È un metodo semplice da capire, ma molto inefficiente: anche una frase corta si trasforma in una lunga catena numerica, e un errore su un carattere si propaga facilmente a tutto il resto.

Una seconda opzione consiste nell’associare un numero a ogni parola. La sequenza si accorcia molto, ma anche qui il costo cresce in fretta: solo l’inglese ha oltre 200.000 parole, e un modello che copre più lingue dovrebbe distinguere fra milioni di possibili elementi.

Per superare questi problemi, la ricerca ha adottato un compromesso: la tokenizzazione. Le parole vengono suddivise in unità più piccole e ricorrenti. Per esempio, “predicting” può essere spezzata in “pred”, “ict” e “ing”. Così il modello non lavora più lettera per lettera o parola per parola, ma su sequenze più compatte e gestibili. In inglese, questo può ridurre lo spazio delle scelte da un intero dizionario a circa 2.000 token utili.

Vediamo ora più da vicino il tokenizer di Llama-2.

Per prima cosa lo importiamo dalla libreria Transformers di Hugging Face:

> from transformers import AutoTokenizer
> tokenizer = AutoTokenizer.from_pretrained('meta-llama/Llama-2-7b-hf', use_fast=True)

Il tokenizer di Llama-2 gestisce un vocabolario di ben 32.000 token:

> print(tokenizer.vocab_size)

32000

Vediamolo in azione con questo esempio:

> print(tokenizer.tokenize('Call me Ishmael. Some years ago...'))

['▁Call', '▁me', '▁I', 'sh', 'ma', 'el', '.', '▁Some', '▁years', '▁ago', ...]

L’output mostra una tokenizzazione piuttosto efficiente: le parole comuni restano compatte, mentre quelle più complesse vengono spezzate in segmenti ancora sensati. È un buon segnale.

Proviamolo ora su una frase tedesca. Anche se non conoscete tutte le lingue citate, il criterio resta semplice: una buona tokenizzazione produce meno token e mediamente più lunghi; una cattiva tokenizzazione genera più token, spesso molto corti.

> print(tokenizer.tokenize('Da steh ich nun, ich armer Tor! Und bin so klug als wie zuvor.'))

['▁Da', '▁ste', 'h', '▁ich', '▁nun', ',', '▁ich', '▁ar', 'mer', '▁Tor', '!', ...]

Qui il tokenizer si comporta bene, e lo fa su una lingua che dal punto di vista computazionale è più complessa dell’inglese.

Vediamo ora come si comporta con il francese.

> print(tokenizer.tokenize("On ne voit bien qu'avec le cœur..."))

['▁On', '▁ne', '▁voit', '▁bien', '▁qu', "'", 'ave', 'c', '▁le', '▁c', 'œur', ...]

Anche qui la rappresentazione è convincente.

Se restiamo nell’area romanza e germanica, Llama-2 regge abbastanza bene. Il quadro cambia quando passiamo alle lingue slave. Iniziamo dal polacco.

> print(tokenizer.tokenize('Litwo, ojczyzno moja! Ty jesteś jak zdrowie...'))

['▁Lit', 'wo', ',', '▁o', 'j', 'czy', 'z', 'no', '▁mo', 'ja', '!', ...]

Il polacco è notoriamente più complesso sul piano computazionale, e il calo di qualità si vede subito: i token diventano più piccoli e più numerosi.

Passiamo ora all’ucraino.

> print(tokenizer.tokenize('Як умру, то поховайте мене на могилі...'))

['▁Я', 'к', '▁у', 'м', 'ру', ',', '▁то', '▁по', 'х', 'ова', 'й', 'те', ...]

Anche qui il pattern è simile: molti token corti, segnale di una tokenizzazione poco efficiente.

Non è il caso peggiore possibile, ma siamo già lontani da un buon risultato. Passiamo al greco.

> print(tokenizer.tokenize('ἄνδρα μοι ἔννεπε, Μοῦσα, πολύτροπον...'))

['▁', 'ἄ', 'ν', 'δ', 'ρ', 'α', '▁', 'μ', 'ο', 'ι', '▁', 'ἔ', 'ν', 'ν', 'ε', 'π', 'ε', ...]

Qui siamo nel caso peggiore: il tokenizer torna, di fatto, a una rappresentazione quasi interamente carattere per carattere.

E con l’ebraico?

> print(tokenizer.tokenize('בְּרֵאשִׁית בָּרָא אֱלֹהִים...'))

['▁', 'ב', 'ְ', 'ּ', 'ר', 'ֵ', 'א', 'ש', 'ִ', 'ׁ', 'י', 'ת', ...]

Anche qui il comportamento è sostanzialmente a livello di carattere.

E il cinese?

> print(tokenizer.tokenize("道可道，非常道。名可名，非常名。"))

['▁', '道', '可', '道', '，', '非', '常', '道', '。', '名', '可', '名', '，', '非', '常', '名', '。']

Anche in questo caso il risultato è sostanzialmente carattere per carattere.

Se continuiamo il test su altre lingue, il pattern resta questo: Llama-2 si comporta bene con molte lingue romanze e germaniche, ma degrada rapidamente sulle altre.

Meta ha dichiarato apertamente che Llama-2 è stato addestrato su un corpus composto per circa il 90% da inglese. È un’avvertenza importante, ma rischia di far pensare che il problema sia solo di training. In realtà il modello non è stato soltanto addestrato principalmente in inglese: è stato progettato con quell’impostazione in mente.

Leggendo la documentazione, qualcuno potrebbe pensare che basti addestrare Llama-2 su più dati non inglesi per migliorarlo sensibilmente. In parte il fine-tuning aiuta, ma non risolve il problema strutturale del tokenizer. Per questo Llama-2 tende a funzionare meglio in lingue come inglese, tedesco, spagnolo o francese, e molto meno bene in lingue come polacco o ucraino. Estenderlo con buoni risultati a greco, ebraico, cinese e molte altre lingue è ancora più difficile. E dato che il tokenizer è strettamente accoppiato al modello, non esiste una scorciatoia semplice.

Noi stessi abbiamo provato a fare fine-tuning di Llama-2 su task multilingui usando oltre un miliardo di token supervisionati e accuratamente curati. A metà progetto abbiamo comunque dovuto cambiare modello.

Se dovete adattare un modello a una di queste lingue più difficili, Llama-2 potrebbe non essere la scelta giusta. In molti casi è più sensato partire da un modello più piccolo, magari anche più vecchio, ma con un tokenizer migliore per la lingua target. La nostra esperienza sui modelli multilingui va chiaramente in questa direzione.

Costruire un LLM personalizzato può migliorare sicurezza dei dati, compliance e vantaggio competitivo del prodotto. Negli altri articoli approfondiamo che cos’è l’effetto rete e come l’AI lo abilita, come costruire un vantaggio competitivo basato sull’AI, quale cultura aiuta a costruire i giusti prodotti AI, cosa evitare nella strategia e nell’esecuzione AI e altro ancora.