## Introduction

Word embedding is a method used to map words of a vocabulary to dense vectors of real numbers where semantically similar words are mapped to nearby points. Representing words in this vector space help algorithms achieve better performance in natural language processing tasks like syntactic parsing and sentiment analysis by grouping similar words. For example, we expect that in the embedding space “cats” and “dogs” are mapped to nearby points since they are both animals, mammals, pets, etc.

In this tutorial we will implement the skip-gram model created by Mikolov et al in R using the keras package. The skip-gram model is a flavor of word2vec, a class of computationally-efficient predictive models for learning word embeddings from raw text. We won’t address theoretical details about embeddings and the skip-gram model. If you want to get more details you can read the paper linked above. The TensorFlow Vector Representation of Words tutorial includes additional details as does the *Deep Learning With R* notebook about embeddings.

There are other ways to create vector representations of words. For example, GloVe Embeddings are implemented in the text2vec package by Dmitriy Selivanov. There’s also a tidy approach described in Julia Silge’s blog post Word Vectors with Tidy Data Principles.

## Getting the Data

We will use the Amazon Fine Foods Reviews dataset. This dataset consists of reviews of fine foods from Amazon. The data span a period of more than 10 years, including all ~500,000 reviews up to October 2012. Reviews include product and user information, ratings, and narrative text.

Data can be downloaded (~116MB) by running:

```
download.file("https://snap.stanford.edu/data/finefoods.txt.gz", "finefoods.txt.gz")
```

We will now load the plain text reviews into R.

Let’s take a look at some reviews we have in the dataset.

```
[1] "I have bought several of the Vitality canned dog food products ...
[2] "Product arrived labeled as Jumbo Salted Peanuts...the peanuts ...
```

## Preprocessing

We’ll begin with some text pre-processing using a keras `text_tokenizer()`

. The tokenizer will be responsible for transforming each review into a sequence of integer tokens (which will subsequently be used as input into the skip-gram model).

Note that the `tokenizer`

object is modified in place by the call to `fit_text_tokenizer()`

. An integer token will be assigned for each of the 20,000 most common words (the other words will be assigned to token 0).

## Skip-Gram Model

In the skip-gram model we will use each word as input to a log-linear classifier with a projection layer, then predict words within a certain range before and after this word. It would be very computationally expensive to output a probability distribution over all the vocabulary for each target word we input into the model. Instead, we are going to use negative sampling, meaning we will sample some words that don’t appear in the context and train a binary classifier to predict if the context word we passed is truly from the context or not.

In more practical terms, for the skip-gram model we will input a 1d integer vector of the target word tokens and a 1d integer vector of sampled context word tokens. We will generate a prediction of 1 if the sampled word really appeared in the context and 0 if it didn’t.

We will now define a generator function to yield batches for model training.

```
library(reticulate)
library(purrr)
skipgrams_generator <- function(text, tokenizer, window_size, negative_samples) {
gen <- texts_to_sequences_generator(tokenizer, sample(text))
function() {
skip <- generator_next(gen) %>%
skipgrams(
vocabulary_size = tokenizer$num_words,
window_size = window_size,
negative_samples = 1
)
x <- transpose(skip$couples) %>% map(. %>% unlist %>% as.matrix(ncol = 1))
y <- skip$labels %>% as.matrix(ncol = 1)
list(x, y)
}
}
```

A generator function is a function that returns a different value each time it is called (generator functions are often used to provide streaming or dynamic data for training models). Our generator function will receive a vector of texts, a tokenizer and the arguments for the skip-gram (the size of the window around each target word we examine and how many negative samples we want to sample for each target word).

Now let’s start defining the keras model. We will use the Keras functional API.

```
embedding_size <- 128 # Dimension of the embedding vector.
skip_window <- 5 # How many words to consider left and right.
num_sampled <- 1 # Number of negative examples to sample for each word.
```

We will first write placeholders for the inputs using the `layer_input`

function.

```
input_target <- layer_input(shape = 1)
input_context <- layer_input(shape = 1)
```

Now let’s define the embedding matrix. The embedding is a matrix with dimensions (vocabulary, embedding_size) that acts as lookup table for the word vectors.

