Two-Bit Networks for Deep Learning on Resource-Constrained Embedded Devices

01/02/2017 ∙ by Wenjia Meng, et al. ∙ Zhejiang University 0

With the rapid proliferation of Internet of Things and intelligent edge devices, there is an increasing need for implementing machine learning algorithms, including deep learning, on resource-constrained mobile embedded devices with limited memory and computation power. Typical large Convolutional Neural Networks (CNNs) need large amounts of memory and computational power, and cannot be deployed on embedded devices efficiently. We present Two-Bit Networks (TBNs) for model compression of CNNs with edge weights constrained to (-2, -1, 1, 2), which can be encoded with two bits. Our approach can reduce the memory usage and improve computational efficiency significantly while achieving good performance in terms of classification accuracy, thus representing a reasonable tradeoff between model size and performance.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

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

Deep Neural Networks (DNNs) are widely used for a variety of machine learning tasks currently, including computer vision, natural language processing, and others. Convolutional Neural Networks (CNNs) are especially suitable for computer vision applications, including object recognition, classification, detection, image segmentation, etc. Smart mobile devices equipped with high-resolution cameras have opened the door to potential mobile computer vision applications. However, a typical CNN has millions of parameters and perform billions of arithmetic operations for each inference, e.g., AlexNet

[1]

has 61M parameters (249MB of memory with floating point weights) and performs 1.5B high-precision operations to classify one image. The enormous demand for memory storage and computation power hinders their deployment on resource-constrained embedded devices with limited memory and computation power. It is an active research topic to adapt DNNs/CNNs for deployment on embedded devices.

A number of authors have proposed techniques for reducing size of DNNs/CNNs, including model pruning [6], i.e., removing edges with small weight magnitudes, and weight compression, i.e., reducing the precision of weights by using a small number of bits to edge weight and/or activation. These two approaches are orthogonal and can be applied separately or together. We focus on weight compression in this paper. The low bit-width translates to small memory footprint and high arithmetic computational efficiency. Courbariaux et al. presented BinaryConnect [3] for training a DNN with binary weights -1 or 1, and BinaryNet [4]

for training a DNN with both binary weights and binary activations. Both BinaryConnect and BinaryNet can achieve good performance on small datasets such as MNIST, CIFAR-10 and SVHN, but performed worse than their full-precision counterparts by a wide margin on large-scale datasets like ImageNet. Rastegari et al.

[2] presented Binary Weight Networks and XNOR-Net

, two efficient approximations to standard CNNs, which are shown to outperform BinaryConnect and BinaryNet by large margins on ImageNet. In Binary-WeightNetworks, the convolutional filters are approximated with binary values (-1,1); in XNOR-Networks, both filters and input to convolutional layers are binary. However, there is still a significant performance gap between these network models and their full-precision counterparts. Also, binarization of both activations and weights generally leads to dramatic performance degradation compared to binarization of weights only.

To strike a balance between model compression rate and model capacity, Li et al. [5] presented Ternary Weight Networks with weights constrained to (-1, 0, 1), each weight encoded with two bits. Compared with DNN models with binary weights, Ternary Weight Networks can achieve better performance due to increased weight precision. However, Ternary Weight Networks make use of only three values (-1, 0, 1) out of the four possible values that can be encoded with two bits.

In this paper, we propose Two-Bit Networks (TBNs) to further explore the tradeoff between model compression rate and model capacity. (We focus on CNNs in this paper, although our techniques can be adapted to apply to general DNNs, including Recurrent Neural Networks.) We constrain weights to four values (-2, -1, 1, 2), which can be encoded with two bits. Compared with existing weight compression methods, TBNs make more efficient use of weight bit-width to achieve higher model capacity and better performance. Arithmetic operations can be implemented with additions, subtractions, and shifts, which are very efficient and hardware-friendly.

We propose a training algorithm for DNNs based on Stochastic Gradient Descent. During each iteration, a set of real-valued weights are discretized into two-bit values, which are used by the following forward pass and backward pass. Then, the real-valued weights are updated with gradients computed by the backward pass. During inference, only the two-bit weights are used. Experimental results show that or method achieves better performance on ImageNet than other weight compression methods.

2 Two-Bits Networks

In a CNN with layers, each layer performs a convolution

on its input tensor

and each of its convolution filters , where and represents shape of the input tensor and the filter, respectively, including channels, width, and height. Let denote the number of elements in , and denote the element of , with . For brevity, we drop indexes and when they are unnecessary.

Each real-valued convolution filter is approximated with a binary filter and a scaling factor , so that . A convolution operation can be approximated by:

(1)

where denotes a convolution operation without multiplication.

Ideally, the TBN should mimic its full-precision counterpart closely, provided that quantization error between and its approximation is minimized. We seek to minimize the L2-norm of the quantization error for each convolution filter:

(2)

The optimization can be divided into two steps. First, the real-valued weights are discretized to find the two-bit weights. Then, the optimal scaling factor is found to minimize the quantization error, given the two-bit weights. For simplicity, we adopt deterministic discretization:

(3)

Substitute the two-bit weights (3) into the expression for quantization error, the expression can be simplified into:

(4)

where , , is a constant independent of , and denotes the magnitude of .

Taking the derivative of w.r.t. and setting to zero, we obtain the optimal scaling factor:

(5)

3 Training Two-Bit Networks

