# ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices 用于移动设备的极其高效的卷积神经网络

＞ 论文中英文对照合集 ： https://aiqianji.com/blog/articles

## Abstract

We introduce an extremely computation-efficient CNN architecture named ShuffleNet, which is designed specially for mobile devices with very limited computing power (e.g., 10-150 MFLOPs). The new architecture utilizes two new operations, pointwise group convolution and channel shuffle, to greatly reduce computation cost while maintaining accuracy. Experiments on ImageNet classification and MS COCO object detection demonstrate the superior performance of ShuffleNet over other structures, e.g. lower top-1 error (absolute 7.8%) than recent MobileNet on ImageNet classification task, under the computation budget of 40 MFLOPs. On an ARM-based mobile device, ShuffleNet achieves \sim 13 \times actual speedup over AlexNet while maintaining comparable accuracy.

.

## Introduction 简介

Building deeper and larger convolutional neural networks (CNNs) is a primary trend for solving major visual recognition tasks. The most accurate CNNs usually have hundreds of layers and thousands of channels, thus requiring computation at billions of FLOPs. This report examines the opposite extreme: pursuing the best accuracy in very limited computational budgets at tens or hundreds of MFLOPs, focusing on common mobile platforms such as drones, robots, and smartphones. Note that many existing works} focus on pruning, compressing, or low-bit representing a basic" network architecture. Here we aim to explore a highly efficient basic architecture specially designed for our desired computing ranges.

We notice that state-of-the-art basic architectures such as Xception and ResNeXt become less efficient in extremely small networks because of the costly dense $1\times 1$ convolutions. We propose using pointwise group convolutions to reduce computation complexity of $1\times 1$ convolutions. To overcome the side effects brought by group convolutions, we come up with a novel channel shuffle operation to help the information flowing across feature channels. Based on the two techniques, we build a highly efficient architecture called ShuffleNet. Compared with popular structures like , for a given computation complexity budget, our ShuffleNet allows more feature map channels, which helps to encode more information and is especially critical to the performance of very small networks.

We evaluate our models on the challenging ImageNet classification and MS COCO object detection tasks. A series of controlled experiments shows the effectiveness of our design principles and the better performance over other structures. Compared with the state-of-the-art architecture MobileNet, ShuffleNet achieves superior performance by a significant margin, e.g. absolute 7.8% lower ImageNet top-1 error at level of 40 MFLOPs. We also examine the speedup on real hardware, i.e. an off-the-shelf ARM-based computing core. The ShuffleNet model achieves $\sim$ actual speedup (theoretical speedup is 18 $\times$ ) over AlexNet while maintaining comparable accuracy.

The last few years have seen the success of deep neural networks in computer vision tasks, in which model designs play an important role. The increasing needs of running high quality deep neural networks on embedded devices encourage the study on efficient model designs. For example, GoogLeNet increases the depth of networks with much lower complexity compared to simply stacking convolution layers. SqueezeNet reduces parameters and computation significantly while maintaining accuracy. ResNet utilizes the efficient bottleneck structure to achieve impressive performance. SENet introduces an architectural unit that boosts performance at slight computation cost. Concurrent with us, a very recent work employs reinforcement learning and model search to explore efficient model designs. The proposed mobile NASNet model achieves comparable performance with our counterpart ShuffleNet model (26.0% @ 564 MFLOPs vs. 26.3% @ 524 MFLOPs for ImageNet classification error). But do not report results on extremely tiny models (e.g. complexity less than 150 MFLOPs), nor evaluate the actual inference time on mobile devices. The concept of group convolution, which was first introduced in AlexNet for distributing the model over two GPUs, has been well demonstrated its effectiveness in ResNeXt. Depthwise separable convolution proposed in Xception generalizes the ideas of separable convolutions in Inception series. Recently, MobileNet utilizes the depthwise separable convolutions and gains state-of-the-art results among lightweight models. Our work generalizes group convolution and depthwise separable convolution in a novel form.

