Google BERT NLP Machine Learning Tutorial

Der er masser af applikationer til maskinindlæring, og en af ​​dem er naturlig sprogbehandling eller NLP.

NLP håndterer ting som tekstsvar, finder ud af betydningen af ​​ord inden for kontekst og holder samtaler med os. Det hjælper computere med at forstå det menneskelige sprog, så vi kan kommunikere på forskellige måder.

Fra chatbots til jobansøgninger til sortering af din e-mail i forskellige mapper, NLP bruges overalt omkring os.

I kernen er naturlig sprogbehandling en blanding af datalogi og lingvistik. Lingvistik giver os reglerne til at træne vores maskinlæringsmodeller og få de resultater, vi leder efter.

Der er mange grunde til, at naturlig sprogbehandling er blevet en stor del af maskinindlæring. Det hjælper maskiner med at opdage stemningen ud fra en kundes feedback, det kan hjælpe med at sortere supportbilletter til alle projekter, du arbejder på, og det kan læse og forstå tekst konsekvent.

Og da det fungerer ud fra et sæt sproglige regler, har det ikke de samme fordomme som et menneske ville.

Da NLP er et så stort studieområde, er der et antal værktøjer, du kan bruge til at analysere data til dine specifikke formål.

Der er den reglerbaserede tilgang, hvor du opretter en masse if-then-udsagn til at håndtere, hvordan tekst fortolkes. Normalt vil en lingvist være ansvarlig for denne opgave, og hvad de producerer, er meget let for folk at forstå.

Dette kan være godt at starte med, men det bliver meget komplekst, når du begynder at arbejde med store datasæt.

En anden tilgang er at bruge maskinindlæring, hvor du ikke behøver at definere regler. Dette er fantastisk, når du prøver at analysere store mængder data hurtigt og præcist.

At vælge den rigtige algoritme, så maskinindlæringsmetoden fungerer, er vigtig med hensyn til effektivitet og nøjagtighed. Der er almindelige algoritmer som Naïve Bayes og Support Vector Machines. Så er der de mere specifikke algoritmer som Google BERT.

Hvad er BERT?

BERT er et open source-bibliotek oprettet i 2018 hos Google. Det er en ny teknik til NLP, og det tager en helt anden tilgang til træningsmodeller end nogen anden teknik.

BERT er et akronym for Bidirectional Encoder Representations fra Transformers. Det betyder, i modsætning til de fleste teknikker, der analyserer sætninger fra venstre mod højre eller højre mod venstre, går BERT begge retninger ved hjælp af Transformer-koderen. Dets mål er at generere en sprogmodel.

Dette giver det utrolig nøjagtighed og ydeevne på mindre datasæt, som løser et kæmpe problem i naturlig sprogbehandling.

Mens der er en enorm mængde tekstbaserede data tilgængelige, er meget lidt af dem mærket til brug til træning af en maskinlæringsmodel. Da de fleste af tilgangene til NLP-problemer drager fordel af dyb læring, har du brug for store mængder data at træne med.

Du ser virkelig de enorme forbedringer i en model, når den er trænet med millioner af datapunkter. For at hjælpe med at omgå dette problem med ikke at have nok mærkede data, kom forskerne på måder til at træne generelle sprogrepræsentationsmodeller gennem foruddannelse ved hjælp af tekst fra hele internettet.

Disse foruddannede repræsentationsmodeller kan derefter finjusteres til at arbejde på specifikke datasæt, der er mindre end dem, der ofte bruges i dyb læring. Disse mindre datasæt kan være til problemer som sentimentanalyse eller spamdetektering. Dette er den måde, de fleste NLP-problemer tilnærmes, fordi det giver mere nøjagtige resultater end at starte med det mindre datasæt.

Derfor er BERT en så stor opdagelse. Det giver en måde til mere præcist at træne dine modeller med færre data. Den tovejs tilgang, den bruger, betyder, at den får mere af konteksten for et ord, end hvis det bare var træning i en retning. Med denne ekstra kontekst er det i stand til at drage fordel af en anden teknik kaldet maskeret LM.

