Google BERT NLP-Lernprogramm für maschinelles Lernen

Es gibt viele Anwendungen für maschinelles Lernen, und eine davon ist die Verarbeitung natürlicher Sprache oder NLP.

NLP behandelt Dinge wie Textantworten, findet die Bedeutung von Wörtern im Kontext heraus und führt Gespräche mit uns. Es hilft Computern, die menschliche Sprache zu verstehen, sodass wir auf unterschiedliche Weise kommunizieren können.

Von Chat-Bots über Bewerbungen bis hin zum Sortieren Ihrer E-Mails in verschiedene Ordner wird NLP überall in unserer Umgebung verwendet.

Die Verarbeitung natürlicher Sprache ist im Kern eine Mischung aus Informatik und Linguistik. Die Linguistik gibt uns die Regeln, nach denen wir unsere Modelle für maschinelles Lernen trainieren und die gewünschten Ergebnisse erzielen können.

Es gibt viele Gründe, warum die Verarbeitung natürlicher Sprache zu einem großen Teil des maschinellen Lernens geworden ist. Es hilft Maschinen dabei, die Stimmung anhand des Kundenfeedbacks zu erkennen, Support-Tickets für alle Projekte zu sortieren, an denen Sie arbeiten, und Text konsistent zu lesen und zu verstehen.

Und da es nach einer Reihe von Sprachregeln arbeitet, hat es nicht die gleichen Vorurteile wie ein Mensch.

Da NLP ein so großes Studiengebiet ist, gibt es eine Reihe von Tools, mit denen Sie Daten für Ihre spezifischen Zwecke analysieren können.

Es gibt einen regelbasierten Ansatz, bei dem Sie viele Wenn-Dann-Anweisungen einrichten, um die Interpretation von Text zu handhaben. Normalerweise ist ein Linguist für diese Aufgabe verantwortlich und was sie produzieren, ist für die Menschen sehr leicht zu verstehen.

Dies mag zunächst gut sein, wird jedoch sehr komplex, wenn Sie mit großen Datenmengen arbeiten.

Ein anderer Ansatz ist das maschinelle Lernen, bei dem Sie keine Regeln definieren müssen. Dies ist ideal, wenn Sie versuchen, große Datenmengen schnell und genau zu analysieren.

Die Auswahl des richtigen Algorithmus, damit der Ansatz des maschinellen Lernens funktioniert, ist im Hinblick auf Effizienz und Genauigkeit wichtig. Es gibt gängige Algorithmen wie Naive Bayes und Support Vector Machines. Dann gibt es die spezifischeren Algorithmen wie Google BERT.

Was ist BERT?

BERT ist eine Open-Source-Bibliothek, die 2018 bei Google erstellt wurde. Es ist eine neue Technik für NLP und es gibt einen völlig anderen Ansatz für Trainingsmodelle als jede andere Technik.

BERT ist eine Abkürzung für Bidirectional Encoder Representations from Transformers. Dies bedeutet, dass BERT im Gegensatz zu den meisten Techniken, die Sätze von links nach rechts oder von rechts nach links analysieren, mit dem Transformer-Encoder in beide Richtungen geht. Ziel ist es, ein Sprachmodell zu generieren.

Dies gibt ihm eine unglaubliche Genauigkeit und Leistung bei kleineren Datensätzen, was ein großes Problem bei der Verarbeitung natürlicher Sprache löst.

Obwohl eine große Menge textbasierter Daten verfügbar ist, wurde nur sehr wenig davon für das Training eines maschinellen Lernmodells gekennzeichnet. Da die meisten Ansätze für NLP-Probleme Deep Learning nutzen, benötigen Sie große Datenmengen, um damit zu trainieren.

Sie sehen wirklich die enormen Verbesserungen in einem Modell, wenn es mit Millionen von Datenpunkten trainiert wurde. Um dieses Problem zu umgehen, dass nicht genügend beschriftete Daten vorhanden sind, haben die Forscher Möglichkeiten gefunden, Allzweck-Sprachrepräsentationsmodelle durch Vorschulung unter Verwendung von Text aus dem Internet zu trainieren.

Diese vorab trainierten Repräsentationsmodelle können dann so optimiert werden, dass sie an bestimmten Datensätzen arbeiten, die kleiner sind als diejenigen, die üblicherweise beim Deep Learning verwendet werden. Diese kleineren Datensätze können Probleme wie die Stimmungsanalyse oder die Spam-Erkennung verursachen. Auf diese Weise werden die meisten NLP-Probleme angegangen, da sie genauere Ergebnisse liefern als mit dem kleineren Datensatz zu beginnen.

