Googles BERT NLP maskininlärningshandledning

Det finns gott om applikationer för maskininlärning, och en av dessa är naturlig språkbehandling eller NLP.

NLP hanterar saker som textsvar, att ta reda på innebörden av ord i sammanhanget och hålla konversationer med oss. Det hjälper datorer att förstå det mänskliga språket så att vi kan kommunicera på olika sätt.

Från chatbots till jobbansökningar till att sortera din e-post i olika mappar, NLP används överallt runt oss.

I sin kärna är naturlig språkbehandling en blandning av datavetenskap och lingvistik. Lingvistik ger oss reglerna för att träna våra maskininlärningsmodeller och få de resultat vi letar efter.

Det finns många anledningar till att naturlig språkbehandling har blivit en stor del av maskininlärning. Det hjälper maskiner att upptäcka sentimentet från en kunds feedback, det kan hjälpa till att sortera supportbiljetter för alla projekt du arbetar med, och det kan läsa och förstå text konsekvent.

Och eftersom det fungerar av en uppsättning språkliga regler, har det inte samma fördomar som en människa skulle.

Eftersom NLP är ett så stort studieområde finns det ett antal verktyg du kan använda för att analysera data för dina specifika ändamål.

Det finns ett reglerbaserat tillvägagångssätt där du ställer in många if-then-uttalanden för att hantera hur text tolkas. Vanligtvis är en lingvist ansvarig för denna uppgift och vad de producerar är mycket lätt för människor att förstå.

Det här kan vara bra att börja med, men det blir väldigt komplicerat när du börjar arbeta med stora datamängder.

Ett annat tillvägagångssätt är att använda maskininlärning där du inte behöver definiera regler. Det här är bra när du försöker analysera stora mängder data snabbt och exakt.

Att välja rätt algoritm så att maskininlärningsmetoden fungerar är viktigt när det gäller effektivitet och noggrannhet. Det finns vanliga algoritmer som Naïve Bayes och Support Vector Machines. Sedan finns det mer specifika algoritmer som Google BERT.

Vad är BERT?

BERT är ett bibliotek med öppen källkod som skapades 2018 på Google. Det är en ny teknik för NLP och det tar en helt annan inställning till träningsmodeller än någon annan teknik.

BERT är en akronym för Bidirectional Encoder Representations from Transformers. Det betyder att till skillnad från de flesta tekniker som analyserar meningar från vänster till höger eller höger till vänster, går BERT åt båda håll med Transformer-kodaren. Målet är att skapa en språkmodell.

Detta ger den otrolig noggrannhet och prestanda på mindre datauppsättningar som löser ett stort problem vid bearbetning av naturligt språk.

Även om det finns en enorm mängd textbaserad data tillgänglig har väldigt lite av det märkts för att användas för utbildning av en maskininlärningsmodell. Eftersom de flesta tillvägagångssätt för NLP-problem utnyttjar djupinlärning behöver du stora mängder data att träna med.

Du ser verkligen de enorma förbättringarna i en modell när den har tränats med miljontals datapunkter. För att hjälpa till att komma runt detta problem med att inte ha tillräckligt med märkta data, kom forskare på sätt att träna språkrepresentationsmodeller för allmänna ändamål genom förutbildning med hjälp av text från hela internet.

Dessa förutbildade representationsmodeller kan sedan finjusteras för att arbeta med specifika datamängder som är mindre än de som vanligtvis används vid djupinlärning. Dessa mindre datauppsättningar kan vara för problem som sentimentanalys eller spam-upptäckt. Det här är hur de flesta NLP-problem uppnås eftersom det ger mer exakta resultat än att börja med den mindre datamängden.

Det är därför BERT är en så stor upptäckt. Det ger ett sätt att mer exakt träna dina modeller med mindre data. Den dubbelriktade metoden den använder innebär att den får mer av sammanhanget för ett ord än om det bara tränade i en riktning. Med detta ytterligare sammanhang kan den dra nytta av en annan teknik som kallas maskerad LM.

Hur det skiljer sig från andra maskininlärningsalgoritmer

Maskerad LM maskerar slumpmässigt 15% av orden i en mening med en [MASK] -token och försöker sedan förutsäga dem baserat på orden som omger den maskerade. Således kan BERT titta på ord från både vänster till höger och höger till vänster.

Detta skiljer sig helt från alla andra befintliga språkmodeller eftersom det tittar på orden före och efter ett maskerat ord samtidigt. Mycket av noggrannheten som BERT har kan tillskrivas detta.

För att få BERT att arbeta med din datamängd måste du lägga till lite metadata. Det kommer att behövas tokeninbäddningar för att markera början och slutet på meningar. Du måste ha segmentinbäddningar för att kunna skilja olika meningar. Slutligen behöver du positioneringsinbäddningar för att ange ordens ord i en mening.

Det ser ut som det här.

[CLS] the [MASK] has blue spots [SEP] it rolls [MASK] the parking lot [SEP]

Med metadata till dina datapunkter är maskerad LM redo att fungera.

När det är klart att förutsäga ord utnyttjar BERT nästa förutsägelse. Detta ser på förhållandet mellan två meningar. Det gör detta för att bättre förstå sammanhanget för hela datamängden genom att ta ett par meningar och förutsäga om den andra meningen är nästa mening baserat på originaltexten.

För att förutsäga nästa mening att fungera i BERT-tekniken skickas den andra meningen genom den transformatorbaserade modellen.

Det finns fyra olika förutbildade versioner av BERT beroende på storleken på data du arbetar med. Du kan läsa mer om dem här: //github.com/google-research/bert#bert

Nackdelen med detta tillvägagångssätt är att förlustfunktionen bara tar hänsyn till de maskerade ordförutsägelserna och inte de andras förutsägelser. Det betyder att BERT-tekniken konvergerar långsammare än de andra höger-till-vänster- eller vänster-till-höger-teknikerna.

BERT kan tillämpas på alla NLP-problem du kan tänka dig, inklusive avsiktförutsägelse, applikationer för att svara på frågor och textklassificering.

Kodexempel

Komma igång

Nu ska vi gå igenom ett exempel på BERT i aktion. Det första du behöver göra är att klona Bert-repo.

git clone //github.com/google-research/bert.git

Nu måste du ladda ner de förutbildade BERT-modellfilerna från BERT GitHub-sidan. Under resten av denna handledning hänvisar jag till katalogen för denna repo som rotkatalog.

Dessa filer ger dig hyperparametrar, vikter och andra saker du behöver med den information Bert lärde sig under förutbildningen. Jag använder BERT-Base, Uncased-modellen, men du hittar flera andra alternativ på olika språk på GitHub-sidan.

Några anledningar till att du väljer BERT-Base, Uncased-modellen är om du inte har tillgång till en Google TPU, i vilket fall du vanligtvis väljer en basmodell.

Om du tycker att höljet i texten du försöker analysera är skiftlägeskänsligt (höljet i texten ger verklig kontextuell mening), skulle du gå med en Cased-modell.

Om höljet inte är viktigt eller om du inte är helt säker än, skulle en Uncased-modell vara ett giltigt val.

Vi kommer att arbeta med några Yelp-recensioner som vår datamängd. Kom ihåg att BERT förväntar sig data i ett visst format med hjälp av dessa tokeninbäddningar och andra. Vi måste lägga till dem i en .tsv-fil. Den här filen liknar en .csv, men den kommer att ha fyra kolumner och ingen rubrikrad.

Här är hur de fyra kolumnerna kommer att se ut.

  • Kolumn 0: Rad-id
  • Kolumn 1: Radetikett (måste vara ett heltal)
  • Kolumn 2: En kolumn med samma bokstav för alla rader (den används inte för någonting, men BERT förväntar sig den)
  • Kolumn 3: Texten vi vill klassificera

Du måste skapa en mapp som heter data i katalogen där du klonade BERT och lägga till tre filer där: train.tsv, dev.tsv, test.tsv .

I filerna train.tsv och dev.tsv har vi de fyra kolumnerna vi pratade om tidigare. I test.tsv- filen har vi bara rad-id och text som vi vill klassificera som kolumner. Dessa kommer att vara de datafiler vi använder för att träna och testa vår modell.

Förbereda data

Först måste vi hämta de data vi ska arbeta med. Du kan ladda ner Yelp-recensioner själv: //course.fast.ai/datasets#nlp Det kommer att finnas under NLP-avsnittet och du vill ha polaritetsversionen.

Anledningen till att vi kommer att arbeta med den här versionen är att data redan har en polaritet, vilket innebär att de redan har en känsla kopplad till den. Spara den här filen i datakatalogen.

Nu är vi redo att börja skriva kod. Skapa en ny fil i rotkatalogen som heter pre_processing.py och lägg till följande kod.

import pandas as pd # this is to extract the data from that .tgz file import tarfile from sklearn.preprocessing import LabelEncoder from sklearn.model_selection import train_test_split # get all of the data out of that .tgz yelp_reviews = tarfile.open('data/yelp_review_polarity_csv.tgz') yelp_reviews.extractall('data') yelp_reviews.close() # check out what the data looks like before you get started # look at the training data set train_df = pd.read_csv('data/yelp_review_polarity_csv/train.csv', header=None) print(train_df.head()) # look at the test data set test_df = pd.read_csv('data/yelp_review_polarity_csv/test.csv', header=None) print(test_df.head())

I den här koden har vi importerat några Python-paket och packat upp data för att se hur data ser ut. Du kommer att märka att värdena associerade med recensioner är 1 och 2, varav 1 är en dålig recension och 2 är en bra recension. Vi måste konvertera dessa värden till mer standardetiketter, så 0 och 1. Du kan göra det med följande kod.

train_df[0] = (train_df[0] == 2).astype(int) test_df[0] = (test_df[0] == 2).astype(int)