Hvordan det adskiller sig fra andre maskinlæringsalgoritmer

Maskeret LM maskerer tilfældigt 15% af ordene i en sætning med et [MASK] -token og forsøger derefter at forudsige dem baseret på ordene omkring den maskerede. Sådan er BERT i stand til at se på ord fra både venstre mod højre og højre mod venstre.

Dette er helt forskelligt fra alle andre eksisterende sprogmodeller, fordi det ser på ordene før og efter et maskeret ord på samme tid. Meget af den nøjagtighed, BERT har, kan tilskrives dette.

For at få BERT til at arbejde med dit datasæt, skal du tilføje lidt metadata. Der skal være tokenindlejringer for at markere begyndelsen og slutningen af ​​sætninger. Du bliver nødt til at have segmentindlejringer for at kunne skelne mellem forskellige sætninger. Endelig skal du bruge positionelle indlejringer for at angive placeringen af ​​ord i en sætning.

Det ligner dette.

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

Med metadataene tilføjet til dine datapunkter er maskeret LM klar til at arbejde.

Når det er færdigt med at forudsige ord, drager BERT fordel af næste sætnings forudsigelse. Dette ser på forholdet mellem to sætninger. Det gør dette for bedre at forstå sammenhængen med hele datasættet ved at tage et par sætninger og forudsige, om anden sætning er den næste sætning baseret på den originale tekst.

For at forudsigelse af næste sætning kan fungere i BERT-teknikken, sendes den anden sætning gennem den transformerbaserede model.

Der er fire forskellige foruddannede versioner af BERT afhængigt af omfanget af data, du arbejder med. Du kan lære mere om dem her: //github.com/google-research/bert#bert

Ulempen ved denne tilgang er, at tabsfunktionen kun tager hensyn til de maskerede ordforudsigelser og ikke de andres forudsigelser. Det betyder, at BERT-teknikken konvergerer langsommere end de andre højre-mod-venstre eller venstre-til-højre-teknikker.

BERT kan anvendes til ethvert NLP-problem, du kan tænke på, herunder forudsigelse af hensigter, spørgsmålssvarende applikationer og tekstklassificering.

Kodeeksempel

Kom i gang

Nu skal vi gennemgå et eksempel på BERT i aktion. Den første ting, du skal gøre, er at klone Bert-repoen.

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

Nu skal du downloade de foruddannede BERT-modelfiler fra BERT GitHub-siden. I løbet af resten af ​​denne vejledning henviser jeg til denne repos bibliotek som rodmappen.

Disse filer giver dig de hyperparametre, vægte og andre ting, du har brug for med de oplysninger, Bert lærte under præ-træning. Jeg bruger BERT-Base, Uncased-modellen, men du finder flere andre muligheder på tværs af forskellige sprog på GitHub-siden.

Nogle grunde til, at du vælger BERT-Base, Uncased-modellen, er, hvis du ikke har adgang til en Google TPU, i hvilket tilfælde du typisk vælger en Base-model.

Hvis du synes, at kabinettet af den tekst, du prøver at analysere, er mellem store og små bogstaver (kabinettet af teksten giver ægte kontekstuel betydning), ville du gå med en Cased-model.

Hvis kappen ikke er vigtig, eller du ikke er helt sikker endnu, ville en ikke-kasket model være et gyldigt valg.

Vi arbejder med nogle Yelp-anmeldelser som vores datasæt. Husk, BERT forventer dataene i et bestemt format ved hjælp af disse tokenindlejringer og andre. Vi bliver nødt til at føje dem til en .tsv-fil. Denne fil vil ligne en .csv, men den har fire kolonner og ingen header-række.

Sådan ser de fire kolonner ud.

  • Kolonne 0: Række-id
  • Kolonne 1: Ræklabel (skal være et heltal)
  • Kolonne 2: En kolonne med det samme bogstav for alle rækker (den bruges ikke til noget, men BERT forventer det)
  • Kolonne 3: Den tekst, vi vil klassificere

