Residual Networks (ResNet)

:label:sec_resnet

As we design increasingly deeper networks it becomes imperative to understand how adding layers can increase the complexity and expressiveness of the network. Even more important is the ability to design networks where adding layers makes networks strictly more expressive rather than just different. To make some progress we need a bit of mathematics.

Function Classes

Consider $\mathcal{F}$, the class of functions that a specific network architecture (together with learning rates and other hyperparameter settings) can reach. That is, for all $f \in \mathcal{F}$ there exists some set of parameters (e.g., weights and biases) that can be obtained through training on a suitable dataset. Let us assume that $f^$ is the “truth” function that we really would like to find. If it is in $\mathcal{F}$, we are in good shape but typically we will not be quite so lucky. Instead, we will try to find some $f^_\mathcal{F}$ which is our best bet within $\mathcal{F}$. For instance, given a dataset with features $\mathbf{X}$ and labels $\mathbf{y}$, we might try finding it by solving the following optimization problem:

f^*_\mathcal{F} \stackrel{\mathrm{def}}{=} \mathop{\mathrm{argmin}}_f L(\mathbf{X}, \mathbf{y}, f) \text{ subject to } f \in \mathcal{F}.

It is only reasonable to assume that if we design a different and more powerful architecture $\mathcal{F}’$ we should arrive at a better outcome. In other words, we would expect that $f^_{\mathcal{F}’}$ is “better” than $f^{\mathcal{F}}$. However, if $\mathcal{F} \not\subseteq \mathcal{F}’$ there is no guarantee that this should even happen. In fact, $f^*{\mathcal{F}’}$ might well be worse. As illustrated by :numref:fig_functionclasses, for non-nested function classes, a larger function class does not always move closer to the “truth” function $f^$. For instance, on the left of :numref:fig_functionclasses, though $\mathcal{F}_3$ is closer to $f^$ than $\mathcal{F}_1$, $\mathcal{F}_6$ moves away and there is no guarantee that further increasing the complexity can reduce the distance from $f^*$. With nested function classes where $\mathcal{F}_1 \subseteq \ldots \subseteq \mathcal{F}_6$ on the right of :numref:fig_functionclasses, we can avoid the aforementioned issue from the non-nested function classes.

For non-nested function classes, a larger (indicated by area) function class does not guarantee to get closer to the "truth" function ($f^*$). This does not happen in nested function classes. :label:fig_functionclasses

Thus, only if larger function classes contain the smaller ones are we guaranteed that increasing them strictly increases the expressive power of the network. For deep neural networks, if we can train the newly-added layer into an identity function $f(\mathbf{x}) = \mathbf{x}$, the new model will be as effective as the original model. As the new model may get a better solution to fit the training dataset, the added layer might make it easier to reduce training errors.

This is the question that He et al. considered when working on very deep computer vision models :cite:He.Zhang.Ren.ea.2016. At the heart of their proposed residual network (ResNet) is the idea that every additional layer should more easily contain the identity function as one of its elements. These considerations are rather profound but they led to a surprisingly simple solution, a residual block. With it, ResNet won the ImageNet Large Scale Visual Recognition Challenge in 2015. The design had a profound influence on how to build deep neural networks.

Residual Blocks

Let us focus on a local part of a neural network, as depicted in :numref:fig_residual_block. Denote the input by $\mathbf{x}$. We assume that the desired underlying mapping we want to obtain by learning is $f(\mathbf{x})$, to be used as the input to the activation function on the top. On the left of :numref:fig_residual_block, the portion within the dotted-line box must directly learn the mapping $f(\mathbf{x})$. On the right, the portion within the dotted-line box needs to learn the residual mapping $f(\mathbf{x}) - \mathbf{x}$, which is how the residual block derives its name. If the identity mapping $f(\mathbf{x}) = \mathbf{x}$ is the desired underlying mapping, the residual mapping is easier to learn: we only need to push the weights and biases of the upper weight layer (e.g., fully-connected layer and convolutional layer) within the dotted-line box to zero. The right figure in :numref:fig_residual_block illustrates the residual block of ResNet, where the solid line carrying the layer input $\mathbf{x}$ to the addition operator is called a residual connection (or shortcut connection). With residual blocks, inputs can forward propagate faster through the residual connections across layers.

A regular block (left) and a residual block (right). :label:fig_residual_block

