Use TensorFlow Package for Deep Learning in R

Introduction

TensorFlow is a python library for numerical computation using data flow graphs, where nodes in the graph represent mathematical operations, and edges represent the multidimensional data arrays (tensors) communicated between the nodes. Its architecture allows us to deploy computation to one or more CPUs or GPUs in a desktop, server, or cloud services with a single API. TensorFlow was originally developed by researchers and engineers working on the Google Brain Team within Google's Machine Intelligence research organization for the purposes of conducting machine learning and deep neural networks research, but the system is general enough to be applicable in a wide variety of other domains as well.

Installation

remotes::install_github("rstudio/tensorflow")

library(tensorflow)
tf$constant("Hellow Tensorflow")

install_tensorflow(version = "2.10.0")

install_tensorflow(version = "gpu")

library(keras)
install_keras(tensorflow = "gpu")

To be verified installation using devtools:

Using Tensor Flow

First, we need to install the keras package, which is the high-level API of TensorFlow 2. This short introduction uses Keras to:

1. Build a neural network that classifies images.
2. Train this neural network.
3. And, finally, evaluate the accuracy of the model.
4. Save and restore the created model.

Let’s start by loading and preparing the MNIST dataset. The values of thee pixels are integers between 0 and 255 and we will convert them to floats between 0 and 1.

library(keras)

mnist = dataset_mnist()

mnist$train$x = mnist$train$x/255

mnist$test$x = mnist$test$x/255

Now, let’s define the a Keras model using the sequential API.

model = keras_model_sequential() 

model = layer_flatten(model, input_shape = c(28, 28))

model = layer_dense (model, units = 128, activation = "relu")

model = layer_dropout(model, 0.2) 

model = layer_dense(model, 10, activation = "softmax")

When using the Sequential API, the first layer must specify the input_shape argument which represents the dimensions of the input. In the above case, images 28x28.

After defining the model, you can see information about layers, number of parameters, etc. with the summary function:

summary(model)

## Model: "sequential"
## ___________________________________________________________________________
## Layer (type)                     Output Shape                  Param #     
## ===========================================================================
## flatten (Flatten)                (None, 784)                   0           
## ___________________________________________________________________________
## dense (Dense)                    (None, 128)                   100480      
## ___________________________________________________________________________
## dropout (Dropout)                (None, 128)                   0           
## ___________________________________________________________________________
## dense_1 (Dense)                  (None, 10)                    1290        
## ===========================================================================
## Total params: 101,770
## Trainable params: 101,770
## Non-trainable params: 0
## ___________________________________________________________________________

The next step after building the model is to compile it. It’s at compile time that we define what loss will be optimized and what optimizer will be used. You can also specify metrics, callbacks and etc that are meant to be run during the model fitting.

Compiling is done with the compile function: 

compile(model, loss = "sparse_categorical_crossentropy", optimizer = "adam", metrics = "accuracy")

Note that compile and fit (which we are going to see next) modify the model object in place, unlike most R functions.

Now let’s fit our model:

history = fit(model, x = mnist$train$x, y = mnist$train$y, epochs = 5,validation_split = 0.3, verbose = 2)

## Train on 42000 samples, validate on 18000 samples
## Epoch 1/5
## 42000/42000 - 3s - loss: 0.3442 - accuracy: 0.9008 - val_loss: 0.1780 - val_accuracy: 0.9484
## Epoch 2/5
## 42000/42000 - 3s - loss: 0.1682 - accuracy: 0.9498 - val_loss: 0.1356 - val_accuracy: 0.9599
## Epoch 3/5
## 42000/42000 - 3s - loss: 0.1242 - accuracy: 0.9626 - val_loss: 0.1233 - val_accuracy: 0.9622
## Epoch 4/5
## 42000/42000 - 3s - loss: 0.0999 - accuracy: 0.9697 - val_loss: 0.1072 - val_accuracy: 0.9685
## Epoch 5/5
## 42000/42000 - 3s - loss: 0.0834 - accuracy: 0.9739 - val_loss: 0.0966 - val_accuracy: 0.9731

Plot the training history. We will see loss, val_loss, accuracy, and val_accuracy over the training epochs. The values val_loss and val_accuracy are computed using evaluation training set. 

plot(history)

We can also evaluate the model using test dataset:

evaluate(model, mnist$test$x, mnist$test$y)

We can now make predictions with our model using the predict function:

predictions = predict(model, mnist$test$x)
head(predictions, 2)

##              [,1]         [,2]         [,3]         [,4]         [,5]
## [1,] 1.079081e-07 1.105458e-08 4.597065e-05 2.821549e-04 5.768893e-11
## [2,] 2.735454e-06 6.786310e-04 9.992226e-01 8.388522e-05 3.788405e-13
##              [,6]         [,7]         [,8]         [,9]        [,10]
## [1,] 5.044960e-07 3.673492e-14 9.996552e-01 4.329958e-07 1.558235e-05
## [2,] 4.735405e-08 1.990466e-07 3.531684e-11 1.182519e-05 3.717427e-13

By default predict will return the output of the last Keras layer. In our case this is the probability for each class. You can also use predict_classes and predict_proba to generate class and probability - these functions are slighly different then predict since they will be run in batches.

You can access the model performance on a different dataset using the evaluate function, for example:

evaluate(model, mnist$test$x, mnist$test$y, verbose = 0)

## $loss
## [1] 0.0833252
## 
## $accuracy
## [1] 0.9741

Our model achieved ~90% accuracy on the test set.

Unlike models built with the lm function, to save Keras models for later prediction, you need to use specialized functions, like save_model_tf:

 save_model_tf(object = model, filepath = "model")

The above model will be saved into the folder called "model" inside the working directory. You can then reload the model and make predictions with:

reloaded_model = load_model_tf("model")
all.equal(predict(model, minist$test$x), predict(reloaded_model, mnist$test$x)