So, how come we will be able to use TensorFlow from R?

Which pc language is maximum intently related to TensorFlow? Whilst at the TensorFlow for R weblog, we’d in fact like the solution to be R, likelihood is that it’s Python (although TensorFlow has authentic bindings for C++, Swift, Javascript, Java, and Pass as smartly).

So why is it you’ll outline a Keras style as

style <- keras_model_sequential() %>%
  layer_dense(gadgets = 32, activation = "relu") %>%
  layer_dense(gadgets = 1)

(great with %>%s and all!) – then educate and overview it, get predictions and plot them, all that with out ever leaving R?

The quick solution is, you will have keras, tensorflow and reticulate put in.
reticulate embeds a Python consultation inside the R procedure. A unmarried procedure manner a unmarried cope with house: The similar gadgets exist, and will also be operated upon, without reference to whether or not they’re observed through R or through Python. On that foundation, tensorflow and keras then wrap the respective Python libraries and assist you to write R code that, in truth, seems like R.

This publish first elaborates somewhat at the brief solution. We then cross deeper into what occurs within the background.

One word on terminology prior to we leap in: At the R facet, we’re making a transparent difference between the programs keras and tensorflow. For Python we’re going to use TensorFlow and Keras interchangeably. Traditionally, those were other, and TensorFlow was once regularly considered one conceivable backend to run Keras on, but even so the pioneering, now discontinued Theano, and CNTK. Standalone Keras does nonetheless exist, however fresh paintings has been, and is being, completed in tf.keras. After all, this makes Python Keras a subset of Python TensorFlow, however all examples on this publish will use that subset so we will be able to use each to confer with the similar factor.

So keras, tensorflow, reticulate, what are they for?

At the beginning, not anything of this might be conceivable with out reticulate. reticulate is an R package deal designed to permit seemless interoperability between R and Python. If we completely sought after, lets assemble a Keras style like this:

<elegance 'tensorflow.python.keras.engine.sequential.Sequential'>

Shall we cross on including layers …

m$upload(tf$keras$layers$Dense(32, "relu"))


However who would need to? If this had been the one approach, it’d be much less bulky to immediately write Python as a substitute. Plus, as a person you’d have to grasp the entire Python-side module construction (now the place do optimizers are living, lately: tf.keras.optimizers, tf.optimizers …?), and stay alongside of all trail and title adjustments within the Python API.

That is the place keras comes into play. keras is the place the TensorFlow-specific usability, re-usability, and comfort options are living.
Capability supplied through keras spans the entire vary between boilerplate-avoidance over enabling chic, R-like idioms to offering manner of complicated function utilization. For instance for the primary two, believe layer_dense which, amongst others, converts its gadgets argument to an integer, and takes arguments in an order that let it to be “pipe-added” to a style: As an alternative of

style <- keras_model_sequential()
style$upload(layer_dense(gadgets = 32L))

we will be able to simply say

style <- keras_model_sequential()
style %>% layer_dense(gadgets = 32)

Whilst those are great to have, there may be extra. Complex capability in (Python) Keras most commonly depends upon the facility to subclass gadgets. One instance is customized callbacks. If you happen to had been the usage of Python, you’d must subclass tf.keras.callbacks.Callback. From R, you’ll create an R6 elegance inheriting from KerasCallback, like so

CustomCallback <- R6::R6Class("CustomCallback",
    inherit = KerasCallback,
    public = listing(
      on_train_begin = serve as(logs) {
        # do one thing
      on_train_end = serve as(logs) {
        # do one thing

It’s because keras defines a real Python elegance, RCallback, and maps your R6 elegance’ find out how to it.
Every other instance is customized fashions, presented in this weblog a few 12 months in the past.
Those fashions will also be skilled with customized coaching loops. In R, you utilize keras_model_custom to create one, for instance, like this:

m <- keras_model_custom(title = "mymodel", serve as(self) {
  self$dense1 <- layer_dense(gadgets = 32, activation = "relu")
  self$dense2 <- layer_dense(gadgets = 10, activation = "softmax")
  serve as(inputs, masks = NULL) {
    self$dense1(inputs) %>%

Right here, keras will make sure that a real Python object is created which subclasses tf.keras.Type and when known as, runs the above nameless serve as().

In order that’s keras. What concerning the tensorflow package deal? As a person you best want it when it’s important to do complicated stuff, like configure TensorFlow instrument utilization or (in TF 1.x) get admission to components of the Graph or the Consultation. Internally, it’s utilized by keras closely. Crucial inside capability comprises, e.g., implementations of S3 strategies, like print, [ or +, on Tensors, so you can operate on them like on R vectors.

Now that we know what each of the packages is “for”, let’s dig deeper into what makes this possible.

Show me the magic: reticulate

Instead of exposing the topic top-down, we follow a by-example approach, building up complexity as we go. We’ll have three scenarios.

First, we assume we already have a Python object (that has been constructed in whatever way) and need to convert that to R. Then, we’ll investigate how we can create a Python object, calling its constructor. Finally, we go the other way round: We ask how we can pass an R function to Python for later usage.

Scenario 1: R-to-Python conversion

Let’s assume we have created a Python object in the global namespace, like this:

So: There is a variable, called x, with value 1, living in Python world. Now how do we bring this thing into R?

We know the main entry point to conversion is py_to_r, defined as a generic in conversion.R:

py_to_r <- function(x) {

… with the default implementation calling a function named py_ref_to_r:

Rcpp : You simply write your C++ serve as, and Rcpp looks after compilation and gives the glue code important to name this serve as from R.

So py_ref_to_r truly is written in C++:

.Name(`_reticulate_py_ref_to_r`, x)

which in the end wraps the “actual” factor, the C++ serve as py_ref_to_R we noticed above.

By way of py_ref_to_r_with_convert in #1, a one-liner that extracts an object’s “convert” function (see underneath)

Extending Python Information.

In authentic phrases, what reticulate does it embed and lengthen Python.
Embed, as it allows you to use Python from inside of R. Prolong, as a result of to permit Python to name again into R it must wrap R purposes in C, so Python can perceive them.

As a part of the previous, the required Python is loaded (Py_Initialize()); as a part of the latter, two purposes are outlined in a brand new module named rpycall, that will likely be loaded when Python itself is loaded.

International Interpreter Lock, this isn’t mechanically the case when different implementations are used, or C is used immediately. So call_python_function_on_main_thread makes positive that except we will be able to execute at the primary thread, we wait.

That’s it for our 3 “spotlights on reticulate”.


It is going with out announcing that there’s so much about reticulate we didn’t quilt on this article, akin to reminiscence control, initialization, or specifics of information conversion. However, we are hoping we had been in a position to shed somewhat of sunshine at the magic concerned with calling TensorFlow from R.

R is a concise and stylish language, however to a prime level its energy comes from its programs, together with those who mean you can name into, and have interaction with, the out of doors international, akin to deep studying frameworks or allotted processing engines. On this publish, it was once a different excitement to concentrate on a central construction block that makes a lot of this conceivable: reticulate.

Thank you for studying!

Like this post? Please share to your friends:
Leave a Reply

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: