Google BERT NLP gépi tanulási útmutató

Rengeteg alkalmazás van a gépi tanuláshoz, és ezek egyike a természetes nyelv feldolgozása vagy az NLP.

Az NLP olyan dolgokat kezel, mint a szöveges válaszok, a szavak jelentésének a kontextuson belüli kitalálása és a beszélgetések folytatása velünk. Segít a számítógépeknek megérteni az emberi nyelvet, hogy különböző módon kommunikálhassunk.

A csevegőrobotoktól kezdve az álláspályázatokon át az e-mailek különféle mappákba rendezéséig az NLP-t mindenütt használják körülöttünk.

Lényegében a természetes nyelv feldolgozása az informatika és a nyelvészet keveréke. A nyelvészet megadja nekünk azokat a szabályokat, amelyek alapján gépi tanulási modelljeinket képezhetjük és elérhetjük a kívánt eredményeket.

Nagyon sok oka van annak, hogy a természetes nyelv feldolgozása a gépi tanulás hatalmas részévé vált. Segít a gépeknek az ügyfelek visszajelzései alapján észlelni a hangulatot, segíthet a támogatási jegyek rendezésében minden projekten, amelyen dolgozik, és következetesen olvashatja és értheti a szöveget.

És mivel nyelvi szabályok alapján működik, nem ugyanazok az elfogultságai, mint az embernek.

Mivel az NLP ekkora terület a tanulmány, számos eszközzel elemezheti az adatokat saját céljaira.

Van egy szabályalapú megközelítés, ahol sok if-then utasítást állít be a szöveg értelmezésének kezelésére. Általában egy nyelvész lesz felelős ezért a feladatért, és amit előállítanak, azt az emberek nagyon könnyen megértik.

Lehet, hogy jó ezzel kezdeni, de nagyon összetetté válik, amikor nagy adathalmazokkal kezd dolgozni.

Egy másik megközelítés a gépi tanulás használata, ahol nincs szükség szabályok meghatározására. Ez nagyszerű, ha nagy mennyiségű adatot próbál gyorsan és pontosan elemezni.

A megfelelő algoritmus kiválasztása a gépi tanulás megközelítésének működése szempontjából fontos a hatékonyság és a pontosság szempontjából. Vannak olyan általános algoritmusok, mint a Naiv Bayes és a Support Vector Machines. Aztán vannak olyan specifikusabb algoritmusok, mint a Google BERT.

Mi a BERT?

A BERT egy nyílt forráskódú könyvtár, amelyet 2018-ban hoztak létre a Google-nál. Ez egy új technika az NLP számára, és teljesen más megközelítést alkalmaz az edzésmodelleknél, mint bármely más technika.

A BERT a Transformers kétirányú kódoló ábrázolásainak rövidítése. Ez azt jelenti, hogy ellentétben a legtöbb bal-jobb vagy jobbról balra elemző technikával, a BERT mindkét irányt a Transformer kódoló segítségével hajtja végre. Célja egy nyelvi modell létrehozása.

Ez hihetetlen pontosságot és teljesítményt nyújt kisebb adathalmazoknál, ami hatalmas problémát old meg a természetes nyelv feldolgozásában.

Habár hatalmas mennyiségű szöveges adat áll rendelkezésre, ezekből csak nagyon keveset jelöltek meg a gépi tanulási modell képzéséhez. Mivel az NLP problémák megközelítésének többsége kihasználja a mély tanulást, nagy mennyiségű adatra van szüksége a képzéshez.

Akkor látja a modell hatalmas fejlesztéseit, amikor millió adatpont segítségével képezték ki. Annak érdekében, hogy kiküszöbölje ezt a problémát, hogy nincs elegendő címkézett adat, a kutatók kitalálták az általános célú nyelvi reprezentációs modellek kiképzésének módját az internetről származó szöveg felhasználásával történő előképzés útján.

Ezeket az előre kiképzett reprezentációs modelleket ezután finomhangolhatjuk, hogy olyan speciális adathalmazokon dolgozzanak, amelyek kisebbek, mint a mélytanulásban általánosan használtak. Ezek a kisebb adatsorok olyan problémákra szolgálhatnak, mint például a hangulatelemzés vagy a spamfelismerés. A legtöbb NLP problémát így közelítik meg, mert pontosabb eredményeket ad, mint a kisebb adathalmazból kiindulva.

Ezért a BERT olyan nagy felfedezés. Ez lehetőséget nyújt arra, hogy kevesebb adattal pontosabban előkészítse a modelleket. Az általa alkalmazott kétirányú megközelítés azt jelenti, hogy többet kap a szó kontextusából, mintha csak egy irányba edzene. Ezzel a további kontextussal képes kihasználni egy másik, a maszkos LM nevű technikát.

Miben különbözik más gépi tanulási algoritmusoktól

A Masked LM véletlenszerűen egy mondat 15% -át maszkolja [MASK] tokennel, majd megpróbálja megjósolni őket az álarcot körülvevő szavak alapján. Így képes a BERT megnézni a szavakat balról jobbra és jobbról balra egyaránt.

Ez teljesen különbözik minden más létező nyelvi modelltől, mert egyszerre nézi a maszkos szó előtti és utáni szavakat. A BERT sok pontossága ennek tulajdonítható.