The next step is to define how the `target_vector`

will be related to the `context_vector`

in order to make our network output 1 when the context word really appeared in the context and 0 otherwise. We want `target_vector`

to be *similar* to the `context_vector`

if they appeared in the same context. A typical measure of similarity is the cosine similarity. Give two vectors (A) and (B) the cosine similarity is defined by the Euclidean Dot product of (A) and (B) normalized by their magnitude. As we don’t need the similarity to be normalized inside the network, we will only calculate the dot product and then output a dense layer with sigmoid activation.

```
dot_product <- layer_dot(list(target_vector, context_vector), axes = 1)
output <- layer_dense(dot_product, units = 1, activation = "sigmoid")
```

Now we will create the model and compile it.

We can see the full definition of the model by calling `summary`

:

```
_________________________________________________________________________________________
Layer (type) Output Shape Param # Connected to
=========================================================================================
input_1 (InputLayer) (None, 1) 0
_________________________________________________________________________________________
input_2 (InputLayer) (None, 1) 0
_________________________________________________________________________________________
embedding (Embedding) (None, 1, 128) 2560128 input_1[0][0]
input_2[0][0]
_________________________________________________________________________________________
flatten_1 (Flatten) (None, 128) 0 embedding[0][0]
_________________________________________________________________________________________
flatten_2 (Flatten) (None, 128) 0 embedding[1][0]
_________________________________________________________________________________________
dot_1 (Dot) (None, 1) 0 flatten_1[0][0]
flatten_2[0][0]
_________________________________________________________________________________________
dense_1 (Dense) (None, 1) 2 dot_1[0][0]
=========================================================================================
Total params: 2,560,130
Trainable params: 2,560,130
Non-trainable params: 0
_________________________________________________________________________________________
```

## Model Training

We will fit the model using the `fit_generator()`

function We need to specify the number of training steps as well as number of epochs we want to train. We will train for 100,000 steps for 5 epochs. This is quite slow (~1000 seconds per epoch on a modern GPU). Note that you may also get reasonable results with just one epoch of training.

```
model %>%
fit_generator(
skipgrams_generator(reviews, tokenizer, skip_window, negative_samples),
steps_per_epoch = 100000, epochs = 5
)
```

```
Epoch 1/1
100000/100000 [==============================] - 1092s - loss: 0.3749
Epoch 2/5
100000/100000 [==============================] - 1094s - loss: 0.3548
Epoch 3/5
100000/100000 [==============================] - 1053s - loss: 0.3630
Epoch 4/5
100000/100000 [==============================] - 1020s - loss: 0.3737
Epoch 5/5
100000/100000 [==============================] - 1017s - loss: 0.3823
```

We can now extract the embeddings matrix from the model by using the `get_weights()`

function. We also added `row.names`

to our embedding matrix so we can easily find where each word is.

## Understanding the Embeddings

We can now find words that are close to each other in the embedding. We will use the cosine similarity, since this is what we trained the model to minimize.

```
find_similar_words("2", embedding_matrix)
```

```
2 4 3 two 6
1.0000000 0.9830254 0.9777042 0.9765668 0.9722549
```

```
find_similar_words("little", embedding_matrix)
```

```
little bit few small treat
1.0000000 0.9501037 0.9478287 0.9309829 0.9286966
```

```
find_similar_words("delicious", embedding_matrix)
```

```
delicious tasty wonderful amazing yummy
1.0000000 0.9632145 0.9619508 0.9617954 0.9529505
```

```
find_similar_words("cats", embedding_matrix)
```

```
cats dogs kids cat dog
1.0000000 0.9844937 0.9743756 0.9676026 0.9624494
```

The **t-SNE** algorithm can be used to visualize the embeddings. Because of time constraints we will only use it with the first 500 words. To understand more about the *t-SNE* method see the article How to Use t-SNE Effectively.

This plot may look like a mess, but if you zoom into the small groups you end up seeing some nice patterns. Try, for example, to find a group of web related words like `http`

, `href`

, etc. Another group that may be easy to pick out is the pronouns group: `she`

, `he`

, `her`

, etc.