By James Briggs, Scienziato dei dati

BERT, ma in Italia — immagine dell'autore

Molti dei miei articoli si sono concentrati su BERT, il modello che è arrivato e ha dominato il mondo dell’elaborazione del linguaggio naturale (PNL) e ha segnato una nuova era per i modelli linguistici.

Per quelli di voi che potrebbero non aver utilizzato prima i modelli di trasformatori (ad esempio, cos'è BERT), il processo assomiglia un po' a questo:

• pip install transformers
• Inizializza un modello di trasformatori preaddestrati: from_pretrained.
• Provalo su alcuni dati.
• Può essere perfezionare il modello (addestrarlo ancora un po').

Ora, questo è un ottimo approccio, ma se lo facessimo solo, ci mancherebbe la comprensione necessaria per creare i nostri modelli di trasformatori.

E, se non possiamo creare i nostri modelli di trasformatore, dobbiamo fare affidamento sulla presenza di un modello pre-addestrato adatto al nostro problema, non è sempre così:

Alcuni commenti che chiedono informazioni sui modelli BERT non inglesi

Quindi, in questo articolo esploreremo i passaggi che dobbiamo compiere per costruire il nostro modello di trasformatore, in particolare una versione ulteriormente sviluppata di BERT, chiamata RoBERTa.

Alla panoramica

 
 
Ci sono alcuni passaggi nel processo, quindi prima di immergerci riassumiamo innanzitutto ciò che dobbiamo fare. In totale, ci sono quattro parti fondamentali:

• Recupero dei dati
• Costruire un tokenizzatore
• Creazione di una pipeline di input
• Addestramento del modello

Una volta che avremo lavorato su ciascuna di queste sezioni, prenderemo il tokenizzatore e il modello che abbiamo creato e li salveremo entrambi in modo da poterli poi utilizzare nello stesso modo in cui faremmo normalmente con from_pretrained.

Ottenere i dati

 
 
Come per qualsiasi progetto di machine learning, abbiamo bisogno di dati. In termini di dati per l'addestramento di un modello di trasformatore, abbiamo davvero l'imbarazzo della scelta: possiamo utilizzare quasi tutti i dati di testo.

E, se c'è una cosa di cui abbiamo moltissimo su Internet, sono i dati di testo non strutturati.

Uno dei set di dati più grandi nel campo dei testi recuperati da Internet è il set di dati OSCAR.

Il set di dati OSCAR vanta un numero enorme di lingue diverse e uno dei casi d’uso più chiari per la formazione da zero è la possibilità di applicare BERT ad alcune lingue meno comunemente utilizzate, come il telugu o il navajo.

Sfortunatamente, l’unica lingua che posso parlare con un certo grado di competenza è l’inglese – ma la mia ragazza è italiana, e quindi lei – Laura, valuterà i risultati del nostro modello BERT di lingua italiana – FiliBERTo.

Quindi, per scaricare il segmento italiano del set di dati OSCAR utilizzeremo HuggingFace datasets libreria - con cui possiamo installare pip install datasets. Quindi scarichiamo OSCAR_IT con:

Diamo un'occhiata a dataset oggetto.

Ottimo, ora archiviamo i nostri dati in un formato che possiamo utilizzare durante la creazione del nostro tokenizzatore. Dobbiamo creare una serie di file di testo in chiaro contenenti solo il file text funzionalità dal nostro set di dati e le divideremo ciascuna campione utilizzando una nuova riga n.

Nel nostro data/text/oscar_it directory troveremo:

La directory contenente i nostri file OSCAR in testo normale

Costruire un tokenizzatore

 
 
Il prossimo è il tokenizzatore! Quando utilizziamo i trasformatori, in genere carichiamo un tokenizzatore, insieme al rispettivo modello di trasformatore: il tokenizzatore è un componente chiave nel processo.

Quando creiamo il nostro tokenizzatore, gli forniremo tutti i nostri dati OSCAR, specificheremo la dimensione del nostro vocabolario (numero di token nel tokenizzatore) ed eventuali token speciali.

Ora, i gettoni speciali RoBERTa si presentano così:

Quindi, ci assicuriamo di includerli all'interno del file special_tokens parametro del nostro tokenizzatore train chiamata al metodo.

Il nostro tokenizzatore è ora pronto e possiamo salvarlo in un file per un uso successivo:

Ora abbiamo due file che definiscono il nostro new FiliBERTo tokenizzatore:

• merges.txt — esegue la mappatura iniziale del testo sui token
• vocab.json — associa i token agli ID dei token

E con questi, possiamo procedere all'inizializzazione del nostro tokenizzatore in modo da poterlo utilizzare come utilizzeremmo qualsiasi altro from_pretrained tokenizzatore.

Inizializzazione del tokenizzatore

 
 
Per prima cosa inizializziamo il tokenizzatore utilizzando i due file che abbiamo creato in precedenza, utilizzando un semplice file from_pretrained:

Ora il nostro tokenizzatore è pronto, possiamo provare a codificare del testo con esso. Durante la codifica utilizziamo gli stessi due metodi che utilizzeremmo normalmente, encode ed encode_batch.

Dall'oggetto codifiche tokens estrarremo il input_ids ed attention_mask tensori da utilizzare con FiliBERTo.

Creazione della pipeline di input

 
 
La pipeline di input del nostro processo di formazione è la parte più complessa dell'intero processo. Consiste nel prendere i nostri dati grezzi di formazione OSCAR, trasformarli e caricarli in un file DataLoader pronto per l'allenamento.

Preparazione dei dati

 
 
Inizieremo con un singolo campione e lavoreremo attraverso la logica di preparazione.

Per prima cosa dobbiamo aprire il nostro file, lo stesso file in cui lo abbiamo salvato txt file in precedenza. Li dividiamo ciascuno in base ai caratteri di nuova riga n poiché questo indica i singoli campioni.

Quindi codifichiamo i nostri dati utilizzando il file tokenizer — assicurandosi di includere parametri chiave come max_length, paddinge truncation.

E ora possiamo passare alla creazione dei nostri tensori: addestreremo il nostro modello attraverso la modellazione del linguaggio mascherato (MLM). Quindi, abbiamo bisogno di tre tensori:

• input_id - Nostro token_id con circa il 15% dei token mascherati utilizzando il token maschera <mask>.
• attenzione_maschera - un tensore di 1s e 0s, che segna la posizione di token/token di riempimento "reali" - utilizzati nei calcoli dell'attenzione.
• etichette - Nostro token_id con no mascheramento.

Se non hai familiarità con il MLM, te l'ho spiegato qui.

Il nostro attention_mask ed labels i tensori vengono semplicemente estratti dal nostro batch. input_ids i tensori richiedono tuttavia maggiore attenzione, per questo tensore mascheriamo circa il 15% dei token, assegnando loro l'ID token 3.

Nell'output finale, possiamo vedere parte di un file codificato input_ids tensore. Il primo ID token è 1 - Il [CLS] gettone. Sparsi per il tensore ne abbiamo diversi 3 ID token: questi sono i nuovi ID aggiunti [MASK] gettoni.

Creazione del DataLoader

 
 
Successivamente, definiamo il nostro Dataset class - che usiamo per inizializzare i nostri tre tensori codificati come PyTorch torch.utils.data.Dataset oggetti.

Infine, il nostro dataset viene caricato in un PyTorch DataLoader oggetto: che utilizziamo per caricare i nostri dati nel nostro modello durante l'addestramento.

Formazione del modello

 
 
Abbiamo bisogno di due cose per l'allenamento, le ns DataLoader e un modello. IL DataLoader abbiamo, ma nessun modello.

Inizializzazione del modello

 
 
Per la formazione, abbiamo bisogno di un grezzo (non pre-addestrato) BERTLMHeadModel. Per crearlo, dobbiamo prima creare un oggetto di configurazione RoBERTa per descrivere i parametri con cui vorremmo inizializzare FiliBERTo.

Quindi, importiamo e inizializziamo il nostro modello RoBERTa con una testa di modellazione del linguaggio (LM).

Preparazione alla formazione

 
 
Prima di passare al ciclo di allenamento, dobbiamo impostare alcune cose. Innanzitutto, configuriamo l'utilizzo di GPU/CPU. Quindi attiviamo la modalità di training del nostro modello e, infine, inizializziamo il nostro ottimizzatore.

Training

 
 
Finalmente: tempo di allenamento! Ci alleniamo proprio come faremmo normalmente quando ci alleniamo tramite PyTorch.

Se andiamo a Tensorboard troveremo la nostra perdita nel tempo: sembra promettente.

Perdita/tempo: più sessioni di allenamento sono state raggruppate insieme in questo grafico

Il vero test

 
 
Adesso è il momento della prova vera. Abbiamo creato una pipeline MLM e chiediamo a Laura di valutare i risultati. Potete guardare la videorecensione alle 22:44 qui:

Per prima cosa inizializziamo a pipeline oggetto, utilizzando il 'fill-mask' discussione. Quindi inizia a testare il nostro modello in questo modo:

"Ciao Venire va?" è la risposta giusta! È avanzato quanto il mio italiano, quindi passiamolo a Laura.

Iniziamo con “buongiorno, come va?” - o "buon giorno come stai?":

La prima risposta, “buongiorno, chi va?” significa "buona giornata, chi c'è?" — ad esempio senza senso. Ma la nostra seconda risposta è corretta!

Successivamente, una frase leggermente più difficile, “ciao, dove ci incontriamo oggi pomeriggio?” - o "ciao, dove ci vediamo questo pomeriggio?":

E restituiamo alcuni risultati più positivi:

✅ "hi, where do we see each other this afternoon?"
✅ "hi, where do we meet this afternoon?"
❌ "hi, where here we are this afternoon?"
✅ "hi, where are we meeting this afternoon?"
✅ "hi, where do we meet this afternoon?"

Infine, un'altra frase più dura, “cosa sarebbe successo se avessimo scelto un altro giorno?” – oppure “cosa sarebbe successo se avessimo scelto un altro giorno?”:

Anche qui restituiamo alcune risposte più valide:

✅ "what would have happened if we had chosen another day?"
✅ "what would have happened if I had chosen another day?"
✅ "what would have happened if they had chosen another day?"
✅ "what would have happened if you had chosen another day?"
❌ "what would have happened if another day was chosen?"

Nel complesso, sembra che il nostro modello abbia superato i test di Laura e ora abbiamo un modello competente in lingua italiana chiamato FiliBERTo!

Questo è tutto per questa procedura dettagliata sull'addestramento di un modello BERT da zero!

Abbiamo coperto molti argomenti, dall'acquisizione e formattazione dei nostri dati, fino all'utilizzo della modellazione linguistica per addestrare il nostro modello BERT grezzo.

Spero che questo articolo ti sia piaciuto! Se avete domande, fatemelo sapere tramite Twitter o nei commenti qui sotto. Se desideri più contenuti come questo, li pubblico su YouTube troppo.

Grazie per la lettura!

70% di sconto! Elaborazione del linguaggio naturale: PNL con trasformatori in Python

I modelli Transformer sono lo standard di fatto nella moderna PNL. Si sono dimostrati i più espressivi...
 

*Tutte le immagini sono dell'autore salvo dove diversamente indicato

 
Bio: James Briggs è un data scientist specializzato nell'elaborazione del linguaggio naturale e che lavora nel settore finanziario, con sede a Londra, Regno Unito. È anche un mentore freelance, scrittore e creatore di contenuti. Puoi contattare l'autore tramite e-mail (jamescalam94@gmail.com).

Originale. Ripubblicato con il permesso.

Correlato:

• Come applicare i trasformatori a qualsiasi lunghezza di testo
• Capire BERT con la faccia che abbraccia
• Modellazione di argomenti con BERT