Introduzione all’uso dei Transformer e di Hugging Face

Introduzione

Il grande contributo dei ricercatori nell’ambito dell’NLP, acronimo di Natural Language Processing, negli ultimi decenni ha prodotto risultati innovativi in diversi settori. Di seguito alcuni esempi di NLP in pratica:

• L’assistente personale Siri di Apple, che può aiutare gli utenti nelle attività quotidiane come impostare sveglie, inviare messaggi, rispondere a domande, ecc.
• I ricercatori in ambito medico usano l’NLP per aprire la strada a una scoperta dei farmaci più rapida.  
• La traduzione automatica è un’altra grande applicazione, perché ci permette di superare le barriere comunicative.  

Questo articolo concettuale mira a trattare i Transformer, uno dei modelli più potenti mai creati nel Natural Language Processing. Dopo aver spiegato i loro vantaggi rispetto alle reti neurali ricorrenti, costruiremo la tua comprensione dei Transformer. Poi, ti guideremo in alcuni scenari reali usando i transformer di Hugging Face.

Puoi anche approfondire con il nostro code-along su come sviluppare applicazioni NLP con Hugging Face.

Reti ricorrenti — l’epoca d’oro prima dei Transformer 

Prima di entrare nel concetto chiave dei transformer, capiamo brevemente cosa sono i modelli ricorrenti e quali limiti hanno.

Le reti ricorrenti impiegano un’architettura encoder–decoder e si usano soprattutto quando si affrontano compiti in cui sia l’input che l’output sono sequenze con un certo ordinamento. Alcune delle applicazioni più importanti delle reti ricorrenti sono la traduzione automatica e la modellazione di serie temporali.

Le sfide delle reti ricorrenti 

Consideriamo di tradurre la seguente frase francese in inglese. L’input trasmesso all’encoder è la frase originale in francese, e l’output tradotto viene generato dal decoder.

Una semplice illustrazione della rete ricorrente per la traduzione automatica

• La frase francese di input viene passata all’encoder una parola dopo l’altra, e le embedding delle parole sono generate dal decoder nello stesso ordine, il che le rende lente da addestrare.
• Lo stato nascosto della parola corrente dipende dagli stati nascosti delle parole precedenti, il che rende impossibile eseguire calcolo in parallelo a prescindere dalla potenza di calcolo disponibile. 
• Le reti neurali sequence-to-sequence sono soggette a gradienti esplosivi quando la rete è troppo lunga, con conseguenti prestazioni scarse. 
• Le reti Long Short-Term Memory (LSTM), un altro tipo di rete ricorrente, sono state introdotte per mitigare il problema del gradiente che svanisce, ma risultano persino più lente dei modelli sequenziali. 

Non sarebbe fantastico avere un modello che unisca i vantaggi delle reti ricorrenti e renda possibile il calcolo in parallelo? 

Ed è qui che entrano in gioco i transformer.

Cosa sono i transformer nell’NLP?

I Transformer sono la nuova architettura di rete neurale semplice ma potente introdotta da Google Brain nel 2017 con il celebre paper “Attention is all you need.” Si basa sul meccanismo di attenzione invece che sul calcolo sequenziale come avviene nelle reti ricorrenti. 

Quali sono i componenti principali dei transformer?

Analogamente alle reti ricorrenti, anche i transformer hanno due blocchi principali: encoder e decoder, ciascuno con un meccanismo di self-attention. La prima versione dei transformer prevedeva un’architettura encoder–decoder con RNN e LSTM, poi sostituita da self-attention e reti feed-forward.

La sezione seguente fornisce una panoramica generale dei componenti principali di ciascun blocco dei transformer. 

Architettura generale dei transformer (adattata dall’autore)

Fase di preprocessing della frase di input

Questa fase contiene due passaggi principali: (1) la generazione delle embedding della frase di input e (2) il calcolo del vettore posizionale di ciascuna parola nella frase. Tutti i calcoli sono eseguiti allo stesso modo sia per la frase sorgente (prima del blocco encoder) sia per la frase target (prima del blocco decoder). 

