Step 1: Defining nodes

Let’s create a constant node as the first example.

Note that the symbol . in the Python language is replaced by $ in R.

hello <- tf$constant('Hello, TensorFlow!')

Other commonly used two types of Tensorflow nodes containing values are:

• tf.Variable: Helps to store a variable(the value could be changed during the computation). This is the most common one used when doing machine learning.

• tf.placeholder: Helps to store a value which is post-defined when feeding it to the graph using feed_dict.

Step 2: Defining session

sess <- tf$Session()

Step 3: Running session

sess$run(hello)

Step 4: Closing session

Note that we must remember to close the session after we finish the computation. Problems may arise in a new computation if you forget to shut down the previous.

sess$close()

Useful reference

Image interpolation with Tensorflow

More about low-level APIs

Tensorflow core functions for Python

Step 1: Data processing

Fetch the data online.

iris <- read.csv(url("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"), header = TRUE) 

Let’s split the dataset into training/test set.

Normalization could also be applied to dataset using normalize() function provided by Keras. While in this example this step is not necessary.

ind <- sample(2, nrow(iris), replace=TRUE, prob=c(0.67, 0.33))

# Split the `iris` data
iris.training <- data.matrix(iris[ind==1, 1:4])
iris.test <- data.matrix(iris[ind==2, 1:4])

# Split the class attribute
iris.trainingtarget <- iris[ind==1, 5]
iris.testtarget <- iris[ind==2, 5]

For this multi-class classification problem, we need to transform the category type from “factor” to “integer”(indicator). This is also called the one-hot encoding. e.g. \([1,0,0]\) indicates Setosa, \([0,1,0]\) indicates Versicolor, \([0,0,1]\) indicates Virginica. Thus the output label could be a \(n\times3\) matrix.

Fortunately, Keras provides a function to_categorical() for doing this.

iris.trainLabels <- to_categorical(as.numeric(iris.trainingtarget))[,-1]

iris.testLabels <- to_categorical(as.numeric(iris.testtarget))[,-1]

Step 2: Model building

We could now start to build our sequential model by adding layers and compile it.

model <- keras_model_sequential()
# Add layers to the model
model %>% 
  layer_dense(units = 8, activation = 'relu', input_shape = c(4)) %>% 
  layer_dense(units = 3, activation = 'softmax')

summary(model)

model %>% compile(
  loss = 'categorical_crossentropy',
  optimizer = 'adam',
  metrics = 'accuracy'
)

Step 3: Model training and tunning parameters

Some important concepts for NN training:

• batch size: the number of training samples in one forward/backward pass.

• epoch: one forward and backward pass for all training samples.

• iterations: number of passes, each pass using [batch size] number of training samples.

These nice explanations come from here.

For this example, we set the epoch number to be 200, batch size to be 5. Let’s say there are 100 training sample. In this case, we need to run \(\frac{100}{5}\times 200 = 4000\) iterations.

model %>% fit(
  iris.training, 
  iris.trainLabels, 
  epochs = 200, 
  batch_size = 5, 
  validation_split = 0.2,
  callbacks = callback_tensorboard("logs/run_a")
)

tensorboard("logs/run_a")

Here’s the training history of our model. We could also open tensorboard to view the structure of our model.

Figure 7. Graph structure visualization

Step 4: Model prediction and evaluation

We could use predict_classes function to return the prediction of our test set.

classes <- model %>% predict_classes(iris.test, batch_size = 128)

evaluate function to returns the accuracy and loss of our model.

score <- model %>% evaluate(iris.test, iris.testLabels, batch_size = 128)
print(score)

This returns a confusion matrix.

table(iris.testtarget, classes)

Our tutorial ends here.