By James Briggs, Data scientist

BERT, maar dan in Italië — afbeelding door auteur

Veel van mijn artikelen waren gericht op BERT - het model dat kwam en de wereld van natuurlijke taalverwerking (NLP) domineerde en een nieuw tijdperk markeerde voor taalmodellen.

Voor degenen onder u die misschien nog nooit transformatormodellen hebben gebruikt (bijvoorbeeld wat BERT is), ziet het proces er ongeveer zo uit:

• pip install transformers
• Initialiseer een vooraf getraind transformatormodel — from_pretrained.
• Test het op enkele gegevens.
• Misschien verfijn het model (train het wat meer).

Dit is een geweldige benadering, maar als we dit alleen maar doen, missen we het begrip achter het maken van onze eigen transformatormodellen.

En als we onze eigen transformatormodellen niet kunnen maken - we moeten erop vertrouwen dat er een vooraf getraind model is dat bij ons probleem past, is dit niet altijd het geval:

Een paar opmerkingen over niet-Engelse BERT-modellen

Dus in dit artikel zullen we de stappen onderzoeken die we moeten nemen om ons eigen transformatormodel te bouwen - met name een verder ontwikkelde versie van BERT, genaamd RoBERTa.

Een overzicht

 
 
Er zijn een paar stappen in het proces, dus voordat we erin duiken, laten we eerst samenvatten wat we moeten doen. In totaal zijn er vier belangrijke onderdelen:

• De gegevens ophalen
• Een tokenizer bouwen
• Een invoerpijplijn maken
• Het model trainen

Zodra we elk van deze secties hebben doorlopen, nemen we de tokenizer en het model dat we hebben gebouwd - en slaan ze beide op, zodat we ze vervolgens op dezelfde manier kunnen gebruiken als we normaal zouden doen met from_pretrained.

De gegevens ophalen

 
 
Zoals bij elk machine learning-project hebben we gegevens nodig. Wat betreft gegevens voor het trainen van een transformatormodel, hebben we echt keuze te over - we kunnen bijna alle tekstgegevens gebruiken.

En als er één ding is waar we genoeg van hebben op internet, dan zijn het ongestructureerde tekstgegevens.

Een van de grootste datasets op het gebied van tekst die van internet is geschraapt, is de OSCAR-dataset.

De OSCAR-dataset beschikt over een groot aantal verschillende talen - en een van de duidelijkste use-cases voor training vanaf nul is dat we BERT kunnen toepassen op enkele minder vaak gebruikte talen, zoals Telugu of Navajo.

Helaas is de enige taal die ik met enige mate van bekwaamheid spreek Engels, maar mijn vriendin is Italiaans, en dus zal zij, Laura, de resultaten beoordelen van ons Italiaans sprekende BERT-model, FiliBERTo.

Dus om het Italiaanse segment van de OSCAR-dataset te downloaden, zullen we HuggingFace's gebruiken datasets bibliotheek - waarmee we kunnen installeren pip install datasets. Vervolgens downloaden we OSCAR_IT met:

Laten we de dataset voorwerp.

Geweldig, laten we nu onze gegevens opslaan in een indeling die we kunnen gebruiken bij het bouwen van onze tokenizer. We moeten een set platte tekstbestanden maken met alleen de text functie uit onze dataset, en we zullen elk splitsen monster een nieuwe regel gebruiken n.

Over in onze data/text/oscar_it directory vinden we:

De map met onze platte tekst OSCAR-bestanden

Een tokenizer bouwen

 
 
De volgende is de tokenizer! Bij het gebruik van transformatoren laden we meestal een tokenizer, naast het bijbehorende transformatormodel - de tokenizer is een sleutelcomponent in het proces.

Bij het bouwen van onze tokenizer zullen we al onze OSCAR-gegevens invoeren, onze woordenschatgrootte specificeren (aantal tokens in de tokenizer) en eventuele speciale tokens.

Nu zien de speciale RoBERTa-tokens er zo uit:

We zorgen er dus voor dat ze worden opgenomen in de special_tokens parameter van onze tokenizer's train methode oproep.

Onze tokenizer is nu klaar en we kunnen het bestand opslaan voor later gebruik:

Nu hebben we twee bestanden die onze new FiliBERTo tokenizer:

• merges.txt — voert de initiële toewijzing van tekst aan tokens uit
• vocab.json — wijst de tokens toe aan token-ID's

En daarmee kunnen we doorgaan met het initialiseren van onze tokenizer, zodat we deze kunnen gebruiken zoals we elke andere zouden gebruiken from_pretrained tokenizer.

De tokenizer initialiseren

 
 
We initialiseren eerst de tokenizer met behulp van de twee bestanden die we eerder hebben gebouwd - met behulp van een simpele from_pretrained:

Nu onze tokenizer klaar is, kunnen we proberen er wat tekst mee te coderen. Bij het coderen gebruiken we dezelfde twee methoden die we normaal gesproken zouden gebruiken, encode en encode_batch.

Van het coderingen-object tokens we zullen de extraheren input_ids en attention_mask tensoren voor gebruik met FiliBERTo.

De invoerpijplijn maken

 
 
De inputpijplijn van ons trainingsproces is het complexere deel van het hele proces. Het bestaat uit het nemen van onze onbewerkte OSCAR-trainingsgegevens, deze transformeren en laden in een DataLoader klaar om te trainen.

De gegevens voorbereiden

 
 
We beginnen met een enkel voorbeeld en doorlopen de voorbereidingslogica.

Eerst moeten we ons bestand openen - dezelfde bestanden als waarin we hebben opgeslagen . Txt bestanden eerder. We splitsen elk op basis van newline-tekens n aangezien dit de individuele monsters aangeeft.