Embedding dei dati di input

Prima di generare le embedding dei dati di input, si inizia con la tokenizzazione, poi si crea l’embedding di ogni singola parola senza considerare le relazioni tra loro nella frase. 

Positional encoding

La tokenizzazione elimina qualsiasi nozione di relazione presente nella frase di input. Il positional encoding cerca di ricreare la natura ciclica originale generando un vettore di contesto per ogni parola. 

Blocco encoder 

Al termine del passaggio precedente, otteniamo per ogni parola due vettori: (1) l’embedding e (2) il suo vettore di contesto. Questi vettori vengono sommati per creare un singolo vettore per parola, che viene poi trasmesso all’encoder. 

Multi-head attention

Come detto in precedenza, abbiamo perso ogni nozione di relazione. L’obiettivo dello strato di attenzione è catturare le relazioni contestuali esistenti tra le diverse parole nella frase di input. Questo passaggio porta a generare un vettore di attenzione per ogni parola.

Rete feed-forward position-wise (FFN)

A questo punto, a ogni vettore di attenzione viene applicata una rete neurale feed-forward per trasformarlo in un formato atteso dal successivo strato di multi-head attention nel decoder.

Blocco decoder

Il blocco decoder è composto da tre strati principali: masked multi-head attention, multi-head attention e una rete feed-forward position-wise. Conosciamo già gli ultimi due, che sono gli stessi presenti nell’encoder. 

Il decoder entra in gioco durante l’addestramento della rete e riceve due input principali: (1) i vettori di attenzione della frase di input che vogliamo tradurre e (2) le frasi target tradotte in inglese. 

Quindi, di cosa si occupa lo strato di masked multi-head attention?

Durante la generazione della parola successiva in inglese, la rete può usare tutte le parole della frase in francese. Tuttavia, quando si considera una data parola nella sequenza target (traduzione inglese), la rete deve poter accedere solo alle parole precedenti, perché rendere disponibili le successive porterebbe la rete a “barare” e a non imparare correttamente. È qui che lo strato di masked multi-head attention mostra tutta la sua utilità: maschera le parole successive trasformandole in zeri, in modo che non possano essere usate dalla rete di attenzione. 

Il risultato del masked multi-head attention passa attraverso gli altri strati per prevedere la parola successiva generando un punteggio di probabilità. 

Questa architettura ha avuto successo per i seguenti motivi:

• La complessità computazionale totale a ogni strato è inferiore rispetto alle RNN. 
• Elimina completamente la necessità di ricorrenza e permette la parallelizzazione delle sequenze, a differenza delle RNN che si aspettano input in sequenza. 
• Le RNN non sono efficienti nell’apprendere da sequenze a lungo raggio a causa della lunghezza dei percorsi dei segnali in avanti e indietro nella rete. Questo percorso viene accorciato con la self-attention, che migliora il processo di apprendimento.

Transfer learning nell’NLP

Addestrare da zero reti neurali profonde come i transformer non è un compito facile e può presentare le seguenti sfide: 

• Trovare la quantità di dati necessaria per il problema target può richiedere molto tempo
• Ottenere le risorse computazionali necessarie, come le GPU, per addestrare reti così profonde può essere molto costoso.  

L’uso del transfer learning può offrire molti vantaggi, come ridurre i tempi di training, velocizzare l’addestramento di nuovi modelli e diminuire i tempi di consegna del progetto.

Immagina di costruire un modello da zero per tradurre la lingua Mandingo in Wolof, entrambe lingue a basse risorse. Raccogliere dati relativi a queste lingue è costoso. Invece di affrontare tutte queste difficoltà, si possono riutilizzare reti neurali profonde pre-addestrate come punto di partenza per addestrare il nuovo modello. 

Tali modelli sono stati addestrati su un enorme corpus di dati, resi disponibili da altri (persone, organizzazioni, ecc.) e valutati come molto efficaci in compiti di traduzione come dal francese all’inglese. 

