Výukový program strojového učenia Google BERT NLP

Existuje veľa aplikácií pre strojové učenie a jednou z nich je spracovanie prirodzeného jazyka alebo NLP.

NLP rieši veci ako textové odpovede, zisťovanie významu slov v kontexte a vedenie rozhovorov s nami. Pomáha počítačom porozumieť ľudskému jazyku, aby sme mohli komunikovať rôznymi spôsobmi.

Od chatovacích robotov cez pracovné aplikácie až po triedenie vašich e-mailov do rôznych priečinkov sa NLP používa všade okolo nás.

Spracovanie prirodzeného jazyka predstavuje jadro kombinácie informatiky a lingvistiky. Lingvistika nám dáva pravidlá, ktoré musíme používať na školenie našich modelov strojového učenia a na získanie výsledkov, ktoré hľadáme.

Existuje veľa dôvodov, prečo sa spracovanie prirodzeného jazyka stalo obrovskou súčasťou strojového učenia. Pomáha strojom zistiť sentiment na základe spätnej väzby od zákazníka, pomáha triediť tikety podpory pre všetky projekty, na ktorých pracujete, a dokáže konzistentne čítať a porozumieť textu.

A keďže funguje na základe súboru jazykových pravidiel, nemá rovnaké predsudky ako ľudské.

Pretože NLP je taká veľká oblasť štúdia, existuje niekoľko nástrojov, ktoré môžete použiť na analýzu údajov pre vaše konkrétne účely.

Existuje prístup založený na pravidlách, kde nastavujete veľa príkazov typu „if-then“ na spracovanie interpretácie textu. Za túto úlohu bude zvyčajne zodpovedný lingvista a to, čo vyrobia, je pre ľudí veľmi ľahké pochopiť.

Na začiatok by to mohlo byť dobré, ale začne sa to veľmi komplikovať, keď začnete pracovať s veľkými množinami údajov.

Ďalším prístupom je použitie strojového učenia tam, kde nemusíte definovať pravidlá. Je to skvelé, keď sa pokúšate rýchlo a presne analyzovať veľké množstvo dát.

Z hľadiska efektívnosti a presnosti je dôležitý výber správneho algoritmu, aby prístup založený na strojovom učení fungoval. Existujú bežné algoritmy ako Naïve Bayes a Support Vector Machines. Potom existujú aj konkrétnejšie algoritmy, ako napríklad Google BERT.

Čo je BERT?

BERT je knižnica open source vytvorená v roku 2018 spoločnosťou Google. Je to nová technika pre NLP a vyžaduje úplne iný prístup k tréningovým modelom ako akákoľvek iná technika.

BERT je skratka pre obojsmerné reprezentácie kódovacieho zariadenia od transformátorov. To znamená, že na rozdiel od väčšiny techník, ktoré analyzujú vety zľava doprava alebo sprava doľava, BERT ide pomocou kodéra Transformer oboma smermi. Jeho cieľom je vygenerovať jazykový model.

To mu dáva neuveriteľnú presnosť a výkon pri menších súboroch údajov, čo rieši obrovský problém v spracovaní prirodzeného jazyka.

Aj keď je k dispozícii obrovské množstvo textových údajov, len veľmi málo z nich bolo označených na použitie na školenie modelu strojového učenia. Pretože väčšina prístupov k problémom NLP využíva výhody hlbokého učenia, na trénovanie potrebujete veľké množstvo údajov.

Skutočne vidíte obrovské vylepšenia modelu, keď bol trénovaný s miliónmi dátových bodov. S cieľom pomôcť prekonať tento problém nedostatku dostatok označených údajov, prišli vedci s spôsobmi, ako trénovať modely reprezentácie jazykov na všeobecné účely prostredníctvom predškolenia pomocou textu z celého internetu.

Tieto vopred vyškolené modely zastúpenia je potom možné doladiť tak, aby fungovali na konkrétnych množinách údajov, ktoré sú menšie ako tie, ktoré sa bežne používajú pri hlbokom učení. Tieto menšie súbory údajov môžu slúžiť na riešenie problémov, ako je analýza sentimentu alebo detekcia spamu. Týmto spôsobom sa pristupuje k väčšine problémov s NLP, pretože poskytuje presnejšie výsledky ako začatie s menšou množinou údajov.