ResNet follows VGG’s full $3\times 3$ convolutional layer design. The residual block has two $3\times 3$ convolutional layers with the same number of output channels. Each convolutional layer is followed by a batch normalization layer and a ReLU activation function. Then, we skip these two convolution operations and add the input directly before the final ReLU activation function. This kind of design requires that the output of the two convolutional layers has to be of the same shape as the input, so that they can be added together. If we want to change the number of channels, we need to introduce an additional $1\times 1$ convolutional layer to transform the input into the desired shape for the addition operation. Let us have a look at the code below.

```{.python .input} from d2l import mxnet as d2l from mxnet import np, npx from mxnet.gluon import nn npx.set_np()

class Residual(nn.Block): #@save “””The Residual block of ResNet.””” def init(self, numchannels, use1x1conv=False, strides=1, **kwargs): super().__init(**kwargs) self.conv1 = nn.Conv2D(num_channels, kernel_size=3, padding=1, strides=strides) self.conv2 = nn.Conv2D(num_channels, kernel_size=3, padding=1) if use_1x1conv: self.conv3 = nn.Conv2D(num_channels, kernel_size=1, strides=strides) else: self.conv3 = None self.bn1 = nn.BatchNorm() self.bn2 = nn.BatchNorm()

  1. def forward(self, X):
  2.     Y = npx.relu(self.bn1(self.conv1(X)))
  3.     Y = self.bn2(self.conv2(Y))
  4.     if self.conv3:
  5.         X = self.conv3(X)
  6.     return npx.relu(Y + X)
  2. ```{.python .input}
  3. #@tab pytorch
  4. from d2l import torch as d2l
  5. import torch
  6. from torch import nn
  7. from torch.nn import functional as F
  9. class Residual(nn.Module):  #@save
  10.     """The Residual block of ResNet."""
  11.     def __init__(self, input_channels, num_channels,
  12.                  use_1x1conv=False, strides=1):
  13.         super().__init__()
  14.         self.conv1 = nn.Conv2d(input_channels, num_channels,
  15.                                kernel_size=3, padding=1, stride=strides)
  16.         self.conv2 = nn.Conv2d(num_channels, num_channels,
  17.                                kernel_size=3, padding=1)
  18.         if use_1x1conv:
  19.             self.conv3 = nn.Conv2d(input_channels, num_channels,
  20.                                    kernel_size=1, stride=strides)
  21.         else:
  22.             self.conv3 = None
  23.         self.bn1 = nn.BatchNorm2d(num_channels)
  24.         self.bn2 = nn.BatchNorm2d(num_channels)
  25.         self.relu = nn.ReLU(inplace=True)
  27.     def forward(self, X):
  28.         Y = F.relu(self.bn1(self.conv1(X)))
  29.         Y = self.bn2(self.conv2(Y))
  30.         if self.conv3:
  31.             X = self.conv3(X)
  32.         Y += X
  33.         return F.relu(Y)

```{.python .input}

@tab tensorflow

from d2l import tensorflow as d2l import tensorflow as tf

class Residual(tf.keras.Model): #@save “””The Residual block of ResNet.””” def init(self, numchannels, use1x1conv=False, strides=1): super().__init() self.conv1 = tf.keras.layers.Conv2D( num_channels, padding=’same’, kernel_size=3, strides=strides) self.conv2 = tf.keras.layers.Conv2D( num_channels, kernel_size=3, padding=’same’) self.conv3 = None if use_1x1conv: self.conv3 = tf.keras.layers.Conv2D( num_channels, kernel_size=1, strides=strides) self.bn1 = tf.keras.layers.BatchNormalization() self.bn2 = tf.keras.layers.BatchNormalization()

  1. def call(self, X):
  2.     Y = tf.keras.activations.relu(self.bn1(self.conv1(X)))
  3.     Y = self.bn2(self.conv2(Y))
  4.     if self.conv3 is not None:
  5.         X = self.conv3(X)
  6.     Y += X
  7.     return tf.keras.activations.relu(Y)
  2. This code generates two types of networks: one where we add the input to the output before applying the ReLU nonlinearity whenever `use_1x1conv=False`, and one where we adjust channels and resolution by means of a $1 \times 1$ convolution before adding. :numref:`fig_resnet_block` illustrates this:
  4. ![ResNet block with and without $1 \times 1$ convolution.](/uploads/projects/d2l-ai-CN/img/resnet-block.svg)
  5. :label:`fig_resnet_block`
  7. Now let us look at a situation where the input and output are of the same shape.
  9. ```{.python .input}
  10. blk = Residual(3)
  11. blk.initialize()
  12. X = np.random.uniform(size=(4, 3, 6, 6))
  13. blk(X).shape

