Deep Pyramidal Residual Networks

10/10/2016 ∙ by Dongyoon Han, et al. ∙ KAIST 수리과학과 0

Deep convolutional neural networks (DCNNs) have shown remarkable performance in image classification tasks in recent years. Generally, deep neural network architectures are stacks consisting of a large number of convolutional layers, and they perform downsampling along the spatial dimension via pooling to reduce memory usage. Concurrently, the feature map dimension (i.e., the number of channels) is sharply increased at downsampling locations, which is essential to ensure effective performance because it increases the diversity of high-level attributes. This also applies to residual networks and is very closely related to their performance. In this research, instead of sharply increasing the feature map dimension at units that perform downsampling, we gradually increase the feature map dimension at all units to involve as many locations as possible. This design, which is discussed in depth together with our new insights, has proven to be an effective means of improving generalization ability. Furthermore, we propose a novel residual unit capable of further improving the classification accuracy with our new network architecture. Experiments on benchmark CIFAR-10, CIFAR-100, and ImageNet datasets have shown that our network architecture has superior generalization ability compared to the original residual networks. Code is available at https://github.com/jhkim89/PyramidNet

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

Code Repositories

PyramidNet

Torch implementation of the paper "Deep Pyramidal Residual Networks" (https://arxiv.org/abs/1610.02915).


view repo

PyramidNet-PyTorch

A PyTorch implementation for PyramidNets (Deep Pyramidal Residual Networks, https://arxiv.org/abs/1610.02915)


view repo

PyramidNet-caffe

Caffe implementation of the paper "Deep Pyramidal Residual Networks" (https://arxiv.org/abs/1610.02915).


view repo

pyramidal_residual_networks

Implementation of Pyramidal Residual Networks by chainer (Deep Pyramidal Residual Networks: https://arxiv.org/abs/1610.02915)


view repo

pytorch_pyramidnet

A PyTorch implementation of PyramidNet.


view repo
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The emergence of deep convolutional neural networks (DCNNs) has greatly contributed to advancements in solving complex tasks [13, 23, 2, 3, 19]

in computer vision with significantly improved performance. Since the proposal of LeNet 

[16], which introduced the use of deep neural network architectures for computer vision tasks, the advanced architecture AlexNet [13] was selected as the winner of the 2012 ImageNet competition [22] by a large margin over traditional methods. Subsequently, ZF-net [35], VGG [25], GoogleNet [31], Residual Networks [7, 8], and Inception Residual Networks [30] were successively proposed to demonstrate advances in network architectures. In particular, Residual Networks (ResNets) [7, 8] leverage the concept of shortcut connections [29] inside a proposed residual unit for residual learning, to make it possible to train much deeper network architectures. Deeper network architectures are known for their superior performance, and these network architectures commonly have deeply stacked convolutional filters with nonlinearity [25, 31].

With respect to feature map dimension, the conventional method of stacking several convolutional filters is to increase the dimension while decreasing the size of feature maps by increasing the strides of the filters or poolings. This is the widely adopted method of controlling the size of feature maps, because extracting the diversified high-level attributes with the increased feature map dimension is very effective for classification tasks. Architectures such as those of AlexNet 

[13] and VGG [25] utilize this method of increasing the feature map dimension to construct their network architectures. The most successful deep neural network, ResNets [7, 8], which was introduced by He et al. [7], also follows this approach for filter stacking.

Figure 1: Schematic illustration of (a) basic residual units [7], (b) bottleneck residual units [7], (c) wide residual units [34], (d) our pyramidal residual units, and (e) our pyramidal bottleneck residual units.

According to the research of Veit et al. [33], ResNets are considered to behave as ensembles of relatively shallow networks. These researchers showed that the deletion of an individual residual unit from ResNets, i.e., such that only a shortcut connection remains, does not significantly affect the overall performance, proving that deleting a residual unit is equivalent to deleting some shallow networks in the ensemble networks. Contrary to this, deleting a single layer in plain network architectures such as a VGG-network [25] damages the network by causing additional severe errors.

However, in the case of ResNets, it was found that deleting the building blocks in a residual unit with downsampling, where the feature map dimension is doubled, still increases the classification error by a significant margin. Interestingly, when the residual net is trained using a stochastic depth [10], it was found that deleting the blocks with downsampling does not degrade the classification performance, as shown in Figure 8 in [33]. One may think that this phenomenon is related to the overall improvement in the classification performance enabled by stochastic depth.

Motivated by the ensemble interpretation of residual networks in Veit et al. [33] and the results with stochastic depth [10], we devised another method to handle the phenomenon associated with deleting the downsampling unit. In the proposed method, the feature map dimensions are increased at all layers to distribute the burden concentrated at locations of residual units affected by downsampling, such that it is equally distributed across all units. It was found that using the proposed new network architecture, deleting the units with downsampling does not degrade the performance significantly. In our paper, we refer to this network architecture as a deep “pyramidal” network and a “pyramidal” residual network with a residual-type network architecture. This reflects the fact that the shape of the network architecture can be compared to that of a pyramid. That is, the number of channels gradually increases as a function of the depth at which the layer occurs, which is similar to a pyramid structure of which the shape gradually widens from the top downwards. This structure is illustrated in comparison to other network architectures in Figure 1. The key contributions are summarized as follows:

  • A deep pyramidal residual network (PyramidNet) is introduced. The key idea is to concentrate on the feature map dimension by increasing it gradually instead of by increasing it sharply at each residual unit with downsampling. In addition, our network architecture works as a mixture of both plain and residual networks by using zero-padded identity-mapping shortcut connections when increasing the feature map dimension.

  • A novel residual unit is also proposed, which can further improve the performance of ResNet-based architectures (compared with state-of-the-art network architectures).

The remainder of this paper is organized as follows. Section 2 presents our PyramidNets and introduces a novel residual unit that can further improve ResNet. Section 3 closely analyzes our PyramidNets via several discussions. Section 4 presents experimental results and comparisons with several state-of-the-art deep network architectures. Section 5 concludes our paper with suggestions for future works.

2 Network Architecture

In this section, we introduce the network architectures of our PyramidNets. The major difference between PyramidNets and other network architectures is that the dimension of channels gradually increases, instead of maintaining the dimension until a residual unit with downsampling appears. A schematic illustration is shown in Figure 1 (d) to facilitate understanding of our network architecture.

2.1 Feature Map Dimension Configuration

Most deep CNN architectures [7, 8, 13, 25, 31, 35] utilize an approach whereby feature map dimensions are increased by a large margin when the size of the feature map decreases, and feature map dimensions are not increased until they encounter a layer with downsampling. In the case of the original ResNet for CIFAR datasets [12], the number of feature map dimensions of the -th residual unit that belongs to the -th group can be described as follows:

(1)

in which denotes the index of the group to which the k-th residual unit belongs. The residual units that belong to the same group have an equal feature map size, and the -th group contains residual units. In the first group, there is only one convolutional layer that converts an RGB image into multiple feature maps. For the -th group, after residual units have passed, the feature size is downsampled by half and the number of dimensions is doubled.

(a) (b) (c)
Figure 2: Visual illustrations of (a) additive PyramidNet, (b) multiplicative PyramidNet, and (c) a comparison of (a) and (b).

We propose a method of increasing the feature map dimension as follows:

(2)

in which denotes the total number of residual units, defined as . The dimension is increased by a step factor of , and the output dimension of the final unit of each group becomes with same number of residual units in each group. The details of our network architecture are presented in Table 1.

The above equations are based on an addition-based widening step factor for increasing dimensions. However, of course, multiplication-based widening (i.e., the process of multiplying by a factor to increase the channel dimension geometrically) presents another possibility for creating a pyramid-like structure. Then, eq.(2) can be transformed as follows:

(3)

The main difference between additive and multiplicative PyramidNets is that the feature map dimension of an additive network gradually increases linearly, whereas the dimension of a multiplicative network increases geometrically. That is, the dimension slowly increases in input-side layers and sharply increases in output-side layers. This process is similar to that of the original deep network architectures such as VGG [25] and ResNet [7]. The visual illustrations of additive and multiplicative PyramidNets are shown in Figure 2. In this paper, we compare the performance of both of these dimension-increasing approaches by comparing an additive PyramidNet (eq. (2)) and a multiplicative PyramidNet (eq. (3)) in section 4.

Group Output size Building Block
conv 1 3232
conv 2 3232
conv 3 1616
conv 4 88
avg pool 11
Table 1: Structure of our PyramidNet for benchmarking with CIFAR-10 and CIFAR-100 datasets. denotes the widening factor, and signifies the number of blocks in a group. Downsampling is performed at conv3_1 and conv4_1 with a stride of 2.

2.2 Building Block

The building block (i.e., the convolutional filter stacks with ReLUs and BN layers) in a residual unit is the core of ResNet-based architectures. It is obvious that in order to maximize the capability of the network architecture, designing a good building block is essential. As shown in Figure 6, the layers can be stacked in various manners to construct a single building block. We found the building block shown in Figure 6 (d) to be the most promising, and therefore we included this structure as building block in our PyramidNets. The discussion of this matter is continued in the following section.

In terms of shortcut connections, many researchers either use those based on identity mapping, or those employing convolution-based projection. However, as the feature map dimension of PyramidNet is increased at every unit, we can only consider two options: zero-padded identity-mapping shortcuts, and projection shortcuts conducted by 11 convolutions. However, as mentioned in the work of He et al. [8], the 11 convolutional shortcut produces a poor result when there are too many residual units, i.e., this shortcut is unsuitable for very deep network architectures. Therefore, we select zero-padded identity-mapping shortcuts for all residual units. Further discussions about the zero-padded shortcut are provided in the following section.

3 Discussions

In this section, we present an in-depth study of the architecture of our PyramidNet, together with the proposed novel residual units. The experiments we include here support the study and confirm that insights obtained from our network architecture can further improve the performance of existing ResNet-based architectures.

3.1 Effect of PyramidNet

According to the work of Veit et al. [33], ResNets can be viewed as ensembles of relatively shallow networks, supported by the observation that deleting an individual building block in a residual unit of ResNets incurs minor classification loss, whereas removing layers from plain networks such as VGG [25] severely reduces the classification rate. However, in both original and pre-activation ResNets [7, 8], another noteworthy aspect is that deleting the units with downsampling (and doubling the feature dimension) still degrades performance by a large margin [33]. Meanwhile, when a stochastic depth [10] is applied, this phenomenon is not observed, and the performance is also improved, according to the experiment of Veit et al. [33]. The objective of our PyramidNet is to resolve this phenomenon differently, by attempting to gradually increase the feature map dimension instead of doubling it at one of the residual units and to evenly distribute the burden of increasing the feature maps. We observed that our PyramidNet indeed resolves this phenomenon and at the same time improves overall performance. We further analyze the effect of our PyramidNet by comparing it against the pre-activation ResNet, with the following experimental results.

Figure 3: Performance comparison between the pre-activation ResNet [8] and our PyramidNet, using CIFAR datasets. Dashed and solid lines denote the training loss and test error, respectively.

First, we compare the training and test error curves of our PyramidNet with those of the pre-activation ResNet [8] in Figure 3. The standard pre-activation ResNet with 110 layers is used for comparison. For our PyramidNet, we used a depth of 110 layers with a widening factor of ; it had the same number of parameters (1.7M) as the pre-activation ResNet to allow for a fair comparison. The results indicate that our PyramidNet has superior test accuracy, thereby confirming its greater ability to generalize compared to existing deep networks.

Second, we verify the ensemble effect of our PyramidNets by evaluating the performance after deleting individual units, similar to the experiment of Veit et al. [33]. The results are shown in Figure 4. As mentioned by Veit et al. [33], removing individual units only causes a slight performance loss, compared with a plain network such as the VGG [25]. However, in the case of the pre-activation ResNet, removing the blocks subjected to downsampling tends to affect the classification accuracy by a relatively large margin, whereas this does not occur with our PyramidNets. Furthermore, the mean average error differences between the baseline result and the result obtained when individual units were deleted from both the pre-activation ResNet and our PyramidNet were 0.72% and 0.54%, respectively. This result shows that the ensemble effect of our PyramidNet becomes stronger than the original ResNet, such that generalization ability is improved.

 
Figure 4: Test error curves to study the extent to which residual units contribute to the performance in different network architectures by deleting their individual units. The dashed and solid lines denote the test errors that occur when no units are deleted, and when an individual unit is deleted, respectively. Bold vertical lines denote the location of residual units through downsampling.

3.2 Zero-padded Shortcut Connection

ResNets and pre-activation ResNets [7, 8] were studied several types of shortcuts, such as an identity-mapping shortcut or projection shortcut. The experimental results in [8] showed that the identity-mapping shortcut is a much more appropriate choice than other shortcuts. Because an identity-mapping shortcut does not have parameters, it has a lower possibility of overfitting compared to the other types of shortcuts; this ensures improved generalization ability. Moreover, it can purely pass through the gradient according to the identity mapping, and therefore it provides more stability in the training stage.

In the case of our PyramidNet, identity mapping alone cannot be used for a shortcut because the feature map dimension differs among individual residual units. Therefore, only a zero-padded shortcut or projection shortcut can be used for all the residual units. However, as discussed in [8], a projection shortcut can hamper information propagation and lead to optimization problems, especially for very deep networks. On the other hand, we found that the zero-padded shortcut does not lead to the overfitting problem because no additional parameters exist, and surprisingly, it shows significant generalization ability compared to other shortcuts.

We now examine the effect of the zero-padded identity-mapping shortcut on the -th residual unit that belongs to the

-th group with the reshaped vector

of the -th feature map:

(4)

where denotes the -th residual function of the -th residual unit and represents the pre-defined channel dimensions of the -th residual unit. From eq.(4), zero-padded elements of the identity-mapping shortcut for increasing dimension let contain the outputs of both residual networks and plain networks. Therefore, we could conjecture that each zero-padded identity-mapping shortcut can provide a mixture of the residual network and plain network, as shown in Figure 5. Furthermore, our PyramidNet increases the channel dimension at every residual unit, and the mixture effect of the residual network and plain network increases markedly. Figure 4 supports the conclusion that the test error of PyramidNet does not oscillate as much as that of the pre-activation ResNet. Finally, we investigate several types of shortcuts including proposed zero-padded identity-mapping shortcut in Table 2.

(a)  (b)
Figure 5: Structure of residual unit (a) with zero-padded identity-mapping shortcut, (b) unraveled view of (a) showing that the zero-padded identity-mapping shortcut constitutes a mixture of a residual network with a shortcut connection and a plain network.

3.3 A New Building Block

To maximize the capability of the network, it is natural to ask the following question: “Can we design a better building block by altering the stacked elements inside the building block in more principled way?”. The first building block types were proposed in the original paper on ResNets [7], and another type of building block was subsequently proposed in the paper on pre-activation ResNets [8], to answer the question. Moreover, pre-activation ResNets attempted to solve the backward gradient flowing problem [8]

by redesigning residual modules; this proved to be successful in trials. However, although the pre-activation residual unit was discovered with empirically improved performance, further investigation over the possible combinations is not yet performed, leaving a potential room for improvement. We next attempt to answer the question from two points of view by considering Rectified Linear Units (ReLUs) 

[20]

and Batch Normalization (BN) 

[11] layers.

Shortcut Types CIFAR-10 CIFAR-100
(a) Identity mapping with projection shortcut 5.03 23.48
(b) Projection with zero-padded shortcut 6.84 31.29
(c) Only projection shortcut 6.98 31.62
(d) Identity mapping with zero-padded shortcut 4.70 22.77
Table 2: Top-1 errors (%) on CIFAR datasets using our PyramidNet with several combinations of shortcut connections.
 (a)   (b)   (c)   (d)
Figure 6: Various types of basic and bottleneck residual units. “BatchNorm” denotes a Batch Normalization (BN) layer. (a) original pre-activation ResNets [8]

, (b) pre-activation ResNets removing the first ReLU, (c) pre-activation ResNets with a BN layer after the final convolutional layer, and (d) pre-activation ResNets removing the fist ReLU with a BN layer after the final convolutional layer.

3.3.1 ReLUs in a Building Block

Including ReLUs [20] in the building blocks of residual units is essential for nonlinearity; however, we found empirically that the performance can vary depending on the locations and the number of ReLUs. This could be discussed with original ResNets [7], for which it was shown that the performance increases as the network becomes deeper; however, if the depth exceeds 1,000 layers, overfitting still occurs and the result is less accurate than that generated by shallower ResNets.

First, we note that using ReLUs after the addition of residual units adversely affects performance:

(5)

where the ReLUs seem to have the function of filtering non-negative elements. Gross and Wilber [5] found that simply removing ReLUs from the original ResNet [7] after each addition with the shortcut connection leads to small performance improvements. This could be understood by considering that, after addition, ReLUs provide non-negative input to the subsequent residual units, and therefore the shortcut connection is always non-negative and the convolutional layers would take responsibility for producing negative output before addition; this may decrease the overall capability of the network architecture as analyzed in [8]. The pre-activation ResNets proposed by He et al. [8] also overcame this issue with pre-activated residual units that place BN layers and ReLUs before (instead of after) the convolutional layers:

(6)

where ReLUs are removed after addition to create an identity path. Consequently, the overall performance has increased by a large margin without overfitting, even at depths exceeding 1,000 layers. Furthermore, Shen et al. [24] proposed a weighted residual network architecture, which locates a ReLU inside a residual unit (instead of locating ReLU after addition) to create an identity path, and showed that this structure also does not overfit even at depths of more than 1,000 layers.

Second, we found that the use of a large number of ReLUs in the blocks of each residual unit may negatively affect performance. Removing the first ReLU in the blocks of each residual unit, as shown in Figure 6 (b) and (d), was found to enhance performance compared with the blocks shown in Figure 6 (a) and (c). Experimentally, we found that removal of the first ReLU in the stack is preferable and that the other ReLU should remain to ensure nonlinearity. Removing the second ReLU in Figure 6 (a) changes the blocks to BN-ReLU-conv-BN-conv, and it is clear that, in these blocks, the convolutional layers are successively located without ReLUs to weaken their representation powers of each other. However, when we remove the first ReLU, the blocks are changed to BN-conv-BN-ReLU-conv, in which case the two convolutional layers are separated by the second ReLU, thereby guaranteeing nonlinearity. The results in Table 3 confirm that removing the first ReLU as in (b) and (d) in Figure 6, enhances the performance. Consequently, provided that an appropriate number of ReLUs are used to guarantee the nonlinearity of the feature space manifold, the remaining ReLUs could be removed to improve network performance.

3.3.2 BN Layers in a Building Block

The main role of a BN layer is to normalize the activations for fast convergence and to improve performance. The experimental results of the four structures provided in Table 3 show that the BN layer can be used to maximize the capability of a single residual unit. A BN layer conducts an affine transformation with the following equation:

ResNet Architecture CIFAR-10 CIFAR-100
(a) Pre-activation [8] 5.82 25.06
(b) Removing the first ReLU 5.31 24.55
(c) BN after the final conv 5.74 24.54
(d) (b) + (c) 5.29 23.74
PyramidNet Architecture CIFAR-10 CIFAR-100
(a) Pre-activation [8] 5.15 24.40
(b) Removing the first ReLU 4.81 23.43
(c) BN after the final conv 4.96 23.89
(d) (b) + (c) 4.62 23.31
PyramidNet (bottleneck) Architecture CIFAR-10 CIFAR-100
(a) Pre-activation [8] 4.61 21.10
(b) Removing the first ReLU 4.45 20.40
(c) BN after the final conv 4.56 20.44
(d) (b) + (c) 4.26 20.32
Table 3: Top-1 errors (%) on CIFAR datasets for several building block combinations of ReLUs and BN layers shown in Figure 6 (a)–(d), using ResNet [8] (with original feature map dimension configuration) and our PyramidNet.
Network # of Params Output Feat. Dim. Depth Training Mem. CIFAR-10 CIFAR-100
NiN [18] - - - - 8.81 35.68
All-CNN [27] - - - - 7.25 33.71
DSN [17] - - - - 7.97 34.57
FitNet [21] - - - - 8.39 35.04
Highway [29] - - - - 7.72 32.39

Fractional Max-pooling 

[4]
- - - - 4.50 27.62
ELU [29] - - - - 6.55 24.28
ResNet [7] 1.7M 64 110 547MB 6.43 25.16
ResNet [7] 10.2M 64 1001 2,921MB - 27.82
ResNet [7] 19.4M 64 1202 2,069MB 7.93 -
Pre-activation ResNet [8] 1.7M 64 164 841MB 5.46 24.33
Pre-activation ResNet [8] 10.2M 64 1001 2,921MB 4.62 22.71
Stochastic Depth [10] 1.7M 64 110 547MB 5.23 24.58
Stochastic Depth [10] 10.2M 64 1202 2,069MB 4.91 -
FractalNet [14] 38.6M 1,024 21 - 4.60 23.73
SwapOut v2 (width[26] 7.4M 256 32 - 4.76 22.72
Wide ResNet (width[34] 8.7M 256 40 775MB 4.97 22.89
Wide ResNet (width[34] 36.5M 640 28 1,383MB 4.17 20.50
Weighted ResNet [24] 19.1M 64 1192 - 5.10 -
DenseNet ([9] 27.2M 2,352 100 4,381MB 3.74 19.25
DenseNet-BC ([9] 25.6M 2,190 190 7,247MB 3.46 17.18
PyramidNet () 1.7M 64 110 655MB 4.580.06 23.120.04
PyramidNet () 3.8M 100 110 781MB 4.260.23 20.660.40
PyramidNet () 28.3M 286 110 1,437MB 3.730.04 18.250.10
PyramidNet (bottleneck, ) 27.0M 1,144 164 4,169MB 3.480.20 17.010.39
PyramidNet (bottleneck, ) 26.6M 1,024 200 4,451MB 3.440.11 16.510.13
PyramidNet (bottleneck, ) 26.8M 944 236 4,767MB 3.400.07 16.370.29
PyramidNet (bottleneck, ) 26.0M 864 272 5,005MB 3.310.08 16.350.24
Table 4: Top-1 error rates (%) on CIFAR datasets. All the results of PyramidNets are produced with additive PyramidNets, and

denotes the widening factor. “Output Feat. Dim.” denotes the feature dimension of just before the last softmax classifier. The best results are highlighted in

red.
(7)

where and are learned for every activation in feature maps. We experimentally found that the learned and could closely approximate . This implies that if the learned and are both close to , then the corresponding activation is considered not to be useful. Weighted ResNets [24], in which the learnable weights occur at the end of their building blocks, are also similarly learned to determine whether the corresponding residual unit is useful. Thus, the BN layers at the end of each residual unit are a generalized version including [24]

to enable decisions to be made as to whether each residual unit is helpful. Therefore, the degrees of freedom obtained by involving

and from the BN layers could improve the capability of the network architecture. The results in Table 3 support the conclusion that adding a BN layer at the end of each building block, as in type (c) and (d) in Figure 6, improves the performance. Note that the aforementioned network removing the first ReLU is also improved by adding a BN layer after the final convolutional layer. Furthermore, the results in Table 3 show that both PyramidNet and a new building block improve the performance significantly.

4 Experimental Results

We evaluate and compare the performance of our algorithm with that of existing algorithms [7, 8, 18, 24, 34] using representative benchmark datasets: CIFAR-10 and CIFAR-100 [12]. CIFAR-10 and CIFAR-100 each contain 3232-pixel color images, consists of 50,000 training images and 10,000 testing images. But in case of CIFAR-10, it includes 10 classes, and CIFAR-100 includes 100 classes. The standard data augmentation, horizontal flipping, and translation by 4 pixels are adopted in our experiments, following the common practice [18]. The results achieved by PyramidNets are based on the proposed residual unit: placing a BN layer after the final convolutional layer, and removing the first ReLU as in Figure 6

 (d). Our code is built on Torch open source deep learning framework 

[1].

4.1 Training Settings

Our PyramidNets are trained using backpropagation 

[15]

by Stochastic Gradient Descent (SGD) with Nesterov momentum for 300 epochs on CIFAR-10 and CIFAR-100 datasets. The initial learning rate is set to 0.1 for CIFAR-10 and 0.5 for CIFAR-100, and is decayed by a factor of 0.1 at 150 and 225 epochs, respectively. The filter parameters are initialized by “msra” 

[6]. We use a weight decay of 0.0001, a dampening of 0, a momentum of 0.9, and a batch size of 128.

  
Figure 7: Comparison of test error curves with error bars of additive PyramidNet and multiplicative PyramidNet on CIFAR-10 (left) and CIFAR-100 (right) datasets, according to the different number of parameters.
Network # of Params Output Feat. Dim. Augmentation Train Crop Test Crop Top-1 Top-5
ResNet-152 [7] 60.0M 2,048 scale 224224 224224 23.0 6.7
Pre-ResNet-152 [8] 60.0M 2,048 scale+asp ratio 224224 224224 22.2 6.2
Pre-ResNet-200 [8] 64.5M 2,048 scale+asp ratio 224224 224224 21.7 5.8
WRN-50-2-bottleneck [34] 68.9M 2,048 scale+asp ratio 224224 224224 21.9 6.0
PyramidNet-200 () 62.1M 1,456 scale+asp ratio 224224 224224 20.5 5.3
PyramidNet-200 () 62.1M 1,456 scale+asp ratio 224224 224224 20.5 5.4
PyramidNet-200 () 116.4M 2,056 scale+asp ratio 224224 224224 20.1 5.4
ResNet-200 [7] 64.5M 2,048 scale 224224 320320 21.8 6.0
Pre-ResNet-200 [8] 64.5M 2,048 scale+asp ratio 224224 320320 20.1 4.8
Inception-v3 [32] - 2,048 scale+asp ratio 299299 299299 21.2 5.6
Inception-ResNet-v1 [30] - 1,792 scale+asp ratio 299299 299299 21.3 5.5
Inception-v4 [30] - 1,536 scale+asp ratio 299299 299299 20.0 5.0
Inception-ResNet-v2 [30] - 1,792 scale+asp ratio 299299 299299 19.9 4.9
PyramidNet-200 () 62.1M 1,456 scale+asp ratio 224224 320320 19.6 4.8
PyramidNet-200 () 62.1M 1,456 scale+asp ratio 224224 320320 19.5 4.8
PyramidNet-200 () 116.4M 2,056 scale+asp ratio 224224 320320 19.2 4.7
Table 5: Comparisons of single-model, single-crop error (%) on the ILSVRC 2012 validation set. All the results of PyramidNets are produced with additive PyramidNets. “asp ratio” means the aspect ratio applied for data augmention, and “Output feat. dim.” denotes the feature dimension of just after the last global pooling layer. denotes the models which applied dropout method, and denotes the results obtained from https://github.com/facebook/fb.resnet.torch.

4.2 Performance Evaluation

In our work, we mainly use the top-1 error rate for evaluating our network architecture. Additive PyramidNets with both basic and pyramidal bottleneck residual units are used. The error rates are provided in Table 4 for ours and the state-of-the-art models. The experimental results show that our network has superior generalization ability, in terms of the number of parameters, showing the best results compared with other models.

Figure 7 compares additive and multiplicative PyramidNets using CIFAR datasets. When the number of parameters is low, both additive and multiplicative PyramidNets show similar performance, because these two network architectures do not have significant structural differences. As the number of parameters increases, they start to show a more marked difference in terms of the feature map dimension configuration. Because the feature map dimension increases linearly in the case of additive PyramidNets, the feature map dimensions of the input-side layers tend to be larger, and those of the output-side layers tend to be smaller, compared with multiplicative PyramidNets as illustrated in Figure 2.

Previous works [7, 25] typically set multiplicative scaling of feature map dimension for downsampling modules, which is implemented to give a larger degree of freedom to the classification part by increasing the feature map dimension of the output-side layers. However, for our PyramidNet, the results in Figure 7 implies that increasing the model capacity of the input-side layers would lead to a better performance improvement than using a conventional way of multiplicative scaling of feature map dimension.

We also note that, although the use of regularization methods such as dropout [28] or stochastic depth [10] could further improve the performance of our model, we did not involve those methods to ensure a fair comparison with other models.

4.3 ImageNet

1,000-class ImageNet dataset [22] used for ILSVRC contains more than one million training images and 50,000 validation images. We use additive PyramidNets with the pyramidal bottleneck residual units, deleting the first ReLU and adding a BN layer at the last layer as described in Section 3.3 and shown in Figure 6 (d) for further performance improvement.

We train our models for 120 epochs with a batch size of 128, and the initial learning rate is set to 0.05, divided by 10 at 60, 90 and 105 epochs. We use the same weight decay, momentum, and initialization settings as those of CIFAR datasets. We train our model by using a standard data augmentation with scale jittering and aspect ratio as suggested in Szegedy et al. [31]. Table 5 shows the results of our PyramidNets in ImageNet dataset compared with the state-of-the-art models. The experimental results show that our PyramidNet with has a top-1 error rate of 20.5, which is 1.2 lower than the pre-activation ResNet-200 [8] which has a similar number of parameters but higher output feature dimension than our model. We also notice that increasing with an appropriate regularization method can further improve the performance.

For comparison with the Inception-ResNet [30] that uses a testing crop with size, we test our model on a crop, by the same reason with the work of He et al. [8]. Our PyramidNet with shows a top-1 error rate of 19.6, which outperforms both the pre-activation ResNet [8] and the Inception-ResNet-v2 [30] models.

5 Conclusion

The main idea of the novel deep network architecture described in this paper involves increasing the feature map dimension gradually, in order to construct so-called PyramidNets along with the concept of ResNets. We also developed a novel residual unit, which includes a new building block for a residual unit with a zero-padded shortcut; this design leads to significantly improved generalization ability. In tests using CIFAR-10, CIFAR-100, and ImageNet-1k datasets, our PyramidNets outperform all previous state-of-the-art deep network architectures. Furthermore, the insights in this paper could be utilized by any network architecture, to improve their capacity for better performance. In future work, we will develop methods of optimizing parameters such as feature map dimensions in more principled ways with proper cost functions that give insight into the nature of residual networks.

Acknowledgements:

This work was supported by the ICT R&D program of MSIP/IITP, 2016-0-00563, Research on Adaptive Machine Learning Technology Development for Intelligent Autonomous Digital Companion.

References

  • [1] R. Collobert, K. Kavukcuoglu, and C. Farabet. Torch7: A matlab-like environment for machine learning. In BigLearn, NIPS Workshop, 2011.
  • [2] J. Donahue, Y. Jia, O. Vinyals, J. Hoffman, N. Zhang, E. Tzeng, and T. Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. In ICML, 2014.
  • [3] R. Girshick, J. Donahue, T. Darrell, and J. Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014.
  • [4] B. Graham. Fractional max-pooling. arXiv preprint arXiv:1412.6071, 2014.
  • [5] S. Gross and M. Wilber. Training and investigating residual nets. 2016. http://torch.ch/blog/2016/02/04/resnets.html.
  • [6] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In ICCV, 2015.
  • [7] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, 2016.
  • [8] K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In ECCV, 2016.
  • [9] G. Huang, Z. Liu, and K. Q. Weinberger. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016.
  • [10] G. Huang, Y. Sun, Z. Liu, D. Sedra, and K. Weinberger. Deep networks with stochastic depth. In ECCV, 2016.
  • [11] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
  • [12] A. Krizhevsky. Learning multiple layers of features from tiny images. In Tech Report, 2009.
  • [13] A. Krizhevsky, I. Sutskever, and G. E. Hinton. ImageNet Classification with Deep Convolutional Neural Networks. In NIPS, 2012.
  • [14] G. Larsson, M. Maire, and G. Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. arXiv preprint arXiv:1605.07648, 2016.
  • [15] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.
  • [16] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
  • [17] C.-Y. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu. Deeply-supervised nets. In AISTATS, 2015.
  • [18] M. Lin, Q. Chen, and S. Yan. Network in network. In ICLR, 2014.
  • [19] J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In CVPR, 2015.
  • [20] V. Nair and G. E. Hinton.

    Rectified linear units improve restricted boltzmann machines.

    In ICML, 2010.
  • [21] A. Romero, N. Ballas, S. E. Kahou, A. Chassang, C. Gatta, and Y. Bengio. Fitnets: Hints for thin deep nets. In ICLR, 2015.
  • [22] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. C. Berg, and L. Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
  • [23] P. Sermanet, D. Eigen, X. Zhang, M. Mathieu, R. Fergus, and Y. LeCun. Overfeat: Integrated recognition, localization and detection using convolutional networks. In ICLR, 2014.
  • [24] F. Shen and G. Zeng. Weighted residuals for very deep networks. arXiv preprint arXiv:1605.08831, 2016.
  • [25] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
  • [26] S. Singh, D. Hoiem, and D. Forsyth. Swapout: Learning an ensemble of deep architectures. In NIPS, 2016.
  • [27] J. T. Springenberg, A. Dosovitskiy, T. Brox, and M. Riedmiller. Striving for simplicity: The all convolutional net. In ICLR Workshop, 2015.
  • [28] N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014.
  • [29] R. K. Srivastava, K. Greff, and J. Schmidhuber. Training very deep networks. In NIPS, 2015.
  • [30] C. Szegedy, S. Ioffe, and V. Vanhoucke.

    Inception-v4, inception-resnet and the impact of residual connections on learning.

    In ICLR Workshop, 2016.
  • [31] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In CVPR, 2015.
  • [32] C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.
  • [33] A. Veit, M. Wilber, and S. Belongie. Residual networks behave like ensembles of relatively shallow networks. In NIPS, 2016.
  • [34] S. Zagoruyko and N. Komodakis. Wide residual networks. In BMVC, 2016.
  • [35] M. D. Zeiler and R. Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.