TensorFlow tensors

Rank 0

The following snippet demonstrates creating a few rank 0 variables:

library(tensorflow)
mammal <- tf$Variable("Elephant", tf$string)
ignition <- tf$Variable(451, tf$int16)
floating <- tf$Variable(3.14159265359, tf$float64)
its_complicated <- tf$Variable(12.3 - 4.85i, tf$complex64)

Note: A string is treated as a single object in TensorFlow, not as a sequence of characters. It is possible to have scalar strings, vectors of strings, etc.

Rank 1

To create a rank 1 tf.Tensor object, you can pass a list of items as the initial value. For example:

mystr <- tf$Variable(c("Hello"), tf$string)
cool_numbers <- tf$Variable(c(3.14159, 2.71828), tf$float32)
first_primes <- tf$Variable(c(2, 3, 5, 7, 11), tf$int32)
its_very_complicated <- tf$Variable(c(12.3 - 4.85i, 7.5 - 6.23i), tf$complex64)

Higher ranks

A rank 2 tf$Tensor object consists of at least one row and at least one column:

mymat <- tf$Variable(list(c(7, 2),c(11, 3)), tf$int16)

Higher-rank Tensors, similarly, consist of an n-dimensional array. For example, during image processing, many tensors of rank 4 are used, with dimensions corresponding to example-in-batch, image height, image width, and color channel.

my_image <- tf$zeros(shape = shape(10, 299, 299, 3)) # batch x height x width x color

Getting a tf$Tensor object’s rank

To determine the rank of a tf$Tensor object, call the tf$rank method. For example, the following method programmatically determines the rank of the tf$Tensor defined in the previous section:

r <- tf$rank(my_image)
r

## tf.Tensor(4, shape=(), dtype=int32)

Referring to tf$Tensor slices

Tensor elements can be extracted either by using functions like tf$gather() and tf$slice(), or by using [ syntax.

Extracting tensor elements with [ in R is similar to extracting elements from standard R arrays, albeit with some minor differences in capabilities. In contrast to most tf$ functions, [ defaults to R style 1-based rather than 0-based indexes. Currently, only numeric indexes in [ are supported (no logical or character indexes)

Extracting works identically to R arrays if the slicing index is missing, supplied as a scalar, or as a sequence (e.g, created by : or seq_len())

x[,1] )      # all rows, first column
x[1:2,] )    # first two rows, all columns
x[,1, drop = FALSE] ) # all rows, first column, but preserving the tensor rank

[ also supports slices with a strided step, which can be specified in traditional R style with seq() or with a python-style second colon. If you are unfamiliar with python-style strided step syntax, see here for a quick primer

x[, seq(1, 5, by = 2)]  # R style
x[, 1:5:2]              # Equivalent python-style strided step 

Missing arguments for python syntax are valid, but they must be supplied as NULL or whole expression must by backticked.

x[, `::2`] 
x[, NULL:NULL:2] 
x[, `2:`] 

[ also accepts tf$newaxis and all_dims() as arguments

x[,, tf$newaxis]
x[all_dims(), 1] # all_dims expands to the shape of the tensor

An important difference between extracting R arrays and tensorflow tensors with [ is how negative numbers are interpreted. For tensorflow tensors, negative numbers are interpreted as selecting elements by counting from tail (e.g, they are interpreted python-style).

x[-1,]  # the last row

Tensors are accepted by [ as well, but note that tensors suplied to [ are not translated from R to python. Meaning that tensors are interpreted as 0-based, and if slicing a range with :, then the returned arrays is exclusive of the upper bound.

x[, tf$constant(1L)] # second column
x[, tf$constant(0L):tf$constant(2L)] # first two columns

If you are translating existing python code to R, note that you can set an option to have all [ arguments be interpreted pure-python style by setting options(tensorflow.extract.style = "python"). See ?`[.tensorflow.tensor` for additional options and details.

Getting a tf$Tensor object’s shape

There are two ways of accessing the shape of a tf$Tensor. While building the graph, it is often useful to ask what is already known about a tensor’s shape. This can be done by reading the shape property of a tf$Tensor object. This method returns a TensorShape object, which is a convenient way of representing partially-specified shapes (since, when building the graph, not all shapes will be fully known).

It is also possible to get a tf$Tensor that will represent the fully-defined shape of another tf$Tensor at runtime. This is done by calling the tf$shape operation. This way, you can build a graph that manipulates the shapes of tensors by building other tensors that depend on the dynamic shape of the input tf$Tensor.

For example, here is how to make a vector of zeros with the same size as the number of columns in a given matrix:

zeros <- tf$zeros(my_image$shape[2])

Changing the shape of a tf$Tensor

The number of elements of a tensor is the product of the sizes of all its shapes. The number of elements of a scalar is always 1. Since there are often many different shapes that have the same number of elements, it’s often convenient to be able to change the shape of a tf.Tensor, keeping its elements fixed. This can be done with tf.reshape.

The following examples demonstrate how to reshape tensors:

rank_three_tensor <- tf$ones(shape(3, 4, 5))
matrix <- tf$reshape(rank_three_tensor, shape(6, 10))  # Reshape existing content into
                                                 # a 6x10 matrix
matrixB <- tf$reshape(matrix, shape(3, -1))  #  Reshape existing content into a 3x20
                                       # matrix. -1 tells reshape to calculate
                                       # the size of this dimension.
matrixAlt <- tf$reshape(matrixB, shape(4, 3, -1))  # Reshape existing content into a
                                             #4x3x5 tensor

# Note that the number of elements of the reshaped Tensors has to match the
# original number of elements. Therefore, the following example generates an
# error because no possible value for the last dimension will match the number
# of elements.