To the best of our knowledge, the idea of channel shuffle operation is rarely mentioned in previous work on efficient model design, although CNN library cuda-convnet supports random sparse convolution" layer, which is equivalent to random channel shuffle followed by a group convolutional layer. Such random shuffle" operation has different purpose and been seldom exploited later. Very recently, another concurrent work also adopt this idea for a two-stage convolution. However, did not specially investigate the effectiveness of channel shuffle itself and its usage in tiny model design.

This direction aims to accelerate inference while preserving accuracy of a pre-trained model. Pruning network connections or channels reduces redundant connections in a pre-trained model while maintaining performance. Quantization and factorization are proposed in literature to reduce redundancy in calculations to speed up inference. Without modifying the parameters, optimized convolution algorithms implemented by FFT and other methods decrease time consumption in practice. Distilling transfers knowledge from large models into small ones, which makes training small models easier.

## Approach 方法

### Channel Shuffle for Group Convolutions 分组卷积的通道混洗

Modern convolutional neural networks usually consist of repeated building blocks with the same structure. Among them, state-of-the-art networks such as Xception and ResNeXt introduce efficient depthwise separable convolutions or group convolutions into the building blocks to strike an excellent trade-off between representation capability and computational cost. However, we notice that both designs do not fully take the $1\times1$ convolutions (also called pointwise convolutions in ) into account, which require considerable complexity. For example, in ResNeXt only $3\times3$ layers are equipped with group convolutions. As a result, for each residual unit in ResNeXt the pointwise convolutions occupy 93.4% multiplication-adds (cardinality = 32 as suggested in ). In tiny networks, expensive pointwise convolutions result in limited number of channels to meet the complexity constraint, which might significantly damage the accuracy. To address the issue, a straightforward solution is to apply channel sparse connections, for example group convolutions, also on $1\times1$ layers. By ensuring that each convolution operates only on the corresponding input channel group, group convolution significantly reduces computation cost. However, if multiple group convolutions stack together, there is one side effect: outputs from a certain channel are only derived from a small fraction of input channels. Figchannelshuffle(a) illustrates a situation of two stacked group convolution layers.

It is clear that outputs from a certain group only relate to the inputs within the group. This property blocks information flow between channel groups and weakens representation. If we allow group convolution to obtain input data from different groups (as shown in Figchannelshuffle(b)), the input and output channels will be fully related. Specifically, for the feature map generated from the previous group layer, we can first divide the channels in each group into several subgroups, then feed each group in the next layer with different subgroups. This can be efficiently and elegantly implemented by a channel shuffle operation (Figchannelshuffle(c)): suppose a convolutional layer with $g$ groups whose output has $g\times n$ channels; we first reshape the output channel dimension into $(g, n)$ , transposing and then flattening it back as the input of next layer. Note that the operation still takes effect even if the two convolutions have different numbers of groups. Moreover, channel shuffle is also differentiable, which means it can be embedded into network structures for end-to-end training. Channel shuffle operation makes it possible to build more powerful structures with multiple group convolutional layers. In the next subsection we will introduce an efficient network unit with channel shuffle and group convolution.

### ShuffleNet Unit ShuffleNet 单元

Taking advantage of the channel shuffle operation, we propose a novel ShuffleNet unit specially designed for small networks. We start from the design principle of bottleneck unit in Figunit(a). It is a residual block. In its residual branch, for the $3\times 3$ layer, we apply a computational economical $3\times 3$ depthwise convolution on the bottleneck feature map. Then, we replace the first $1\times 1$ layer with pointwise group convolution followed by a channel shuffle operation, to form a ShuffleNet unit, as shown in Figunit(b). The purpose of the second pointwise group convolution is to recover the channel dimension to match the shortcut path. For simplicity, we do not apply an extra channel shuffle operation after the second pointwise layer as it results in comparable scores. The usage of batch normalization (BN) and nonlinearity is similar to , except that we do not use ReLU after depthwise convolution as suggested by . As for the case where ShuffleNet is applied with stride, we simply make two modifications (see Figunit(c)): (i) add a $3\times 3$ average pooling on the shortcut path; (ii) replace the element-wise addition with channel concatenation, which makes it easy to enlarge channel dimension with little extra computation cost.