Se sei alle prime armi con l’NLP, questo corso Introduction to Natural Language Processing in Python può fornirti le competenze fondamentali per affrontare e risolvere problemi reali.

Ma cosa significa riutilizzare reti neurali profonde?

Il riutilizzo del modello consiste nello scegliere un modello pre-addestrato simile al tuo caso d’uso, preparare i dati di coppie input–output del tuo compito target e riaddestrare la “testa” del modello pre-addestrato usando i tuoi dati. 

L’introduzione dei Transformer ha portato allo sviluppo di modelli di transfer learning allo stato dell’arte come: 

• BERT, acronimo di Bidirectional Encoder Representations from Transformers, sviluppato dai ricercatori di Google nel 2018. Aiuta a risolvere i compiti linguistici più comuni come named entity recognition, sentiment analysis, question answering, riassunto di testi, ecc. Leggi di più su BERT in questo tutorial NLP.
• GPT‑3 (Generative Pre-Training‑3), proposto dai ricercatori di OpenAI. È un transformer multistrato, usato principalmente per generare qualsiasi tipo di testo. I modelli GPT sono in grado di produrre risposte testuali simili a quelle umane a una data domanda. Questo straordinario articolo può fornirti informazioni più approfondite su cosa rende unico GPT‑3, sulla tecnologia che lo alimenta, sui suoi rischi e sui suoi limiti.

Introduzione ai Transformer di Hugging Face

Hugging Face è una community di AI e una piattaforma di Machine Learning creata nel 2016 da Julien Chaumond, Clément Delangue e Thomas Wolf. Mira a democratizzare l’NLP offrendo a Data Scientist, professionisti dell’AI e ingegneri accesso immediato a oltre 20.000 modelli pre-addestrati basati sull’architettura di transformer allo stato dell’arte. Questi modelli si possono applicare a:

• Testo in oltre 100 lingue per svolgere compiti come classificazione, estrazione di informazioni, question answering, generazione e traduzione. 
• Audio/vocale, per compiti come classificazione di audio e riconoscimento vocale. 
• Visione per rilevamento oggetti, classificazione di immagini, segmentazione.
• Dati tabellari per problemi di regressione e classificazione. 
• Reinforcement Learning con transformer. 

Hugging Face Transformers fornisce anche quasi 2000 dataset e API stratificate, permettendo ai programmatori di interagire facilmente con questi modelli usando quasi 31 librerie. La maggior parte sono librerie di deep learning, come Pytorch, Tensorflow, Jax, ONNX, Fastai, Stable-Baseline 3, ecc. 

Questi corsi sono un’ottima introduzione all’uso di Pytorch e Tensorflow rispettivamente per costruire reti neurali convoluzionali profonde. Altri componenti dei Transformer di Hugging Face sono le Pipelines. 

Cosa sono le Pipeline nei Transformer?

• Offrono un’API facile da usare tramite il metodo pipeline() per eseguire inferenza su una varietà di compiti.
• Vengono usate per incapsulare l’intero processo di ogni attività di NLP, come pulizia del testo, tokenizzazione, embedding, ecc.

Il metodo pipeline() ha la seguente struttura: 

from transformers import pipeline

# To use a default model & tokenizer for a given task(e.g. question-answering)
pipeline("<task-name>")

# To use an existing model
pipeline("<task-name>", model="<model_name>")

# To use a custom model/tokenizer
pipeline('<task-name>', model='<model name>',tokenizer='<tokenizer_name>')

Tutorial su Hugging Face: EDIZIONE IN CORSO …

Ora che hai una comprensione migliore dei Transformer e della piattaforma Hugging Face, ti guideremo attraverso i seguenti scenari reali: traduzione automatica, classificazione di sequenze con zero-shot classification, sentiment analysis e question answering. 

Informazioni sui dataset