Preto je BERT taký veľký objav. Poskytuje spôsob, ako presnejšie pripraviť vaše modely s menším počtom údajov. Obojsmerný prístup, ktorý používa, znamená, že získa viac kontextu pre slovo, ako keby to bol iba tréning v jednom smere. V tomto dodatočnom kontexte je schopný využiť ďalšiu techniku ​​nazývanú maskovaný LM.

Ako sa líši od iných algoritmov strojového učenia

Maskovaná LM náhodne maskuje 15% slov vo vete tokenom [MASK] a potom sa ich pokúša predpovedať na základe slov obklopujúcich maskované. Takto je BERT schopný pozerať sa na slová zľava doprava aj sprava doľava.

Toto je úplne odlišné od všetkých ostatných existujúcich jazykových modelov, pretože sa pozerá na slová pred a za maskovaným slovom súčasne. Môže za to veľa presnosti, ktorú má BERT.

Ak chcete, aby BERT pracoval s vašou množinou údajov, musíte pridať trochu metadát. Na označenie začiatku a konca viet bude potrebné vložiť tokeny . Aby ste mohli rozlíšiť rôzne vety, musíte mať vložené segmenty . Na záver budete potrebovať pozičné vloženia, ktoré označujú pozíciu slov vo vete.

Bude to vyzerať podobne.

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

S pridanými metadátami k vašim dátovým bodom je maskovaná LM pripravená pracovať.

Keď je predpovedanie slov dokončené, BERT využije predikciu ďalšej vety. Toto sa pozerá na vzťah medzi dvoma vetami. Robí to kvôli lepšiemu pochopeniu kontextu celého súboru údajov, keď vezme dvojicu viet a predpovedá, či je druhá veta nasledujúcou vetou na základe pôvodného textu.

Aby predikcia ďalšej vety fungovala v technike BERT, druhá veta sa odosiela prostredníctvom modelu založeného na transformátore.

Existujú štyri rôzne vopred vyškolené verzie BERT v závislosti od rozsahu údajov, s ktorými pracujete. Viac sa o nich dozviete tu: //github.com/google-research/bert#bert

Nevýhodou tohto prístupu je, že funkcia straty zohľadňuje iba predpovede maskovaného slova, a nie predpovede ostatných. To znamená, že technika BERT konverguje pomalšie ako iné techniky sprava doľava alebo zľava doprava.

BERT sa dá použiť na akýkoľvek problém NLP, na ktorý si spomeniete, vrátane predikcie zámerov, aplikácií na zodpovedanie otázok a klasifikácie textu.

Príklad kódu

Pripravujem sa

Teraz si ukážeme príklad BERT v akcii. Prvá vec, ktorú musíte urobiť, je naklonovať Bertovo repo.

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

Teraz si musíte stiahnuť vopred vyškolené súbory modelu BERT zo stránky BERT GitHub. Vo zvyšku tohto tutoriálu budem adresár tohto repo servera označovať ako koreňový adresár.

Tieto súbory vám poskytnú hyperparametre, váhy a ďalšie veci, ktoré potrebujete, s informáciami, ktoré sa Bert naučil počas predtréningovky. Budem používať model BERT-Base, Uncased, ale na stránke GitHub nájdete niekoľko ďalších možností v rôznych jazykoch.

Niektoré dôvody, prečo by ste si vybrali model BERT-Base, Uncased, sú, ak nemáte prístup k Google TPU, v takom prípade by ste si zvyčajne vybrali model Base.

Ak si myslíte, že veľkosť písmen v texte, ktorý sa pokúšate analyzovať, rozlišuje veľké a malé písmená (veľkosť písmen v texte dáva skutočný kontextový význam), mali by ste model Cased.

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

Cítil som, že je potrebné tu prejsť procesom čistenia údajov, len ak by to niekto predtým nemal. Niekedy sa strojové učenie javí ako kúzlo, ale naozaj je treba čas, aby ste svoje dáta dostali do správneho stavu, aby ste ich mohli trénovať pomocou algoritmu.

BERT je stále relatívne nový, pretože vyšiel v roku 2018, zatiaľ sa však ukázal byť presnejší ako súčasné modely, aj keď je pomalší.