```{.python .input}

@tab pytorch

blk = Residual(3,3) X = torch.rand(4, 3, 6, 6) Y = blk(X) Y.shape

  2. ```{.python .input}
  3. #@tab tensorflow
  4. blk = Residual(3)
  5. X = tf.random.uniform((4, 6, 6, 3))
  6. Y = blk(X)
  7. Y.shape

We also have the option to halve the output height and width while increasing the number of output channels.

```{.python .input} blk = Residual(6, use_1x1conv=True, strides=2) blk.initialize() blk(X).shape

  2. ```{.python .input}
  3. #@tab pytorch
  4. blk = Residual(3,6, use_1x1conv=True, strides=2)
  5. blk(X).shape

```{.python .input}

@tab tensorflow

blk = Residual(6, use_1x1conv=True, strides=2) blk(X).shape

  2. ## ResNet Model
  4. The first two layers of ResNet are the same as those of the GoogLeNet we described before: the $7\times 7$ convolutional layer with 64 output channels and a stride of 2 is followed by the $3\times 3$ maximum pooling layer with a stride of 2. The difference is the batch normalization layer added after each convolutional layer in ResNet.
  6. ```{.python .input}
  7. net = nn.Sequential()
  8. net.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3),
  9.         nn.BatchNorm(), nn.Activation('relu'),
  10.         nn.MaxPool2D(pool_size=3, strides=2, padding=1))