Thanks to pointwise group convolution with channel shuffle, all components in ShuffleNet unit can be computed efficiently. Compared with ResNet (bottleneck design) and ResNeXt, our structure has less complexity under the same settings. For example, given the input size $c\times h \times w$ and the bottleneck channels $m$ , ResNet unit requires $hw(2cm+9m^2)$ FLOPs and ResNeXt has $hw(2cm+9m^2/g)$ FLOPs, while our ShuffleNet unit requires only $hw(2cm/g+9m)$ FLOPs, where $g$ means the number of groups for convolutions. In other words, given a computational budget, ShuffleNet can use wider feature maps. We find this is critical for small networks, as tiny networks usually have an insufficient number of channels to process the information. In addition, in ShuffleNet depthwise convolution only performs on bottleneck feature maps. Even though depthwise convolution usually has very low theoretical complexity, we find it difficult to efficiently implement on low-power mobile devices, which may result from a worse computation/memory access ratio compared with other dense operations. Such drawback is also referred in , which has a runtime library based on TensorFlow. In ShuffleNet units, we intentionally use depthwise convolution only on bottleneck in order to prevent overhead as much as possible.

### Network Architecture 网络架构

Built on ShuffleNet units, we present the overall ShuffleNet architecture in Table arch. The proposed network is mainly composed of a stack of ShuffleNet units grouped into three stages. The first building block in each stage is applied with stride = 2. Other hyper-parameters within a stage stay the same, and for the next stage the output channels are doubled. Similar to , we set the number of bottleneck channels to 1/4 of the output channels for each ShuffleNet unit. Our intent is to provide a reference design as simple as possible, although we find that further hyper-parameter tunning might generate better results.

In ShuffleNet units, group number $g$ controls the connection sparsity of pointwise convolutions. Tablearch explores different group numbers and we adapt the output channels to ensure overall computation cost roughly unchanged ( $\sim$ 140 MFLOPs). Obviously, larger group numbers result in more output channels (thus more convolutional filters) for a given complexity constraint, which helps to encode more information, though it might also lead to degradation for an individual convolutional filter due to limited corresponding input channels.

In Secgconv we will study the impact of this number subject to different computational constrains. To customize the network to a desired complexity, we can simply apply a scale factor $s$ on the number of channels. For example, we denote the networks in Tablearch as "ShuffleNet 1 $\times$ ", then "ShuffleNet $s\times$ " means scaling the number of filters in ShuffleNet 1 $\times$ by $s$ times thus overall complexity will be roughly $s^2$ times of ShuffleNet 1 $\times$ .

## Experiments 实验

We mainly evaluate our models on the ImageNet 2012 classification dataset. We follow most of the training settings and hyper-parameters used in , with two exceptions: (i) we set the weight decay to 4e-5 instead of 1e-4 and use linear-decay learning rate policy (decreased from 0.5 to 0); (ii) we use slightly less aggressive scale augmentation for data preprocessing. Similar modifications are also referenced in because such small networks usually suffer from underfitting rather than overfitting. It takes 1 or 2 days to train a model for $3\times 10^5$ iterations on 4 GPUs, whose batch size is set to 1024. To benchmark, we compare single crop top-1 performance on ImageNet validation set, i.e. cropping $224\times 224$ center view from $256\times$ input image and evaluating classification accuracy. We use exactly the same settings for all models to ensure fair comparisons.

### Ablation Study 消融研究

The core idea of ShuffleNet lies in pointwise group convolution and channel shuffle operation. In this subsection we evaluate them respectively.

ShuffleNet 的核心思想在于第 3.1 节和第 3.2 节中引用的逐点分组卷积和通道混洗操作 。在本小节中，我们分别对其进行评估。

#### Pointwise Group Convolutions 逐点分组卷积

To evaluate the importance of pointwise group convolutions, we compare ShuffleNet models of the same complexity whose numbers of groups range from 1 to 8. If the group number equals 1, no pointwise group convolution is involved and then the ShuffleNet unit becomes an "Xception-like" structure. For better understanding, we also scale the width of the networks to 3 different complexities and compare their classification performance respectively. Results are shown in Tablegroupconv.