Ahhoz, hogy a BERT az adatkészlettel működjön, hozzá kell adnia egy kis metaadatot. Jelölő beágyazásokra lesz szükség a mondatok elején és végén. A különböző mondatok megkülönböztetéséhez szegmensbeágyazásokkal kell rendelkeznie . Végül helyzeti beágyazásokra van szükség a szavak helyzetének megjelölésére egy mondatban.

Ehhez hasonló lesz.

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

Az adatpontokhoz hozzáadott metaadatokkal a maszkos LM készen áll a működésre.

Miután befejezte a szavak előrejelzését, a BERT kihasználja a következő mondat előrejelzését. Ez két mondat kapcsolatát vizsgálja. Teszi ezt azért, hogy jobban megértse a teljes adatsor kontextusát azzal, hogy vesz egy pár mondatot, és megjósolja, hogy a második mondat-e a következő mondat az eredeti szöveg alapján.

Ahhoz, hogy a következő mondat előrejelzése a BERT technikában működjön, a második mondatot a Transformer alapú modellen keresztül küldjük el.

A BERT négy különböző, előre kiképzett verzióval rendelkezik, attól függően, hogy milyen adatokkal dolgozik. Itt többet megtudhat róluk: //github.com/google-research/bert#bert

Ennek a megközelítésnek az a hátránya, hogy a veszteségfüggvény csak a maszkos szóra vonatkozó jóslatokat veszi figyelembe, a többiek jóslatait nem. Ez azt jelenti, hogy a BERT technika lassabban konvergál, mint a többi jobbról balra vagy balról jobbra technika.

A BERT minden olyan NLP problémára alkalmazható, amelyre gondolhat, ideértve a szándék előrejelzését, a kérdésre válaszoló alkalmazásokat és a szöveges besorolást.

Kódpélda

Beállítás

Most a BERT példáján megyünk keresztül. Először meg kell tennie, hogy klónozza a Bert repót.

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

Most le kell töltenie az előre kiképzett BERT modellfájlokat a BERT GitHub oldaláról. Az oktatóanyag további részében ennek a repónak a könyvtárát nevezem gyökérkönyvtárnak.

Ezek a fájlok megadják a hiperparamétereket, súlyokat és egyéb dolgokat, amelyekre szükségük van azokkal az információkkal, amelyeket Bert megtanult az edzés közben. A BERT-Base, Uncased modellt fogom használni, de a GitHub oldalon számos más lehetőséget találhat különböző nyelveken.

Néhány ok, amiért a BERT-Base, Uncased modellt választaná, ha nincs hozzáférése a Google TPU-hoz, ebben az esetben általában egy Base modellt választana.

Ha úgy gondolja, hogy az elemezni kívánt szöveg nagybetűje megkülönbözteti a kis- és nagybetűket (a szöveg nagybetűje valódi kontextuális jelentést ad), akkor a Cased modellt választaná.

If the casing isn't important or you aren't quite sure yet, then an Uncased model would be a valid choice.

We'll be working with some Yelp reviews as our data set. Remember, BERT expects the data in a certain format using those token embeddings and others. We'll need to add those to a .tsv file. This file will be similar to a .csv, but it will have four columns and no header row.

Here's what the four columns will look like.

  • Column 0: Row id
  • Column 1: Row label (needs to be an integer)
  • Column 2: A column of the same letter for all rows (it doesn't get used for anything, but BERT expects it)
  • Column 3: The text we want to classify

You'll need to make a folder called data in the directory where you cloned BERT and add three files there: train.tsv, dev.tsv, test.tsv.

In the train.tsv and dev.tsv files, we'll have the four columns we talked about earlier. In the test.tsv file, we'll only have the row id and text we want to classify as columns. These are going to be the data files we use to train and test our model.

Prepping the data

First we need to get the data we'll be working with. You can download the Yelp reviews for yourself here: //course.fast.ai/datasets#nlp It'll be under the NLP section and you'll want the Polarity version.

The reason we'll work with this version is because the data already has a polarity, which means it already has a sentiment associated with it. Save this file in the data directory.

Now we're ready to start writing code. Create a new file in the root directory called pre_processing.py and add the following code.

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())

In this code, we've imported some Python packages and uncompressed the data to see what the data looks like. You'll notice that the values associated with reviews are 1 and 2, with 1 being a bad review and 2 being a good review. We need to convert these values to more standard labels, so 0 and 1. You can do that with the following code.

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

Whenever you make updates to your data, it's always important to take a look at if things turned out right. So we'll do that with the following commands.

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

When you see that your polarity values have changed to be what you expected. Now that the data should have 1s and 0s.

Since we've cleaned the initial data, it's time to get things ready for BERT. We'll have to make our data fit the column formats we talked about earlier. Let's start with the training data.

The training data will have all four columns: row id, row label, single letter, text we want to classify.

BERT expects two files for training called train and dev. We'll make those files by splitting the initial train file into two files after we format our data with the following commands.

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)

With the bert_df variable, we have formatted the data to be what BERT expects. You can choose any other letter for the alpha value if you like. The train_test_split method we imported in the beginning handles splitting the training data into the two files we need.

Take a look at how the data has been formatted with this command.

print(train_bert_df.head())

Now we need to format the test data. This will look different from how we handled the training data. BERT only expects two columns for the test data: row id, text we want to classify. We don't need to do anything else to the test data once we have it in this format and we'll do that with the following command.

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

It's similar to what we did with the training data, just without two of the columns. Take a look at the newly formatted test data.

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

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.