Du bliver nødt til at oprette en mappe kaldet data i biblioteket, hvor du klonede BERT og tilføje tre filer der: train.tsv, dev.tsv, test.tsv .

I train.tsv- og dev.tsv- filerne har vi de fire kolonner, vi talte om tidligere. I test.tsv- filen har vi kun række-id'et og teksten, vi vil klassificere som kolonner. Dette bliver de datafiler, vi bruger til at træne og teste vores model.

Prepping af data

Først skal vi hente de data, vi arbejder med. Du kan selv downloade Yelp-anmeldelserne her: //course.fast.ai/datasets#nlp Det vil være under NLP-sektionen, og du vil have polaritetsversionen.

Årsagen til, at vi arbejder med denne version, er, at dataene allerede har en polaritet, hvilket betyder, at de allerede har et sentiment forbundet med det. Gem denne fil i datakataloget.

Nu er vi klar til at begynde at skrive kode. Opret en ny fil i rodmappen kaldet pre_processing.py, og tilføj følgende kode.

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 denne kode har vi importeret nogle Python-pakker og ukomprimeret dataene for at se, hvordan dataene ser ud. Du vil bemærke, at de værdier, der er knyttet til anmeldelser, er 1 og 2, hvor 1 er en dårlig anmeldelse og 2 er en god anmeldelse. Vi er nødt til at konvertere disse værdier til flere standardetiketter, så 0 og 1. Du kan gøre det med følgende kode.

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

Når du foretager opdateringer til dine data, er det altid vigtigt at se på, om tingene viste sig at være rigtige. Så vi gør det med følgende kommandoer.

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

Når du ser, at dine polaritetsværdier er ændret til at være, hvad du forventede. Nu hvor dataene skal have 1s og 0s.

Da vi har renset de oprindelige data, er det tid til at gøre tingene klar til BERT. Vi bliver nødt til at få vores data til at passe til de kolonneformater, vi talte om tidligere. Lad os starte med træningsdataene.

Træningsdataene har alle fire kolonner: række-id, rækkeetiket, enkelt bogstav, tekst, vi vil klassificere.

BERT forventer to filer til træning kaldet tog og dev . Vi opretter disse filer ved at opdele den oprindelige togfil i to filer, efter at vi har formateret vores data med følgende kommandoer.

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 variablen bert_df har vi formateret dataene til at være, hvad BERT forventer. Du kan vælge ethvert andet bogstav til alfaværdien, hvis du vil. Den train_test_split metode importerede vi i starten håndtag opdeling træningsdata ind i de to filer, vi har brug for.

Se på, hvordan dataene er formateret med denne kommando.

print(train_bert_df.head())

Nu skal vi formatere testdataene. Dette vil se anderledes ud, hvordan vi håndterede træningsdataene. BERT forventer kun to kolonner til testdataene: række-id, tekst, vi vil klassificere. Vi behøver ikke gøre noget andet med testdataene, når vi har det i dette format, og vi gør det med følgende kommando.

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

Det svarer til det, vi gjorde med træningsdataene, bare uden to af kolonnerne. Se på de nyligt formaterede testdata.

test_bert_df.head()

If everything looks good, you can save these variables as the .tsv files BERT will work with.

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)

Training the model

One quick note before we get into training the model: BERT can be very resource intensive on laptops. It might cause memory errors because there isn't enough RAM or some other hardware isn't powerful enough. You could try making the training_batch_size smaller, but that's going to make the model training really slow.

Add a folder to the root directory called model_output. That's where our model will be saved after training is finished. Now open a terminal and go to the root directory of this project. Once you're in the right directory, run the following command and it will begin training your model.

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

Jeg følte, at det var nødvendigt at gennemgå datarensningsprocessen her, hvis nogen ikke har været igennem det før. Nogle gange virker maskinindlæring som magi, men det tager virkelig tid at få dine data i den rette tilstand til at træne med en algoritme.

BERT er stadig relativt ny, siden den netop blev frigivet i 2018, men den har hidtil vist sig at være mere præcis end eksisterende modeller, selvom den er langsommere.