From the results, we see that models with group convolutions ( $g>1$ ) consistently perform better than the counterparts without pointwise group convolutions ( $g=1$ ). Smaller models tend to benefit more from groups. For example, for ShuffleNet 1 $\times$ the best entry ( $g=8$ ) is 1.2% better than the counterpart, while for ShuffleNet 0.5 $\times$ and 0.25 $\times$ the gaps become 3.5% and 4.4% respectively. Note that group convolution allows more feature map channels for a given complexity constraint, so we hypothesize that the performance gain comes from wider feature maps which help to encode more information. In addition, a smaller network involves thinner feature maps, meaning it benefits more from enlarged feature maps.

Table groupconv also shows that for some models (e.g. ShuffleNet 0.5 $\times$ ) when group numbers become relatively large (e.g. $g=8$ ), the classification score saturates or even drops. With an increase in group number (thus wider feature maps), input channels for each convolutional filter become fewer, which may harm representation capability. Interestingly, we also notice that for smaller models such as ShuffleNet 0.25 $\times$ larger group numbers tend to better results consistently, which suggests wider feature maps bring more benefits for smaller models.

2 还显示了对于某些模型（例如 ShuffleNet 1×），当组号变得相对较大时（例如 G=4 或者 8），则分类得分达到饱和甚至下降。随着组数的增加（因此，特征图会更宽），每个卷积滤波器的输入通道会越来越少，这可能会损害表示能力。有趣的是，我们还注意到，对于较小的模型，例如 ShuffleNet 0.25× 较大的组数趋于一致地获得更好的结果，这表明较宽的特征图对于较小的模型尤为重要。受此启发，对于低成本模型，我们对表 1 中的体系结构进行了少许修改 ：我们在 Stage3 中删除了两个单元，并加宽了每个功能图，以保持整体复杂性。表 2 中显示了新体系结构（名为“ arch2 ”）的结果 。显然，新设计的模型始终优于同类模型。此外，逐点群卷积在体系结构中仍然有效。

#### Channel Shuffle vs. No Shuffle 通道混洗与无混洗操作

The purpose of shuffle operation is to enable cross-group information flow for multiple group convolution layers. Tableshuffle compares the performance of ShuffleNet structures (group number is set to 3 or 8 for instance) with/without channel shuffle. The evaluations are performed under three different scales of complexity. It is clear that channel shuffle consistently boosts classification scores for different settings. Especially, when group number is relatively large (e.g. $g=8$ ), models with channel shuffle outperform the counterparts by a significant margin, which shows the importance of cross-group information interchange.

### Comparison with Other Structure Units 与其他结构单元的比较

Recent leading convolutional units in VGG, ResNet, GoogleNet, ResNeXt and Xception have pursued state-of-the-art results with large models (e.g. $\ge 1$ GFLOPs), but do not fully explore low-complexity conditions. In this section we survey a variety of building blocks and make comparisons with ShuffleNet under the same complexity constraint. For fair comparison, we use the overall network architecture as shown in Tablearch. We replace the ShuffleNet units in Stage 2-4 with other structures, then adapt the number of channels to ensure the complexity remains unchanged. The structures we explored include: - \emph{VGG-like}. Following the design principle of VGG net, we use a two-layer 3 \times 3 convolutions as the basic building block. Different from , we add a Batch Normalization layer after each of the convolutions to make end-to-end training easier. - \emph{ResNet}. We adopt the "bottleneck" design in our experiment, which has been demonstrated more efficient in . Same as , the \emph{bottleneck ratio}\footnote{In the bottleneck-like units (like ResNet, ResNeXt or ShuffleNet) \emph{bottleneck ratio} implies the ratio of bottleneck channels to output channels. For example, bottleneck ratio = 1:4 means the output feature map is 4 times the width of the bottleneck feature map. } is also 1:4 . - \emph{Xception-like}. The original structure proposed in involves fancy designs or hyper-parameters for different stages, which we find difficult for fair comparison on small models. Instead, we remove the pointwise group convolutions and channel shuffle operation from ShuffleNet (also equivalent to ShuffleNet with g=1 ). The derived structure shares the same idea of depthwise separable convolution" as in , which is called an \emph{Xception-like} structure here. - \emph{ResNeXt}. We use the settings of \emph{cardinality} =16 and bottleneck ratio =1:2 as suggested in . We also explore other settings, e.