Deshalb ist BERT eine so große Entdeckung. Es bietet eine Möglichkeit, Ihre Modelle mit weniger Daten genauer vorab zu trainieren. Der bidirektionale Ansatz bedeutet, dass ein Wort mehr Kontext erhält, als wenn nur in eine Richtung trainiert würde. Mit diesem zusätzlichen Kontext kann eine andere Technik namens maskiertes LM genutzt werden.

Wie es sich von anderen Algorithmen für maschinelles Lernen unterscheidet

Masked LM maskiert zufällig 15% der Wörter in einem Satz mit einem [MASK] -Token und versucht dann, sie basierend auf den Wörtern vorherzusagen, die das maskierte umgeben. Auf diese Weise kann BERT Wörter von links nach rechts und von rechts nach links betrachten.

Dies unterscheidet sich grundlegend von jedem anderen vorhandenen Sprachmodell, da die Wörter vor und nach einem maskierten Wort gleichzeitig betrachtet werden. Ein Großteil der Genauigkeit, die BERT hat, kann darauf zurückgeführt werden.

Damit BERT mit Ihrem Datensatz funktioniert, müssen Sie einige Metadaten hinzufügen. Es müssen Token-Einbettungen vorhanden sein , um den Anfang und das Ende von Sätzen zu markieren. Sie benötigen Segmenteinbettungen , um verschiedene Sätze unterscheiden zu können. Zuletzt benötigen Sie Positionseinbettungen , um die Position von Wörtern in einem Satz anzugeben.

Es wird ähnlich aussehen.

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

Mit den zu Ihren Datenpunkten hinzugefügten Metadaten ist der maskierte LM einsatzbereit.

Sobald die Vorhersage der Wörter abgeschlossen ist, nutzt BERT die Vorhersage des nächsten Satzes. Dies befasst sich mit der Beziehung zwischen zwei Sätzen. Dies geschieht, um den Kontext des gesamten Datensatzes besser zu verstehen, indem ein Satzpaar genommen und anhand des Originaltextes vorhergesagt wird, ob der zweite Satz der nächste Satz ist.

Damit die Vorhersage des nächsten Satzes in der BERT-Technik funktioniert, wird der zweite Satz über das Transformer-basierte Modell gesendet.

Abhängig vom Umfang der Daten, mit denen Sie arbeiten, gibt es vier verschiedene vorab trainierte Versionen von BERT. Weitere Informationen finden Sie hier: //github.com/google-research/bert#bert

Der Nachteil dieses Ansatzes besteht darin, dass die Verlustfunktion nur die maskierten Wortvorhersagen berücksichtigt und nicht die Vorhersagen der anderen. Dies bedeutet, dass die BERT-Technik langsamer konvergiert als die anderen Techniken von rechts nach links oder von links nach rechts.

BERT kann auf jedes denkbare NLP-Problem angewendet werden, einschließlich Vorsatzvorhersage, Beantwortung von Fragen und Textklassifizierung.

Codebeispiel

Einrichten

Jetzt werden wir ein Beispiel für BERT in Aktion durchgehen. Als erstes müssen Sie das Bert-Repo klonen.

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

Jetzt müssen Sie die vorgefertigten BERT-Modelldateien von der BERT GitHub-Seite herunterladen. Im weiteren Verlauf dieses Tutorials werde ich das Verzeichnis dieses Repos als Stammverzeichnis bezeichnen.

Diese Dateien enthalten die Hyperparameter, Gewichte und andere Dinge, die Sie mit den Informationen benötigen, die Bert vor dem Training gelernt hat. Ich werde das BERT-Base, Uncased-Modell verwenden, aber auf der GitHub-Seite finden Sie mehrere andere Optionen in verschiedenen Sprachen.

Einige Gründe, warum Sie sich für das BERT-Base-Modell ohne Gehäuse entscheiden, sind, wenn Sie keinen Zugriff auf eine Google-TPU haben. In diesem Fall wählen Sie normalerweise ein Basismodell.

Wenn Sie der Meinung sind, dass die Groß- und Kleinschreibung des zu analysierenden Textes zwischen Groß- und Kleinschreibung unterscheidet (die Groß- und Kleinschreibung des Textes gibt eine echte kontextbezogene Bedeutung), würden Sie sich für ein Cased-Modell entscheiden.

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.