När du gör uppdateringar av dina data är det alltid viktigt att ta en titt på om saker och ting visade sig vara rätt. Så vi gör det med följande kommandon.

print(train_df.head()) print(test_df.head())

När du ser att dina polaritetsvärden har förändrats till att vara vad du förväntade dig. Nu när data ska ha 1 och 0.

Eftersom vi har rengjort de ursprungliga uppgifterna är det dags att göra saker redo för BERT. Vi måste få våra data att passa de kolumnformat vi pratade om tidigare. Låt oss börja med träningsdata.

Utbildningsdata kommer att ha alla fyra kolumner: rad-id, radetikett, en bokstav, text som vi vill klassificera.

BERT förväntar sig två filer för utbildning som heter train and dev . Vi skapar dessa filer genom att dela den inledande tågfilen i två filer efter att vi formaterat våra data med följande kommandon.

bert_df = pd.DataFrame({     'id': range(len(train_df)),     'label': train_df[0],     'alpha': ['q']*train_df.shape[0],     'text': train_df[1].replace(r'\n', ' ', regex=True) }) train_bert_df, dev_bert_df = train_test_split(bert_df, test_size=0.01)

Med variabeln bert_df har vi formaterat data för att vara vad BERT förväntar sig. Du kan välja vilken annan bokstav som helst för alfavärdet om du vill. Den train_test_split metod vi importerade i början handtag dela träningsdata i två filer som vi behöver.

Ta en titt på hur data har formaterats med det här kommandot.

print(train_bert_df.head())

Nu måste vi formatera testdata. Detta kommer att se annorlunda ut än hur vi hanterade träningsdata. BERT förväntar sig bara två kolumner för testdata: rad-id, text som vi vill klassificera. Vi behöver inte göra något annat mot testdata när vi har det i det här formatet och vi gör det med följande kommando.

test_bert_df = pd.DataFrame({     'id': range(len(test_df)),     'text': test_df[1].replace(r'\n', ' ', regex=True) })

Det liknar vad vi gjorde med träningsdata, bara utan två av kolumnerna. Ta en titt på de nyligen formaterade testdata.

test_bert_df.head()

Om allt ser bra ut kan du spara dessa variabler eftersom .tsv-filerna BERT kommer att fungera med.

train_bert_df.to_csv('data/train.tsv', sep='\t', index=False, header=False) dev_bert_df.to_csv('data/dev.tsv', sep='\t', index=False, header=False) test_bert_df.to_csv('data/test.tsv', sep='\t', index=False, header=False)

Träna modellen

En snabb anteckning innan vi börjar träna modellen: BERT kan vara mycket resurskrävande på bärbara datorer. Det kan orsaka minnesfel eftersom det inte finns tillräckligt med RAM eller någon annan maskinvara inte är tillräckligt kraftfull. Du kan försöka göra training_batch_size mindre, men det kommer att göra modellutbildningen riktigt långsam.

Lägg till en mapp i rotkatalogen som heter model_output . Det är där vår modell kommer att sparas när träningen är klar. Öppna nu en terminal och gå till rotkatalogen för detta projekt. När du är i rätt katalog kör du följande kommando och det börjar träna din modell.

python run_classifier.py --task_name=cola --do_train=true --do_eval=true --data_dir=./data/ --vocab_file=./uncased_L-12_H-768_A-12/vocab.txt --bert_config_file=./uncased_L-12_H-768_A-12/bert_config.json --init_checkpoint=./uncased_L-12_H768_A-12/bert_model.ckpt.index --max_seq_length=128 --train_batch_size=32 --learning_rate=2e-5 --num_train_epochs=3.0 --output_dir=./model_output --do_lower_case=False

You should see some output scrolling through your terminal. Once this finishes running, you will have a trained model that's ready to make predictions!

Making a predication

If you take a look in the model_output directory, you'll notice there are a bunch of model.ckpt files. These files have the weights for the trained model at different points during training so you want to find the one with the highest number. That will be the final trained model that you'll want to use.

Now we'll run run_classifier.py again with slightly different options. In particular, we'll be changing the init_checkpoint value to the highest model checkpoint and setting a new --do_predict value to true. Here's the command you need to run in your terminal.

python run_classifier.py --task_name=cola --do_predict=true --data_dir=./data --vocab_file=./uncased_L-12_H-768-A-12/bert_config.json --init_checkpoint=./model_output/model.ckpt- --max_seq_length=128 --output_dir=./model_output

Once the command is finished running, you should see a new file called test_results.tsv. This will have your predicted results based on the model you trained!

You've just used BERT to analyze some real data and hopefully this all made sense.

Other thoughts

I felt it was necessary to go through the data cleaning process here just in case someone hasn't been through it before. Sometimes machine learning seems like magic, but it's really taking the time to get your data in the right condition to train with an algorithm.

BERT is still relatively new since it was just released in 2018, but it has so far proven to be more accurate than existing models even if it is slower.