### 与其他结构单位的比较

VGG [ 27 ]，ResNet [ 9 ]，GoogleNet [ 30 ]，ResNeXt [ 37 ]和 Xception [ 3 ]中最近的领先卷积单元 都采用大型模型（例如，≥1 个 GFLOPs），但不能完全探索低复杂性条件。在本节中，我们将调查各种构建基块，并在相同的复杂性约束下与 ShuffleNet 进行比较。

• 像 VGG 一样。遵循 VGG net [ 27 ]的设计原理 ，我们使用两层 3×3 个卷积作为基本构建块。与[ 27 ]不同 ，我们在每个卷积之后添加了一个批处理归一化层 [ 14 ]，以简化端到端的训练。
• ResNet。我们在实验中采用了“瓶颈”设计，这在[ 9 ]中得到了更有效的证明 。与[ 9 ]相同 ，瓶颈比率为 =1:4
• 类似 Xception。在[ 3 ]中提出的原始结构 涉及不同阶段的精美设计或超参数，我们发现很难在小模型上进行公平比较。取而代之的是，我们从 ShuffleNet（也等效于 ShuffleNetG=1 个）。派生的结构与[ 3 ]中的“深度可分离卷积”具有相同的思想，在 此称为 Xception-like 结构。
• ResNeXt。我们使用基数的设置** =16 和瓶颈比率 =1 个：2 个如[ 37 ]中建议的 。我们还将探索其他设置，例如瓶颈比率=1：4，并获得相似的结果。

We use exactly the same settings to train these models. Results are shown in Tablestructues. Our ShuffleNet models outperform most others by a significant margin under different complexities. Interestingly, we find an empirical relationship between feature map channels and classification accuracy. For example, under the complexity of 38 MFLOPs, output channels of Stage 4 (see Tablearch) for VGG-like, ResNet, ResNeXt, Xception-like, ShuffleNet models are 50, 192, 192, 288, 576 respectively, which is consistent with the increase of accuracy. Since the efficient design of ShuffleNet, we can use more channels for a given computation budget, thus usually resulting in better performance. Note that the above comparisons do not include GoogleNet or Inception series. We find it nontrivial to generate such Inception structures to small networks because the original design of Inception module involves too many hyper-parameters. As a reference, the first GoogleNet version has 31.3% top-1 error at the cost of 1.5 GFLOPs (See Tablecomplexity). More sophisticated Inception versions are more accurate, however, involve significantly increased complexity. Recently, Kim et al. propose a lightweight network structure named PVANET which adopts Inception units. Our reimplemented PVANET (with 224 $\times$ 224 input size) has 29.7% classification error with a computation complexity of 557 MFLOPs, while our ShuffleNet 2x model ( $g=3$ ) gets 26.3% with 524 MFLOPs (see Tablecomplexity).

4 还在较浅但较宽的体系结构上评估了各种模型（标记为“ arch2 ”，有关详细信息，请参见 4.1.1）。可以看出，与其他结构相比，ShuffleNet 仍然取得了出色的结果。

### Comparison with MobileNets and Other Frameworks 与 MOBILENETS 和其他框架的比较

