By James Briggs, Datavetare

BERT, men i Italien — bild av författaren

Många av mina artiklar har varit fokuserade på BERT – modellen som kom och dominerade världen av naturlig språkbehandling (NLP) och markerade en ny tid för språkmodeller.

För er som kanske inte har använt transformatormodeller (t.ex. vad BERT är) tidigare, ser processen ut lite så här:

• pip install transformers
• Initiera en förtränad transformatormodell — from_pretrained.
• Testa det på vissa data.
• Kanske finjustera modellen (träna den lite mer).

Nu är det här ett bra tillvägagångssätt, men om vi bara gör det här, saknar vi förståelsen bakom att skapa våra egna transformatormodeller.

Och om vi inte kan skapa våra egna transformatormodeller – vi måste lita på att det finns en förutbildad modell som passar vårt problem, detta är inte alltid fallet:

Några kommentarer som frågar om icke-engelska BERT-modeller

Så i den här artikeln kommer vi att undersöka stegen vi måste ta för att bygga vår egen transformatormodell – närmare bestämt en vidareutvecklad version av BERT, kallad RoBERTa.

En översikt

 
 
Det finns några steg i processen, så innan vi dyker in, låt oss först sammanfatta vad vi behöver göra. Totalt finns det fyra nyckeldelar:

• Skaffa data
• Att bygga en tokenizer
• Skapa en inputpipeline
• Utbildning av modellen

När vi har arbetat igenom var och en av dessa sektioner kommer vi att ta tokenizern och modellen vi har byggt — och spara dem båda så att vi sedan kan använda dem på samma sätt som vi brukar göra med from_pretrained.

Få data

 
 
Som med alla maskininlärningsprojekt behöver vi data. När det gäller data för att träna en transformatormodell är vi verkligen bortskämda med valmöjligheter - vi kan använda nästan vilken textdata som helst.

Och om det är en sak som vi har gott om på internet – det är ostrukturerad textdata.

En av de största datamängderna inom domänen för text som skrapas från internet är OSCAR-datauppsättningen.

OSCAR-datauppsättningen har ett stort antal olika språk — och ett av de tydligaste användningsfallen för träning från början är att vi kan tillämpa BERT på några mindre vanliga språk, som Telugu eller Navajo.

Tyvärr är det enda språk jag kan tala med någon grad av kompetens engelska – men min flickvän är italienska, och därför kommer hon – Laura, att bedöma resultaten av vår italiensktalande BERT-modell – FiliBERTo.

Så för att ladda ner det italienska segmentet av OSCAR-datauppsättningen kommer vi att använda HuggingFace datasets bibliotek — som vi kan installera med pip install datasets. Sedan laddar vi ner OSCAR_IT med:

Låt oss ta en titt på dataset objekt.

Bra, låt oss nu lagra vår data i ett format som vi kan använda när vi bygger vår tokenizer. Vi måste skapa en uppsättning klartextfiler som bara innehåller text funktion från vår datauppsättning, och vi delar upp var och en prov använder en ny linje n.

Borta i vår data/text/oscar_it katalog hittar vi:

Katalogen som innehåller våra OSCAR-filer i klartext

Att bygga en Tokenizer

 
 
Nästa upp är tokenizern! När vi använder transformatorer laddar vi vanligtvis en tokenizer, tillsammans med dess respektive transformatormodell - tokenizern är en nyckelkomponent i processen.

När vi bygger vår tokenizer kommer vi att mata den med all vår OSCAR-data, specificera vår ordförrådsstorlek (antal tokens i tokenizern) och eventuella speciella tokens.

Nu ser RobERTa speciella tokens ut så här:

Så vi ser till att inkludera dem i special_tokens parametern för våra tokenizers train metodanrop.

Vår tokenizer är nu klar och vi kan spara den för senare användning:

Nu har vi två filer som definierar vår nya FiliBERTo tokenizer:

• merges.txt — utför den första mappningen av text till tokens
• vocab.json — mappar tokens till token-ID:n

Och med dem kan vi gå vidare till att initiera vår tokenizer så att vi kan använda den som vi skulle använda vilken annan from_pretrained tokenizer.

Initiera Tokenizer

 
 
Vi initierar först tokenizern med de två filerna vi byggde tidigare - med en enkel from_pretrained:

Nu är vår tokenizer klar, vi kan prova att koda lite text med den. När vi kodar använder vi samma två metoder som vi vanligtvis skulle använda, encode och encode_batch.

Från kodningsobjektet tokens vi kommer att extrahera input_ids och attention_mask tensorer för användning med FiliBERTo.

Skapa ingångspipeline

 
 
Inputpipelinen i vår utbildningsprocess är den mer komplexa delen av hela processen. Den består av att vi tar vår råa OSCAR-träningsdata, omvandlar den och laddar den till en DataLoader redo för träning.

Förbereder data

 
 
Vi börjar med ett enda prov och arbetar oss igenom förberedelselogiken.

Först måste vi öppna vår fil - samma filer som vi sparade som .Text filer tidigare. Vi delar upp varje baserat på nyradsfigurer n eftersom detta indikerar de enskilda proverna.

