Software for data science is advancing and changing rapidly. Although this is wonderful for progress, it can make reproducing someone else's results a challenge. Even your own code may not work when you go back to it a few months later. One way to address this issue is to make a record of what versions of software were used and ensure there is a snapshot of them available. For this book, we will use the R package checkpoint provided by Revolution Analytics; this works in connection with their server, which provides daily snapshots (checkpoints) of the Comprehensive R Archive Network (CRAN). To learn more about this process, you can read the online vignette for the package available at https://cran.r-project.org/web/packages/checkpoint/vignettes/checkpoint.html.

This book was written using R version 3.2.3, nicknamed Wooden Christmas-Tree, on Windows 10 Professional x64. Although this is the latest version of R at the time of writing, as new versions are released CRAN keeps copies of older R versions both as binaries (in the future at https://cran.r-project.org/bin/windows/base/old/) and as source tar balls (https://cran.r-project.org/src/base/R-3/), which can be used to compile the source to any operating system.

For H2O, one of the main R packages will be used for deep learning, we will also need Java installed. This book was written using the Java SE Development Kit 8 update 66 for 64 bit. You can download Java for your operating system at http://www.oracle.com/technetwork/java/javase/.

With those steps done, we are ready to get started. To use the checkpoint package, put all your R scripts for one project together in a single folder. Installing R packages using the checkpoint package is a somewhat circular process. The checkpoint package works by scanning R scripts in the project directory to see what packages are loaded (and therefore that it needs to install), by checking for calls to the library() or require() functions. Of course, we cannot actually use the library() function until we have installed the packages.

To begin with, create an R script in your project directory called checkpoint.R with the following code:

## uncomment to install the checkpoint package
## install.packages("checkpoint")
library(checkpoint)

checkpoint("2016-02-20", R.version = "3.2.3")

Once you have created the R script, you can uncomment and run the code to install the checkpoint package. You only need to do this once, so when you are done it's best to comment the code out again so it is not re-installed each time you run the file. This is the file we will run each time we want to set up our R environment for this deep learning project. The checkpoint for this book is 20th February 2016 and we are using R version 3.2.3. Next, we can add library() calls for some packages we will need to be available by adding the following code to our checkpoint.R script (but note that these are not run yet!):

## Chapter 1 ##

## Tools
library(RCurl)
library(jsonlite)
library(caret)
library(e1071)

## basic stats packages
library(statmod)
library(MASS)

Once we have added that code, save the file so that any changes are written to the disk, and then run the first couple of lines to load the checkpoint package and the call to checkpoint(). The results should look something like Figure 1.5:

Figure 1.5

The checkpoint package asks to create a directory to store specific versions of the packages used, and then finds all packages and installs them. The next sections show how to set up some specific R packages for deep learning.

There are several packages in R that can fit basic neural networks. The nnet package is a recommended package and can fit feed-forward neural networks with one hidden layer, like the one shown in Figure 1.3. For more details on the nnet package, see Venables, W. N. and Ripley, B. D. (2002). The neuralnet package also fits shallow neural networks with one hidden layer, but can train them using back-propagation and allows custom error and neuron activation functions. Finally, we come to the RSNNS package, which is an R wrapper of the Stuttgart Neural Network Simulator (SNNS). The SNNS was originally written in C, but was ported to C++. RSNNS allows many types of models to fit in R. Common models are available using convenient wrappers, but the RSNNS package also makes many model components from SNNS available, making it possible to train a wide variety of models. For more details on the RSNNS package, see Bergmeir, C., and Benítez, J. M. (2012). We will see examples of how to use these models in Chapter 2, Training a Prediction Model. For now, we can install them by adding the following code to the checkpoint.R script and saving it. Saving is important because, if our changes to the R script are not written to the disk, the checkpoint() function will not see the changes and will not find and install the new packages:

## neural networks
library(nnet)
library(neuralnet)
library(RSNNS)

Now, if we re-run the checkpoint() function and it is successful, R should tell us that it discovered eight packages and that it installed nnet, neuralnet, RSNNS, and Rcpp, a dependency for the RSNNS package.

The deepnet package provides a number of tools for deep learning in R. Specifically, it can train RBMs and use these as part of DBNs to generate initial values to train deep neural networks. The deepnet package also allows for different activation functions, and the use of dropout for regularization. To install it, we follow the same process we used before adding the following code to the checkpoint.R script, saving it, and then re-running the checkpoint() function:

## deep learning
library(deepnet)

The darch package is based on Matlab code by George Hinton and stands for deep architectures. It can train RBMs and DBNs along with a variety of options related to each. A limitation of the darch package is that, because it is a pure R implementation, model training tends to be slow. To install it, we follow the same process we used before adding the following code to the checkpoint.R script, saving it, and then re-running the checkpoint() function:

## deep learning
library(darch)

The H2O package provides an interface to the H2O software. H2O is written in Java and is fast and scalable. It provides not only deep learning functionality, but also a variety of other popular machine learning algorithms and models, and the model results can be stored as pure Java code to allow fast scoring, facilitating the deployment of models to solve real-world problems. To install it, we follow the same process we used before adding the following code to the checkpoint.R script, saving it, and then re-running the checkpoint() function:

## deep learning
library(h2o)