Recently Howard et al. have proposed MobileNets which mainly focus on efficient network architecture for mobile devices. MobileNet takes the idea of depthwise separable convolution from and achieves state-of-the-art results on small models. Tablemobilecls compares classification scores under a variety of complexity levels. It is clear that our ShuffleNet models are superior to MobileNet for all the complexities. Though our ShuffleNet network is specially designed for small models ( $<150$ MFLOPs), we find it is still better than MobileNet for higher computation cost, e.g. 3.1% more accurate than MobileNet 1 $\times$ at the cost of 500 MFLOPs. For smaller networks ( $\sim$ 40 MFLOPs) ShuffleNet surpasses MobileNet by . Note that our ShuffleNet architecture contains 50 layers while MobileNet only has 28 layers. For better understanding, we also try ShuffleNet on a 26-layer architecture by removing half of the blocks in Stage 2-4 (see "ShuffleNet 0.5 $\times$ shallow ( $g=3$ )" in Tablemobilecls). Results show that the shallower model is still significantly better than the corresponding MobileNet, which implies that the effectiveness of ShuffleNet mainly results from its efficient structure, not the depth. Tablecomplexity compares our ShuffleNet with a few popular models. Results show that with similar accuracy ShuffleNet is much more efficient than others. For example, ShuffleNet 0.5 $\times$ is theoretically 18 $\times$ faster than AlexNet with comparable classification score. We will evaluate the actual running time in Sec actual. It is also worth noting that the simple architecture design makes it easy to equip ShuffeNets with the latest advances such as . For example, in the authors propose Squeeze-and-Excitation (SE) blocks which achieve state-of-the-art results on large ImageNet models. We find SE modules also take effect in combination with the backbone ShuffleNets, for instance, boosting the top-1 error of ShuffleNet 2 $\times$ to 24.7%(shown in Tablemobilecls). Interestingly, though negligible increase of theoretical complexity, we find ShuffleNets with SE modules are usually $25 \sim 40%$ slower than the raw ShuffleNets on mobile devices, which implies that actual speedup evaluation is critical on low-cost architecture design. In Secactual we will make further discussion.

5 比较了各种复杂性级别下的分类得分。显然，我们的 ShuffleNet 模型在所有复杂性方面都优于 MobileNet。尽管我们的 ShuffleNet 网络是专门为小型机型设计的（<150MFLOPs），我们发现它在计算成本上仍比 MobileNet 稍好。对于较小的网络（约 40 个 MFLOP），ShuffleNet 超过 MobileNet 6.7％。请注意，我们的 ShuffleNet 架构包含 50 层（或 arch2 则为 44 层），而 MobileNet 仅包含 28 层。为了更好地理解，我们还通过在阶段 2-4 中删除一半的块来尝试在 26 层体系结构上使用 ShuffleNet（请参阅“ ShuffleNet 0.5× （G=3）”表 5）。结果表明，该浅模型仍然显著优于相应 MobileNet，这意味着的 ShuffleNet 的有效性，主要是由于从它的有效的结构，而不是深度。

6 将我们的 ShuffleNet 与一些流行的模型进行了比较。结果表明，以相似的精度 ShuffleNet 比其他的效率更高。例如，ShuffleNet 0.5× 理论上是 18× 速度比具有类似分类评分的 AlexNet [ 19 ]快 。我们将在 4.5 节中评估实际的运行时间。

### Generalization Ability 泛化能力

To evaluate the generalization ability for transfer learning, we test our ShuffleNet model on the task of MS COCO object detection. We adopt Faster-RCNN as the detection framework and use the publicly released Caffe code for training with default settings. Similar to , the models are trained on the COCO train+val dataset excluding 5000 minival images and we conduct testing on the minival set. Tabledet shows the comparison of results trained and evaluated on two input resolutions. Comparing ShuffleNet 2 $\times$ with MobileNet whose complexity are comparable (524 vs. 569 MFLOPs), our ShuffleNet 2 $\times$ surpasses MobileNet by a significant margin on both resolutions; our ShuffleNet 1 $\times$ also achieves comparable results with MobileNet on 600 $\times$ resolution, but has $\sim$ 4 $\times$ complexity reduction. We conjecture that this significant gain is partly due to ShuffleNet's simple design of architecture without bells and whistles.

### Actual Speedup Evaluation 实际加速评估

Finally, we evaluate the actual inference speed of ShuffleNet models on a mobile device with an ARM platform. Though ShuffleNets with larger group numbers (e.g. $g=4$ or $g=8$ ) usually have better performance, we find it less efficient in our current implementation. Empirically $g=3$ usually has a proper trade-off between accuracy and actual inference time. As shown in Tableactual, three input resolutions are exploited for the test. Due to memory access and other overheads, we find every 4 $\times$ theoretical complexity reduction usually results in $\sim$ 2.6 $\times$ actual speedup in our implementation. Nevertheless, compared with AlexNet our ShuffleNet 0.5 $\times$ model still achieves $\sim$ 13 $\times$ speedup under comparable classification accuracy (the theoretical speedup is 18 $\times$ ), which is much faster than previous AlexNet-level models or speedup approaches such as .