We describe details of the training algorithm for Two-Bit Networks based on Stochastic Gradient Descent (SGD). Algorithm 1 shows the pseudocode for each training iteration. In order to keep track of tiny weight updates of each iteration, we adopt a similar trick as [3] and maintain a set of real-valued convolution filters throughout the training process. First, approximate filters are computed from the real-valued filters for all convolutional layers (Lines 3-9). Note that fully-connected layers can be treated as convolutional layers [7]. The real-valued weights are discretized into two-bit weights (Line 5), and an optimal scaling factor is computed for each filter (Line 6). Then, a forward pass is run on the network inputs (Line 10), followed by a backward pass, which back-propagates errors through the network to compute gradients w.r.t. the approximate filters (Line 11). Unlike conventional CNNs, the forward and backward passes use approximate filters instead of the real-valued filters. Finally, the real-valued filters are updated with the gradients (Line 12). During inference, only the two-bit filters and the optimal scaling factors are used.

1:A minibatch of inputs and targets , current real-valued weights and learning rate
2:Updated real-valued weights and learning rate
3:for  do
4:     for  filter in layer do
5:         Compute two-bit filter from by (3)
6:         Compute optimal scaling factor by (5)
7:         Approximate filter
8:     end for
9:end for
10: // Convolutions by (1)
11:
12:
13:Update learning rate according to any learning rate scheduling function
Algorithm 1 SGD Training for Two-Bit Networks

4 Experiments

We use the well-known ImageNet dataset (ILSVRC2012) to evaluate performance of Two-Bit Networks. ImageNet is a computer vision benchmark dataset with a large number of labeled images, divided into a training set and a validation set. The training set consists of 1.2M images from 1K categories, including animals, plants, and other common items; the validation set contains 50K images.

We use Deep Residual Networks (DRNs) [8] as the CNN architecture in our experiments, which achieved state-of-the-art performance on ImageNet. Compared with other CNN architectures, DRNs can have a large number of convolutional layers (from 18 to 152), and a shortcut connection that performs linear projection exists alongside each group of two consecutive convolutional layers, in order to reformulate the layers as learning functions with reference to the layer inputs. For simplicity, we adopt ResNet-18, which has 18 convolutional layers and is the smallest model presented in their paper.

The experiments are conducted with Torch7 [9] on an NVIDIA Titan X. At training time, images are randomly cropped with 224

224 windows. We run the training algorithm for 58 epochs with batch size of 256. We use SGD with momentum of 0.9 to update parameters and batch normalization

[10] to speed up convergence. The weight decay is set to 0.0001. The learning rate starts at 0.1 and is divided by 10 at epoches 30, 40, and 50. At inference time, we use the 224224 center crops for forward propagation.

We compare our method with state-of-the-art weight compression methods, including Ternary Weight Network [5], Binary Weight Network and XNOR-Net [2]. Fig. 1 shows performance results (classification accuracy) on ImageNet. Our method outperforms the other weight compression methods, with top-5 accuracy of 84.5% and top-1 accuracy of 62.6%. We attribute the improved performance to the increased model capacity due to more efficient use of the two-bit representation for weights.

Figure 1: Validation accuracy comparison of the Two-Bit Network method and state-of-the-art weight compression methods on the ImageNet dataset
Figure 2: Memory size comparisons between Two-Bits Networks and double-precision networks for different CNN architectures.

Fig. 2 shows memory size requirement of Two-Bit Networks compared to double-precision floating point representation for three different architectures(AlexNet, ResNet-18 and VGG-19). The dramatic reduction in memory size requirement makes Two-Bit Networks suitable for deployment on embedded devices.

5 Conclusion

We have presented Two-Bit Networks for model compression of CNNs, which achieves a good tradeoff between model size and performance compared with state-of-the-art weight compression methods. Compared to the recent work on binary weights and/or activations, our method achieves higher model capacity and better performance with slightly larger memory size requirement. This work is partially supported by NSFC Grant #61672454. The Titan-X GPU used for this research was donated by the NVIDIA Corporation.

Wenjia Meng, Zonghua Gu, Ming Zhang and Zhaohui Wu (College of Computer Science, Zhejiang University, Hangzhou, China, 310027)

E-mail: zgu@zju.edu.cn

References

  • [1] Krizhevsky, A., Sutskever, I., Hinton, G.E., "Imagenet classification with deep convolutional neural networks,", Advances in neural information processing systems. (2012) 1097 C1105.
  • [2] M. Rastegari, V. Ordonez, J. Redmon, and A. Farhadi, "XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks," CoRR, vol. abs/1603.0, 2016.
  • [3] M. Courbariaux, Y. Bengio, and J.-P. David, "BinaryConnect: Training Deep Neural Networks with binary weights during propagations," in Advances in Neural Information Processing Systems 28, 2015, pp. 3123-3131.
  • [4] M. Courbariaux and Y. Bengio, "Binary Neural Networks: Training Deep Neural Networks with Weights and Activations Constrained to +1 or -1," CoRR, vol. abs/1602.0, 2016.
  • [5] F. Li and B. Liu, "Ternary Weight Networks," CoRR, vol. abs/1605.04711, 2016.
  • [6] S. Han, J. Pool, J. Tran, and W. Dally, "Learning both Weights and Connections for Efficient Neural Network," in Advances in Neural Information Processing Systems 28, 2015, pp. 1135-1143.
  • [7]

    J. Long, E. Shelhamer, and T. Darrell, "Fully Convolutional Networks for Semantic Segmentation," in The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.

  • [8] K. He, X. Zhang, S. Ren, and J. Sun, "Deep Residual Learning for Image Recognition," CoRR, vol. abs/1512.03385, 2015.
  • [9] R. Collobert, K. Kavukcuoglu, and C. Farabet, "Torch7: A matlab-like environment for machine learning," in BigLearn, NIPS Workshop, 2011, no. EPFL-CONF-192376.
  • [10] S. Ioffe and C. Szegedy, "Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift," Proc. 32nd Int. Conf. Mach. Learn., pp. 448-456, 2015.