Keras Backend

Overview

Keras is a model-level library, providing high-level building blocks for developing deep learning models. It does not handle itself low-level operations such as tensor products, convolutions and so on. Instead, it relies on a specialized, well-optimized tensor manipulation library to do so, serving as the “backend engine” of Keras.

The R interface to Keras uses TensorFlow™ as it’s default tensor backend engine, however it’s possible to use other backends if desired. At this time, Keras has three backend implementations available:

TensorFlow is an open-source symbolic tensor manipulation framework developed by Google.
Theano is an open-source symbolic tensor manipulation framework developed by LISA Lab at Université de Montréal.
CNTK is an open-source toolkit for deep learning developed by Microsoft.

Selecting a Backend

Keras uses the TensorFlow backend by default. If you want to switch to Theano or CNTK call the use_backend() function just after your call to library(keras). For example:

library(keras)
use_backend("theano")

If you want to use the CNTK backend then you should follow the installation instructions for CNTK and then speicfy “cntk” in your call to use_backend():

library(keras)
use_backend("cntk")

Selecting an Implementation

Keras specifies an API that can be implemented by multiple providers. By default, the Keras R package uses the implementation provided by the Keras Python package (“keras”). TensorFlow also provides an integrated implementation of Keras which you can use by specifying “tensorflow” in a call to the use_implementation() function. For example:

library(keras)
use_implementation("tensorflow")

You would typically specify the “tensorflow” implementation when using Keras with the tfestimators package, as this implementation allows you to use Keras models seamlessly as TensorFlow Estimators.

Keras Configuration File

If you have run Keras at least once, you will find the Keras configuration file at:

~/.keras/keras.json

If it isn’t there, you can create it.

The default configuration file looks like this:

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "tensorflow"
}

You can change these settings by editing $HOME/.keras/keras.json.

image_data_format: String, either "channels_last" or "channels_first". It specifies which data format convention Keras will follow. (backend()$image_data_format() returns it.)
- For 2D data (e.g. image), "channels_last" assumes (rows, cols, channels) while "channels_first" assumes (channels, rows, cols).
- For 3D data, "channels_last" assumes (conv_dim1, conv_dim2, conv_dim3, channels) while "channels_first" assumes (channels, conv_dim1, conv_dim2, conv_dim3).
epsilon: Float, a numeric fuzzing constant used to avoid dividing by zero in some operations.
floatx: String, "float16", "float32", or "float64". Default float precision.
backend: String, "tensorflow", "theano", or "cntk".

Using the Backend

If you want the Keras modules you write to be compatible with all available backends, you have to write them via the abstract Keras backend API. Backend API functions have a k_ prefix (e.g. k_placeholder, k_constant, k_dot, etc.).

For example, the code below instantiates an input placeholder. It’s equivalent to tf$placeholder():

library(keras)
inputs <- k_placeholder(shape = c(2, 4, 5))
# also works:
inputs <-  k_placeholder(shape = list(NULL, 4, 5))
# also works:
inputs <- k_placeholder(ndim = 3)

The code below instantiates a variable. It’s equivalent to tf$Variable():

val <- array(runif(60), dim = c(3L, 4L, 5L))
var <- k_variable(value = val)

# all-zeros variable:
var <- k_zeros(shape = c(3, 4, 5))
# all-ones:
var <- k_ones(shape = c(3, 4, 5))

Backend Functions