Vervolgens coderen we onze gegevens met behulp van de tokenizer - zorg ervoor dat u belangrijke parameters opneemt, zoals max_length, padding en truncation.

En nu kunnen we verder gaan met het maken van onze tensoren - we zullen ons model trainen door middel van masked-language modeling (MLM). We hebben dus drie tensoren nodig:

• invoer_id's - ons token_id's met ~ 15% van de tokens gemaskeerd met behulp van het maskertoken <mask>.
• aandacht_masker — een tensor van 1s en 0s, markering van de positie van 'echte' tokens/padding tokens — gebruikt in aandachtsberekeningen.
• labels - ons token_id's Met geen maskeren.

Als je niet bekend bent met MLM, heb ik het uitgelegd hier.

Onze attention_mask en labels tensoren worden gewoon uit onze gehaald batch. De input_ids tensoren vereisen echter meer aandacht, voor deze tensor maskeren we ~15% van de tokens — door ze de token-ID toe te wijzen 3.

In de uiteindelijke uitvoer kunnen we een deel van een gecodeerd input_ids tensor. De allereerste token-ID is 1 - de [CLS] teken. Gestippeld rond de tensor hebben we er verschillende 3 token-ID's - dit zijn onze nieuw toegevoegde [MASK] tokens.

De DataLoader bouwen

 
 
Vervolgens definiëren we onze Dataset class - die we gebruiken om onze drie gecodeerde tensoren te initialiseren als PyTorch torch.utils.data.Dataset voorwerpen.

Eindelijk, onze dataset wordt geladen in een PyTorch DataLoader object — dat we gebruiken om onze gegevens tijdens de training in ons model te laden.

Het model trainen

 
 
We hebben twee dingen nodig voor training, onze DataLoader en een fotomodel. De DataLoader we hebben - maar geen model.

Initialisatie van het model

 
 
Voor training hebben we een onbewerkte (niet vooraf getrainde) BERTLMHeadModel. Om dat te maken, moeten we eerst een RoBERTa-configuratieobject maken om de parameters te beschrijven waarmee we FiliBERTo willen initialiseren.

Vervolgens importeren en initialiseren we ons RoBERTa-model met een taalmodelleringskop (LM).

Trainingsvoorbereiding

 
 
Voordat we naar onze trainingslus gaan, moeten we een paar dingen instellen. Eerst hebben we het GPU/CPU-gebruik ingesteld. Vervolgens activeren we de trainingsmodus van ons model - en ten slotte initialiseren we onze optimizer.

Trainingen

 
 
Eindelijk - trainingstijd! We trainen zoals we gewoonlijk zouden doen bij het trainen via PyTorch.

Als we naar Tensorboard gaan, zullen we ons verlies in de loop van de tijd vinden - het ziet er veelbelovend uit.

Verlies / tijd - in deze grafiek zijn meerdere trainingssessies aan elkaar geregen

De echte test

 
 
Nu is het tijd voor de echte test. We zetten een MLM-pijplijn op - en vragen Laura om de resultaten te beoordelen. Je kunt de videoreview om 22:44 hier bekijken:

We initialiseren eerst a pipeline voorwerp, met behulp van de 'fill-mask' argument. Begin dan ons model als volgt te testen:

"doei hoe va?” is het juiste antwoord! Dat is zo geavanceerd als mijn Italiaans krijgt - dus laten we het aan Laura overhandigen.

We beginnen met "buongiorno, kom va?" - of "goedendag, hoe gaat het?":

Het eerste antwoord, "buongiorno, chi va?" betekent "goedendag, wie is daar?" — bijv. onzinnig. Maar ons tweede antwoord is correct!

Vervolgens een iets moeilijkere zin, "ciao, dove ci incontriamo oggi pomeriggio?" - of "Hoi, waar gaan we vanmiddag afspreken?":

En we geven wat meer positieve resultaten terug:

✅ "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?"

Tot slot nog een, hardere zin, "Heeft u succes gehad met een andere giorno?" — of "wat zou er zijn gebeurd als we een andere dag hadden gekozen?":

We geven hier ook een paar goede, meer goede antwoorden:

✅ "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?"

Al met al lijkt het erop dat ons model Laura's tests heeft doorstaan ​​— en we hebben nu een bekwaam Italiaans taalmodel genaamd FiliBERTo!

Dat was het voor deze walkthrough van het helemaal opnieuw trainen van een BERT-model!

We hebben veel terrein behandeld, van het verkrijgen en formatteren van onze gegevens tot het gebruik van taalmodellering om ons onbewerkte BERT-model te trainen.

Ik hoop dat je genoten hebt van dit artikel! Als je vragen hebt, laat het me weten via Twitter of in de reacties hieronder. Als je meer van dit soort inhoud wilt, post ik op YouTube ook.

Bedankt voor het lezen!

70% korting! Natuurlijke taalverwerking: NLP met transformatoren in Python

Transformatormodellen zijn de de facto standaard in moderne NLP. Ze hebben zichzelf bewezen als de meest expressieve…
 

*Alle afbeeldingen zijn van de auteur, tenzij anders vermeld

 
Bio: James Briggs is een datawetenschapper gespecialiseerd in natuurlijke taalverwerking en werkzaam in de financiële sector, gevestigd in Londen, VK. Hij is ook een freelance mentor, schrijver en maker van inhoud. U kunt de auteur bereiken via e-mail (jamescalam94@gmail.com).

ORIGINELE. Met toestemming opnieuw gepost.

Zie ook:

• Transformers toepassen op elke tekstlengte
• BERT begrijpen met knuffelend gezicht
• Onderwerpmodellering met BERT