Questo dataset disponibile su Datacamp’s Dataset è stato arricchito da Facebook ed è stato creato per prevedere la popolarità di un articolo prima della pubblicazione. L’analisi sarà basata sulla colonna description. Per illustrare gli esempi, useremo solo tre esempi dal dataset. 

Di seguito una breve descrizione dei dati. Ha 14 colonne e 1428 righe.

import pandas as pd
# Load the data from the path
data_path = "datacamp_workspace_export_2022-08-08 07_56_40.csv"
news_data = pd.read_csv(data_path, error_bad_lines=False)




# Show data information
news_data.info()

Traduzione automatica

MarianMT è un framework efficiente per la traduzione automatica. Usa il motore MarianNMT sotto il cofano, sviluppato interamente in C++ da Microsoft e da molte istituzioni accademiche come l’Università di Edimburgo e l’Università Adam Mickiewicz di Poznań. Lo stesso motore è attualmente alla base del servizio Microsoft Translator. 

Il gruppo NLP dell’Università di Helsinki ha reso open source numerosi modelli di traduzione su Hugging Face Transformers e sono tutti nel formato Helsinki-NLP/opus-mt-{src}-{tgt} dove {src} e {tgt} corrispondono rispettivamente alle lingue sorgente e target. 

Nel nostro caso, la lingua sorgente è l’inglese (en) e la lingua target è il francese (fr)

MarianMT è uno di questi modelli, precedentemente addestrato con Marian su dati paralleli raccolti su Opus.

• MarianMT richiede sentencepiece oltre a Transformers:

pip install transformers sentencepiece
from transformers import MarianTokenizer, MarianMTModel

• Seleziona il modello pre-addestrato, ottieni il tokenizer e carica il modello pre-addestrato

# Get the name of the model
model_name = 'Helsinki-NLP/opus-mt-en-fr'

# Get the tokenizer
tokenizer = MarianTokenizer.from_pretrained(model_name)
# Instantiate the model
model = MarianMTModel.from_pretrained(model_name)

• Aggiungi il token speciale >>{tgt}<< davanti a ciascun testo sorgente (inglese) con l’aiuto della seguente funzione.

def format_batch_texts(language_code, batch_texts):
    formated_bach = [">>{}<< {}".format(language_code, text) for text in     

                batch_texts]
return formated_bach

• Implementa la logica di traduzione a batch con la seguente funzione, dove un batch è una lista di testi da tradurre.

def perform_translation(batch_texts, model, tokenizer, language="fr"):

  # Prepare the text data into appropriate format for the model
  formated_batch_texts = format_batch_texts(language, batch_texts)
 
  # Generate translation using model
  translated = model.generate(**tokenizer(formated_batch_texts,

                                          return_tensors="pt", padding=True))

  # Convert the generated tokens indices back into text
  translated_texts = [tokenizer.decode(t, skip_special_tokens=True) for t in translated]
 
  return translated_texts

• Esegui la traduzione sui precedenti esempi di descrizioni

# Check the model translation from the original language (English) to French
translated_texts = perform_translation(english_texts, trans_model, trans_model_tkn)

# Create wrapper to properly format the text
from textwrap import TextWrapper
# Wrap text to 80 characters.
wrapper = TextWrapper(width=80)

for text in translated_texts:
  print("Original text: \n", text)
  print("Translation : \n", text)
  print(print(wrapper.fill(text)))
  print("")

Zero-shot classification

Molto spesso, l’addestramento di un modello di Machine Learning richiede che tutte le etichette/target candidate siano note in anticipo: significa che, se le tue etichette di training sono scienza, politica o istruzione, non sarai in grado di prevedere l’etichetta sanità a meno di riaddestrare il modello, tenendo conto di quell’etichetta e dei relativi dati di input. 

Questo approccio potente consente di prevedere il target di un testo in circa 15 lingue senza aver visto alcuna delle etichette candidate. Possiamo usare questo modello semplicemente caricandolo dall’hub. 