```{.python .input}

@tab pytorch

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

  2. ```{.python .input}
  3. #@tab tensorflow
  4. b1 = tf.keras.models.Sequential([
  5.     tf.keras.layers.Conv2D(64, kernel_size=7, strides=2, padding='same'),
  6.     tf.keras.layers.BatchNormalization(),
  7.     tf.keras.layers.Activation('relu'),
  8.     tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')])

GoogLeNet uses four modules made up of Inception blocks. However, ResNet uses four modules made up of residual blocks, each of which uses several residual blocks with the same number of output channels. The number of channels in the first module is the same as the number of input channels. Since a maximum pooling layer with a stride of 2 has already been used, it is not necessary to reduce the height and width. In the first residual block for each of the subsequent modules, the number of channels is doubled compared with that of the previous module, and the height and width are halved.

Now, we implement this module. Note that special processing has been performed on the first module.

```{.python .input} def resnet_block(num_channels, num_residuals, first_block=False): blk = nn.Sequential() for i in range(num_residuals): if i == 0 and not first_block: blk.add(Residual(num_channels, use_1x1conv=True, strides=2)) else: blk.add(Residual(num_channels)) return blk

  2. ```{.python .input}
  3. #@tab pytorch
  4. def resnet_block(input_channels, num_channels, num_residuals,
  5.                  first_block=False):
  6.     blk = []
  7.     for i in range(num_residuals):
  8.         if i == 0 and not first_block:
  9.             blk.append(Residual(input_channels, num_channels,
  10.                                 use_1x1conv=True, strides=2))
  11.         else:
  12.             blk.append(Residual(num_channels, num_channels))
  13.     return blk

```{.python .input}

@tab tensorflow

class ResnetBlock(tf.keras.layers.Layer): def init(self, numchannels, numresiduals, first_block=False, **kwargs): super(ResnetBlock, self).__init(**kwargs) self.residual_layers = [] for i in range(num_residuals): if i == 0 and not first_block: self.residual_layers.append( Residual(num_channels, use_1x1conv=True, strides=2)) else: self.residual_layers.append(Residual(num_channels))

  1. def call(self, X):
  2.     for layer in self.residual_layers.layers:
  3.         X = layer(X)
  4.     return X
  2. Then, we add all the modules to ResNet. Here, two residual blocks are used for each module.
  4. ```{.python .input}
  5. net.add(resnet_block(64, 2, first_block=True),
  6.         resnet_block(128, 2),
  7.         resnet_block(256, 2),
  8.         resnet_block(512, 2))

```{.python .input}

@tab pytorch

b2 = nn.Sequential(resnet_block(64, 64, 2, first_block=True)) b3 = nn.Sequential(resnet_block(64, 128, 2)) b4 = nn.Sequential(resnet_block(128, 256, 2)) b5 = nn.Sequential(resnet_block(256, 512, 2))

  2. ```{.python .input}
  3. #@tab tensorflow
  4. b2 = ResnetBlock(64, 2, first_block=True)
  5. b3 = ResnetBlock(128, 2)
  6. b4 = ResnetBlock(256, 2)
  7. b5 = ResnetBlock(512, 2)

Finally, just like GoogLeNet, we add a global average pooling layer, followed by the fully-connected layer output.

```{.python .input} net.add(nn.GlobalAvgPool2D(), nn.Dense(10))

  2. ```{.python .input}
  3. #@tab pytorch
  4. net = nn.Sequential(b1, b2, b3, b4, b5,
  5.                     nn.AdaptiveAvgPool2d((1,1)),
  6.                     nn.Flatten(), nn.Linear(512, 10))

```{.python .input}

@tab tensorflow

Recall that we define this as a function so we can reuse later and run it

within tf.distribute.MirroredStrategy‘s scope to utilize various

computational resources, e.g. GPUs. Also note that even though we have

created b1, b2, b3, b4, b5 but we will recreate them inside this function’s

scope instead

def net(): return tf.keras.Sequential([

  1.     # The following layers are the same as b1 that we created earlier
  2.     tf.keras.layers.Conv2D(64, kernel_size=7, strides=2, padding='same'),
  3.     tf.keras.layers.BatchNormalization(),
  4.     tf.keras.layers.Activation('relu'),
  5.     tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same'),
  6.     # The following layers are the same as b2, b3, b4, and b5 that we
  7.     # created earlier
  8.     ResnetBlock(64, 2, first_block=True),
  9.     ResnetBlock(128, 2),
  10.     ResnetBlock(256, 2),
  11.     ResnetBlock(512, 2),
  12.     tf.keras.layers.GlobalAvgPool2D(),
  13.     tf.keras.layers.Dense(units=10)])
  2. There are 4 convolutional layers in each module (excluding the $1\times 1$ convolutional layer). Together with the first $7\times 7$ convolutional layer and the final fully-connected layer, there are 18 layers in total. Therefore, this model is commonly known as ResNet-18.
  3. By configuring different numbers of channels and residual blocks in the module, we can create different ResNet models, such as the deeper 152-layer ResNet-152. Although the main architecture of ResNet is similar to that of GoogLeNet, ResNet's structure is simpler and easier to modify. All these factors have resulted in the rapid and widespread use of ResNet. :numref:`fig_resnet18` depicts the full ResNet-18.
  5. ![The ResNet-18 architecture.](/uploads/projects/d2l-ai-CN/img/resnet18.svg)
  6. :label:`fig_resnet18`
  8. Before training ResNet, let us observe how the input shape changes across different modules in ResNet. As in all the previous architectures, the resolution decreases while the number of channels increases up until the point where a global average pooling layer aggregates all features.
  10. ```{.python .input}
  11. X = np.random.uniform(size=(1, 1, 224, 224))
  12. net.initialize()
  13. for layer in net:
  14.     X = layer(X)
  15.     print(layer.name, 'output shape:\t', X.shape)

```{.python .input}

@tab pytorch

X = torch.rand(size=(1, 1, 224, 224)) for layer in net: X = layer(X) print(layer.class.name,’output shape:\t’, X.shape)

  2. ```{.python .input}
  3. #@tab tensorflow
  4. X = tf.random.uniform(shape=(1, 224, 224, 1))
  5. for layer in net().layers:
  6.     X = layer(X)
  7.     print(layer.__class__.__name__,'output shape:\t', X.shape)

Training

We train ResNet on the Fashion-MNIST dataset, just like before.

```{.python .input}

@tab all

lr, num_epochs, batch_size = 0.05, 10, 256 train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96) d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr) ```

Summary

  • Nested function classes are desirable. Learning an additional layer in deep neural networks as an identity function (though this is an extreme case) should be made easy.
  • The residual mapping can learn the identity function more easily, such as pushing parameters in the weight layer to zero.
  • We can train an effective deep neural network by having residual blocks. Inputs can forward propagate faster through the residual connections across layers.
  • ResNet had a major influence on the design of subsequent deep neural networks, both for convolutional and sequential nature.

Exercises

  1. What are the major differences between the Inception block in :numref:fig_inception and the residual block? After removing some paths in the Inception block, how are they related to each other?
  2. Refer to Table 1 in the ResNet paper :cite:He.Zhang.Ren.ea.2016 to implement different variants.
  3. For deeper networks, ResNet introduces a “bottleneck” architecture to reduce model complexity. Try to implement it.
  4. In subsequent versions of ResNet, the authors changed the “convolution, batch normalization, and activation” structure to the “batch normalization, activation, and convolution” structure. Make this improvement yourself. See Figure 1 in :cite:He.Zhang.Ren.ea.2016*1 for details.
  5. Why can’t we just increase the complexity of functions without bound, even if the function classes are nested?

:begin_tab:mxnet Discussions :end_tab:

:begin_tab:pytorch Discussions :end_tab:

:begin_tab:tensorflow Discussions :end_tab: