Open RStudio Server from your browser by opening http://<your.ip.address>:8787/. Make sure port 8787 is open. Your username is rstudio and your password is rstudio.
Configure RStudio Server to download package binaries from the Posit Package Manager
# For Red Hat 8 use:
https://packagemanager.rstudio.com/cran/__linux__/centos8/latest
# For Ubuntu 20.04 use:
https://packagemanager.rstudio.com/cran/__linux__/focal/latest
Install torch from the pre-built binaries (Warning! This download is 2Gb)
It is written entirely in R and C++ (including a bit of C). No Python installation is required to use it.
There’s a vibrant community of developers
The torch for R ecosystem also includes R packages: torchvision , torchaudio, and luz.
3. Tensors [Exercise]
What’s in a tensor?
To do anything useful with torch, you need to know about tensors. Not tensors in the math/physics sense. In deep learning frameworks such as TensorFlow and (Py-)Torch, tensors are “just” multi-dimensional arrays optimized for fast computation – not on the CPU only but also, on specialized devices such as GPUs and TPUs.
In fact, a torchtensor is like an R array, in that it can be of arbitrary dimensionality. But unlike array, it is designed for fast and scalable execution of mathematical calculations, and you can move it to the GPU. (It also has an extra capability of enormous practical impact – automatic differentiation – but we reserve that for the next chapter.)
Topics:
Creating tensors
Operations on tensors
Accessing parts of a tensor
Reshaping tensors
Broadcasting
4. Autograd
Frameworks like torch are so popular because of what you can do with them: deep learning, machine learning, optimization, large-scale scientific computation in general. Most of these application areas involve minimizing some loss function. This, in turn, entails computing function derivatives.
torch implements what is called automatic differentiation. In automatic differentiation, and more specifically, its often-used reverse-mode variant, derivatives are computed and combined on a backward pass through the graph of tensor operations.
In torch, the AD engine is usually referred to as autograd.
Automatic differentiation example
Quadratic function of two variables: \(f(x_1, x_2) = 0.2 {x_1}^2 + 0.2 {x_2}^2 - 5\). It has its minimum at (0,0).
At x7, we calculate partial derivatives with respect to x5 and x6. Basically, the equation to differentiate looks like this: \(f(x_5, x_6) = x_5 + x_6 - 5\). Thus, both partial derivatives are 1.
From x5, we move to the left to see how it depends on x3. We find that \(\frac{\partial x_5}{\partial x_3} = 0.2\). At this point, applying the chain rule of calculus, we already know how the output depends on x3: \(\frac{\partial f}{\partial x_3} = 0.2 * 1 = 0.2\).
From x3, we take the final step to x. We learn that \(\frac{\partial x_3}{\partial x_1} = 2 x_1\). Now, we again apply the chain rule, and are able to formulate how the function depends on its first input: \(\frac{\partial f}{\partial x_1} = 2 x_1 * 0.2 * 1 = 0.4 x_1\).
Analogously, we determine the second partial derivative, and thus, already have the gradient available: \(\nabla f = \frac{\partial f}{\partial x_1} + \frac{\partial f}{\partial x_2} = 0.4 x_1 + 0.4 x_2\).
These are the partial derivatives of x7 with respect to x1 and x2, respectively. Conforming to our manual calculations above, both amount to 0.8, that is, 0.4 times the tensor values 2 and 2.
5. Function minimization with autograd
In optimization research, the Rosenbrock function is a classic. It is a function of two variables; its minimum is at (1,1). If you take a look at its contours, you see that the minimum lies inside a stretched-out, narrow valley.
a <-1b <-5rosenbrock <-function(x) { x1 <- x[1] x2 <- x[2] (a - x1)^2+ b * (x2 - x1^2)^2}
lr, for learning rate, is the fraction of the gradient to subtract on every step
num_iterations is the number of steps to take.
library(torch)num_iterations <-1000lr <-0.01x <-torch_tensor(c(-1, 1), requires_grad =TRUE)for (i in1:num_iterations) {if (i %%100==0) cat("Iteration: ", i, "\n") value <-rosenbrock(x)if (i %%100==0) {cat("Value is: ", as.numeric(value), "\n") } value$backward()if (i %%100==0) {cat("Gradient is: ", as.matrix(x$grad), "\n") }with_no_grad({ x$sub_(lr * x$grad) x$grad$zero_() })}
Iteration: 400
Value is: 0.009619333
Gradient is: -0.04347242 -0.08254051
Iteration: 500
Value is: 0.003990697
Gradient is: -0.02652063 -0.05206227
Iteration: 600
Value is: 0.001719962
Gradient is: -0.01683905 -0.03373682
Iteration: 700
Value is: 0.0007584976
Gradient is: -0.01095017 -0.02221584
Iteration: 800
Value is: 0.0003393509
Gradient is: -0.007221781 -0.01477957
Iteration: 900
Value is: 0.0001532408
Gradient is: -0.004811743 -0.009894371
Iteration: 1000
Value is: 6.962555e-05
Gradient is: -0.003222887 -0.006653666
After thousand iterations, we have reached a function value lower than 0.0001. What is the corresponding (x1,x2)-position?
x
torch_tensor
0.9918
0.9830
[ CPUFloatType{2} ]
This is rather close to the true minimum of (1,1).
6. A neural network from scratch [Exercise]
Understanding the basics will be an efficient antidote against the surprisingly common temptation to think of deep learning as some kind of “magic”. It’s all just matrix computations; one has to learn how to orchestrate them though.
One of the defining features of neural networks is their ability to chain an unlimited (in theory) number of layers.
All but the output layer may be referred to as “hidden” layers, although from the point of view of someone who uses a deep learning framework such as torch, they are not that hidden after all.
The most-used activation function inside a network is the so-called ReLU, or Rectified Linear Unit. This is a long name for something rather straightforward: All negative values are set to zero. In torch, this can be accomplished using the relu() function:
t <-torch_tensor(c(-2, 1, 5, -7))t$relu()
torch_tensor
0
1
5
0
[ CPUFloatType{4} ]
Loss functions
Loss is a measure of how far away we are from our goal. For regression-type tasks, this often will be mean squared error (MSE).
y <-torch_randn(5)y_pred <- y +0.01loss <- (y_pred - y)$pow(2)$mean()loss
torch_tensor
9.99999e-05
[ CPUFloatType{} ]
Example
do a forward pass, yielding the network’s predictions (if you dislike the one-liner, feel free to split it up);
compute the loss (this, too, being a one-liner – we merely added some logging);
have autograd calculate the gradient of the loss with respect to the parameters; and
update the parameters accordingly (again, taking care to wrap the whole action in with_no_grad(), and zeroing the grad fields on every iteration).
Generate random data
library(torch)## input dimensionality (number of input features)d_in <-3## number of observations in training setn <-100x <-torch_randn(n, d_in)coefs <-c(0.2, -1.3, -0.5)y <- x$matmul(coefs)$unsqueeze(2) +torch_randn(n, 1)
In torch, a module can be of any complexity, ranging from basic layers to complete models consisting of many such layers. Code-wise, there is no difference between “layers” and “models”.
nn_module()
In torch, a linear layer is created using nn_linear() which expects (at least) two arguments: in_features and out_features.
x <-torch_randn(50, 5)output <-l(x)output$size() # forward pass
[1] 50 16
nn_sequential()
If all our model should do is propagate straight through the layers, we can use nn_sequential() to build it. Models consisting of all linear layers are known as Multi-Layer Perceptrons (MLPs).
nn_conv1d(), nn_conv2d(), and nn_conv3d(), the so-called convolutional layers that apply filters to input data of varying dimensionality,
nn_lstm() and nn_gru() , the recurrent layers that carry through a state,
nn_embedding() that is used to embed categorical data in high-dimensional space,
and more.
8. Optimizers
1. Optimizers help in updating weights
Without optimizers
library(torch)# compute gradient of loss w.r.t. all tensors with# requires_grad = TRUEloss$backward()### -------- Update weights -------- # Wrap in with_no_grad() because this is a part we don't # want to record for automatic gradient computationwith_no_grad({ w1 <- w1$sub_(learning_rate * w1$grad) w2 <- w2$sub_(learning_rate * w2$grad) b1 <- b1$sub_(learning_rate * b1$grad) b2 <- b2$sub_(learning_rate * b2$grad) # Zero gradients after every pass, as they'd accumulate# otherwise w1$grad$zero_() w2$grad$zero_() b1$grad$zero_() b2$grad$zero_() })
With optimizers
# compute gradient of loss w.r.t. all tensors with# requires_grad = TRUE# no change hereloss$backward()# Still need to zero out gradients before the backward pass,# only this time, on the optimizer objectoptimizer$zero_grad()# use the optimizer to update model parametersoptimizer$step()
So far, we’ve only talked about the kinds of optimizers often used in deep learning – stochastic gradient descent (SGD), SGD with momentum, and a few classics from the adaptivelearning rate family: RMSProp, Adadelta, Adagrad, Adam. All these have in common one thing: They only make use of the gradient, that is, the vector of first derivatives. Accordingly, they are all first-order algorithms. This means, however, that they are missing out on helpful information provided by the Hessian, the matrix of second derivatives.
Approximate Newton: BFGS and L-BFGS
Among approximate Newton methods, probably the most-used is the Broyden-Goldfarb-Fletcher-Shanno algorithm, or BFGS. Instead of continually computing the exact inverse of the Hessian, it keeps an iteratively-updated approximation of that inverse. BFGS is often implemented in a more memory-friendly version, referred to as Limited-Memory BFGS (L-BFGS). This is the one provided as part of the core torch optimizers.
Line search
With line search, we spend some time evaluating how far to follow the descent direction. There are two principal ways of doing this.
Exact. Take the current point, compute the descent direction, and hard-code them as givens in a second function that depends on the learning rate only. Then, differentiate this function to find its minimum. The solution will be the learning rate that optimizes the step length taken.
Approximate search. Essentially, we look for something that is justgood enough. Among the most established heuristics are the Strong Wolfe conditions, and this is the strategy implemented in torch’s optim_lbfgs().
11. Modularizing the neural network [Exercise]
The forward pass, instead of calling functions on tensors, will call the model.
In computing the loss, we now make use of torch’s nnf_mse_loss().
Backpropagation of gradients is, in fact, the only operation that remains unchanged.
Weight updating is taken care of by the optimizer.
The upcoming two chapters will introduce you to workflow-related techniques that are indispensable in practice. You’ll encounter another package, luz, that endows torch with an important layer of abstraction, and significantly streamlines the workflow. Once you know how to use it, we’re all set to look at a first application: image classification.
Regarding workflow, we’ll see how to:
prepare the input data in a form the model can work with;
effectively and efficiently train a model, monitoring progress and adjusting hyper-parameters on the fly;
save and load models;
making models generalize beyond the training data;
How luz helps with devices. For the call to predict(), what happened “under the hood” was the following:
luz put the model in evaluation mode, making sure that weights are not updated.
luz moved the test data to the GPU, batch by batch, and obtained model predictions.
These predictions were then moved back to the CPU, in anticipation of the caller wanting to process them further with R.
15. A first go at image classification [Exercise]
This chapter is about “convolutional” neural networks; the specialized module in question is the “convolutional” one. In this chapter, we design and train a basic convnet from scratch. This is “just” a beginning.
Glossary of terms
Convolution / Cross-correlation: Which finds things, or spots similarities.
Filter / kernel: Maps non-linear data into a higher-dimensional space without the need to visit or understand that higher-dimensional space.
Padding: Allows the kernel to extend outside the valid region.
Stride: The way a kernel moves over the image.
Dilation: Spreads out the pixels in a convolution.
Translation invariant: If a shift has occurred, the target is still detected, but at a new location.
Pooling: Down sample feature maps by summarizing the presence of features in patches of the feature map.
New Package
In addition to torch and luz, we load a third package from the torch ecosystem: torchvision. torchvision provides operations on images, as well as a set of pre-trained models and common benchmark datasets.
Dataset
library(torch)library(torchvision)library(luz)set.seed(777)torch_manual_seed(777)train_ds <-tiny_imagenet_dataset(root=".",download =FALSE,transform =function(x) { x %>%transform_to_tensor() })valid_ds <-tiny_imagenet_dataset(root=".",split ="val",transform =function(x) { x %>%transform_to_tensor() })
preds <- fitted %>%predict(valid_dl)preds <-nnf_softmax(preds, dim =2)torch_argmax(preds, dim =2)
16. Making models generalize
Original image
Rotations, flips, translations
Mixup
Dropout
At each forward pass, individual activations – single values in the tensors being passed on – are dropped (meaning: set to zero), with configurable probability. Put differently: Dynamically and reversibly, individual inter-neuron connections are “cut off”.
Regularization
The idea is to keep the weights small and homogeneous, to prevent sharp cliffs and canyons in the loss function. It is often referred to as “weight decay”. Regularization is not seen that often in the context of neural networks.
Early stopping
In deep learning, early stopping is ubiquitous; it’s hard to imagine why one would not want to use it.
17. Speeding up training
Batch normalization. Batchnorm – to introduce a popular abbreviation – layers are added to a model to stabilize and, in consequence, speed up training.
Determining a good learning rate upfront, and dynamically varying it during training. As you might remember from our experiments with optimization, the learning rate has an enormous impact on training speed and stability.
Transfer learning. Applied to neural networks, the term commonly refers to using pre-trained models for feature detection, and making use of those features in a downstream task.
18. Image classification: Improving performance
Always use
Data augmentation. There is hardly ever a case where you’d not want to use it – unless, of course, you are already using a different data augmentation technique.
Learning rate finder with a learning rate schedule.
Early stopping. This will not just prevent overfitting, but also, save time.
Examples (slow)
First training: Take the convnet from three chapters ago, and add dropout layers.
Second training: Replace dropout by batch normalization. (Everything else stays the same.)
Third training: Replace the model completely, by one chaining a pre-trained feature classifier (ResNet) and a small sequential model.