L’obiettivo qui è cercare di classificare la categoria di ciascuna delle descrizioni precedenti, che sia tech, politics, security o finance. 

• Importa il modulo pipeline

from transformers import pipeline

• Definisci le etichette candidate. Corrispondono a ciò che vogliamo prevedere: tech, politics, business o finance

candidate_labels = ["tech", "politics", "business", "finance"]

• Definisci il classificatore con l’opzione multilingue

my_classifier = pipeline("zero-shot-classification",  

                           model='joeddav/xlm-roberta-large-xnli')

• Esegui le previsioni sulla prima e sull’ultima descrizione 

#For the first description
prediction = my_classifier(english_texts[0], candidate_labels, multi_class = True)
pd.DataFrame(prediction).drop(["sequence"], axis=1)

Testo previsto principalmente come finance 

Questo risultato mostra che il testo è complessivamente relativo alla finanza all’81%. 

Per l’ultima descrizione, otteniamo il seguente risultato:

#For the last description
prediction = my_classifier(english_texts[-1], candidate_labels, multi_class = True)
pd.DataFrame(prediction).drop(["sequence"], axis=1)

Testo previsto principalmente come tech 

Questo risultato mostra che il testo è complessivamente relativo alla tecnologia al 95%.

Sentiment analysis

La maggior parte dei modelli che eseguono la classificazione del sentiment richiede un adeguato addestramento. Il modulo pipeline di Hugging Face rende semplice eseguire previsioni di sentiment analysis usando un modello specifico disponibile sull’hub, specificandone il nome. 

• Scegli il compito da eseguire e carica il modello corrispondente. Qui vogliamo eseguire la classificazione del sentiment usando il modello base Distilled BERT. 

model_checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"

distil_bert_model = pipeline(task="sentiment-analysis", model=model_checkpoint)

• Il modello è pronto! Analizziamo i sentimenti sottostanti dietro le ultime due frasi. 

# Run the predictions
distil_bert_model(english_texts[1:])

Il modello ha previsto che il primo testo abbia un sentiment negativo con il 96% di confidenza e che il secondo abbia un sentiment positivo con il 52% di confidenza. 

Se vuoi approfondire i compiti di sentiment analysis, questo corso di Python sulla Sentiment Analysis ti aiuterà a sviluppare le competenze per creare un tuo classificatore di sentiment con Python e comprendere le basi dell’NLP.

Question answering

Immagina di avere a che fare con un report molto più lungo di quello su Apple. E tutto ciò che ti interessa è la data dell’evento menzionato. Invece di leggere l’intero report per trovare l’informazione chiave, possiamo usare un modello di question answering di Hugging Face che fornirà la risposta che ci interessa. 

Questo si può fare fornendo al modello il contesto adeguato (il report su Apple) e la domanda alla quale siamo interessati a trovare risposta.

• Importa la classe di question answering e il tokenizer da transformers

from transformers import AutoModelForQuestionAnswering, AutoTokenizer

• Istanzia il modello usando il suo nome e il relativo tokenizer. 

model_checkpoint = "deepset/roberta-base-squad2"

task = 'question-answering'
QA_model = pipeline(task, model=model_checkpoint, tokenizer=model_checkpoint)

• Interroga il modello ponendo la domanda e specificando il contesto. 

QA_input = {
          'question': 'when is Apple hosting an event?',
          'context': english_texts[-1]
          }

• Ottieni il risultato del modello

model_response = QA_model(QA_input)
pd.DataFrame([model_response])

Il modello ha risposto che l’evento di Apple è il 10 settembre con un’alta confidenza del 97%. 

Conclusione

In questo articolo abbiamo trattato l’evoluzione della tecnologia del linguaggio naturale dalle reti ricorrenti ai transformer e come Hugging Face abbia democratizzato l’uso dell’NLP attraverso la sua piattaforma. 

Se esiti ancora a usare i transformer, crediamo sia il momento di provarli e portare valore ai tuoi casi d’uso.