Tutorial de aprendizaje automático de Google BERT NLP

Hay muchas aplicaciones para el aprendizaje automático, y una de ellas es el procesamiento del lenguaje natural o PNL.

La PNL maneja cosas como respuestas de texto, descifrar el significado de las palabras dentro del contexto y mantener conversaciones con nosotros. Ayuda a las computadoras a comprender el lenguaje humano para que podamos comunicarnos de diferentes maneras.

Desde los bots de chat hasta las solicitudes de empleo y la clasificación de su correo electrónico en diferentes carpetas, la PNL se utiliza en todas partes a nuestro alrededor.

En esencia, el procesamiento del lenguaje natural es una combinación de informática y lingüística. La lingüística nos brinda las reglas que debemos usar para entrenar nuestros modelos de aprendizaje automático y obtener los resultados que buscamos.

Hay muchas razones por las que el procesamiento del lenguaje natural se ha convertido en una parte importante del aprendizaje automático. Ayuda a las máquinas a detectar el sentimiento de los comentarios de un cliente, puede ayudar a clasificar los tickets de soporte para cualquier proyecto en el que esté trabajando y puede leer y comprender el texto de manera consistente.

Y dado que opera con un conjunto de reglas lingüísticas, no tiene los mismos prejuicios que los humanos.

Dado que la PNL es un área de estudio tan grande, hay una serie de herramientas que puede utilizar para analizar datos para sus propósitos específicos.

Existe el enfoque basado en reglas en el que se configuran muchas declaraciones si-entonces para manejar cómo se interpreta el texto. Por lo general, un lingüista será responsable de esta tarea y lo que producen es muy fácil de entender para la gente.

Esto puede ser bueno para empezar, pero se vuelve muy complejo a medida que comienza a trabajar con grandes conjuntos de datos.

Otro enfoque es utilizar el aprendizaje automático donde no es necesario definir reglas. Esto es excelente cuando intenta analizar grandes cantidades de datos de forma rápida y precisa.

Elegir el algoritmo correcto para que el enfoque de aprendizaje automático funcione es importante en términos de eficiencia y precisión. Existen algoritmos comunes como Naïve Bayes y Support Vector Machines. Luego están los algoritmos más específicos como Google BERT.

¿Qué es BERT?

BERT es una biblioteca de código abierto creada en 2018 en Google. Es una técnica nueva para la PNL y adopta un enfoque de modelos de entrenamiento completamente diferente al de cualquier otra técnica.

BERT es un acrónimo de Representaciones de codificador bidireccional de Transformers. Eso significa que, a diferencia de la mayoría de las técnicas que analizan oraciones de izquierda a derecha o de derecha a izquierda, BERT va en ambas direcciones usando el codificador Transformer. Su objetivo es generar un modelo de lenguaje.

Esto le da una precisión y un rendimiento increíbles en conjuntos de datos más pequeños, lo que resuelve un gran problema en el procesamiento del lenguaje natural.

Si bien hay una gran cantidad de datos basados ​​en texto disponibles, muy pocos de ellos han sido etiquetados para usarlos en el entrenamiento de un modelo de aprendizaje automático. Dado que la mayoría de los enfoques para los problemas de PNL aprovechan el aprendizaje profundo, necesita grandes cantidades de datos para entrenar.

Realmente se ven las grandes mejoras en un modelo cuando se ha entrenado con millones de puntos de datos. Para ayudar a solucionar este problema de no tener suficientes datos etiquetados, los investigadores idearon formas de entrenar modelos de representación del lenguaje de propósito general a través del entrenamiento previo utilizando texto de Internet.

Estos modelos de representación previamente entrenados se pueden ajustar para que funcionen en conjuntos de datos específicos que son más pequeños que los que se usan comúnmente en el aprendizaje profundo. Estos conjuntos de datos más pequeños pueden ser para problemas como el análisis de opiniones o la detección de spam. Esta es la forma en que se abordan la mayoría de los problemas de PNL porque proporciona resultados más precisos que comenzar con un conjunto de datos más pequeño.

Es por eso que BERT es un gran descubrimiento. Proporciona una forma de pre-entrenar con mayor precisión sus modelos con menos datos. El enfoque bidireccional que utiliza significa que obtiene más contexto para una palabra que si solo estuviera entrenando en una dirección. Con este contexto adicional, puede aprovechar otra técnica llamada LM enmascarada.

En qué se diferencia de otros algoritmos de aprendizaje automático

Masked LM enmascara al azar el 15% de las palabras en una oración con un símbolo [MASK] y luego intenta predecirlas basándose en las palabras que rodean al enmascarado. Así es como BERT puede ver las palabras de izquierda a derecha y de derecha a izquierda.

Esto es completamente diferente de cualquier otro modelo de lenguaje existente porque mira las palabras antes y después de una palabra enmascarada al mismo tiempo. Gran parte de la precisión que tiene BERT se puede atribuir a esto.

Para que BERT funcione con su conjunto de datos, debe agregar un poco de metadatos. Deberá haber incrustaciones de tokens para marcar el principio y el final de las oraciones. Deberá tener incrustaciones de segmentos para poder distinguir diferentes oraciones. Por último, necesitará incrustaciones posicionales para indicar la posición de las palabras en una oración.

Se verá similar a esto.

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

Con los metadatos agregados a sus puntos de datos, LM enmascarado está listo para funcionar.

Una vez que ha terminado de predecir palabras, BERT aprovecha la predicción de la siguiente oración. Esto analiza la relación entre dos oraciones. Hace esto para comprender mejor el contexto de todo el conjunto de datos al tomar un par de oraciones y predecir si la segunda oración es la siguiente en función del texto original.

For next sentence prediction to work in the BERT technique, the second sentence is sent through the Transformer based model.

There are four different pre-trained versions of BERT depending on the scale of data you're working with. You can learn more about them here: //github.com/google-research/bert#bert

The drawback to this approach is that the loss function only considers the masked word predictions and not the predictions of the others. That means the BERT technique converges slower than the other right-to-left or left-to-right techniques.

BERT can be applied to any NLP problem you can think of, including intent prediction, question-answering applications, and text classification.

Code Example

Getting set up

Now we're going to go through an example of BERT in action. First thing you'll need to do is clone the Bert repo.

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

Now you need to download the pre-trained BERT model files from the BERT GitHub page. Throughout the rest of this tutorial, I'll refer to the directory of this repo as the root directory.

These files give you the hyper-parameters, weights, and other things you need with the information Bert learned while pre-training. I'll be using the BERT-Base, Uncased model, but you'll find several other options across different languages on the GitHub page.

Some reasons you would choose the BERT-Base, Uncased model is if you don't have access to a Google TPU, in which case you would typically choose a Base model.

If you think the casing of the text you're trying to analyze is case-sensitive (the casing of the text gives real contextual meaning), then you would go with a Cased model.

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.