Sedan kodar vi vår data med hjälp av tokenizer — se till att inkludera nyckelparametrar som max_length, paddingoch truncation.

Och nu kan vi gå vidare till att skapa våra tensorer – vi kommer att träna vår modell genom masked-language modeling (MLM). Så vi behöver tre tensorer:

• input_ids — vår token_ids med ~15 % av tokens maskerade med masktoken <mask>.
• uppmärksamhetsmask — en tensor av 1s och 0s, markerar positionen för "riktiga" polletter/utfyllnadspoletter - används i uppmärksamhetsberäkningar.
• etiketter — vår token_ids med Nej maskering.

Om du inte är bekant med MLM har jag förklarat det här..

Vår attention_mask och labels tensorer utvinns helt enkelt från våra batch. De input_ids Tensorer kräver dock mer uppmärksamhet, för denna tensor maskerar vi ~15 % av tokens - och tilldelar dem token-ID:t 3.

I den slutliga utgången kan vi se en del av en kodad input_ids tensor. Det allra första token-ID:t är 1 - Den [CLS] tecken. Prickade runt tensorn har vi flera 3 token-ID:n – dessa är våra nyligen tillagda [MASK] polletter.

Bygger DataLoader

 
 
Därefter definierar vi vår Dataset klass — som vi använder för att initiera våra tre kodade tensorer som PyTorch torch.utils.data.Dataset föremål.

Äntligen vår dataset laddas in i en PyTorch DataLoader objekt — som vi använder för att ladda vår data i vår modell under träning.

Träna modellen

 
 
Vi behöver två saker för träning, vår DataLoader och en modell. De DataLoader vi har - men ingen modell.

Initiering av modellen

 
 
För träning behöver vi en rå (ej förtränad) BERTLMHeadModel. För att skapa det måste vi först skapa ett RoBERTa-konfigurationsobjekt för att beskriva parametrarna vi vill initiera FiliBERTo med.

Sedan importerar och initierar vi vår RobERTa-modell med ett språkmodelleringshuvud (LM).

Träningsförberedelser

 
 
Innan vi går vidare till vår träningsslinga måste vi ställa in några saker. Först ställer vi in ​​GPU/CPU-användning. Sedan aktiverar vi träningsläget för vår modell - och initierar slutligen vår optimerare.

Utbildning

 
 
Äntligen - träningstid! Vi tränar precis som vi brukar när vi tränar via PyTorch.

Om vi ​​går vidare till Tensorboard kommer vi att hitta vår förlust med tiden - det ser lovande ut.

Förlust/tid — flera träningspass har sammanfogats i det här diagrammet

Det riktiga testet

 
 
Nu är det dags för det riktiga testet. Vi sätter upp en MLM-pipeline – och ber Laura att utvärdera resultaten. Du kan se videorecensionen klockan 22:44 här:

Vi initialiserar först a pipeline objekt, med hjälp av 'fill-mask' argument. Börja sedan testa vår modell så här:

"ciao komma va?” är rätt svar! Det är så avancerat som min italienska blir - så låt oss lämna över den till Laura.

Vi börjar med "buongiorno, kom va?" - eller "god dag hur mår du?":

Det första svaret, "buongiorno, chi va?" betyder "god dag, vem är där?" — t.ex. meningslöst. Men vårt andra svar är korrekt!

Nästa, en lite svårare fras, "ciao, dove ci incontriamo oggi pomeriggio?" - eller "hej, var ska vi träffas i eftermiddag?":

Och vi ger några fler positiva resultat:

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

Äntligen en hårdare mening till, "cosa sarebbe successo se avessimo scelto un altro giorno?" — eller "vad skulle ha hänt om vi hade valt en annan dag?":

Vi återkommer med några bra fler bra svar här också:

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

Sammantaget ser det ut som att vår modell klarade Lauras tester – och vi har nu en kompetent italiensk språkmodell som heter FiliBERTo!

Det var allt för denna genomgång av att träna en BERT-modell från grunden!

Vi har täckt mycket mark, från att hämta och formatera vår data – hela vägen till att använda språkmodellering för att träna vår råa BERT-modell.

Jag hoppas att du gillade den här artikeln! Om du har några frågor, låt mig veta via Twitter eller i kommentarerna nedan. Om du vill ha mer sådant här innehåll lägger jag upp det Youtube också.

Tack för läsning!

70% rabatt! Naturlig språkbehandling: NLP med transformatorer i Python

Transformatormodeller är de-facto-standarden i modern NLP. De har visat sig vara de mest uttrycksfulla...
 

*Alla bilder är av författaren om inte annat anges

 
Bio: James Briggs är en datavetare som specialiserat sig på bearbetning av naturliga språk och arbetar inom finanssektorn med säte i London, Storbritannien. Han är också frilans mentor, författare och innehållsskapare. Du kan nå författaren via e-post (jamescalam94@gmail.com).

Ursprungliga. Skickas om med tillstånd.

Relaterat:

• Hur man applicerar transformatorer på valfri textlängd
• Förstå BERT med kramande ansikte
• Ämnesmodellering med BERT