Towards Accurate Binary Convolutional Neural Network

Introduction

Convolutional neural networks (CNNs) have achieved state-of-the-art results on real-world applications such as image classification (He et al., 2016) and object detection (Ren et al., 2015), with the best results obtained with large models and sufficient computation resources. Concurrent to these progresses, the deployment of CNNs on mobile devices for consumer applications is gaining more and more attention, due to the widespread commercial value and the exciting prospect.

On mobile applications, it is typically assumed that training is performed on the server and test or inference is executed on the mobile devices (Courbariaux et al., 2016; Esser et al., 2016). In the training phase, GPUs enabled substantial breakthroughs because of their greater computational speed. In the test phase, however, GPUs are usually too expensive to deploy. Thus improving the test-time performance and reducing hardware costs are likely to be crucial for further progress, as mobile applications usually require real-time, low power consumption and fully embeddable. As a result, there is much interest in research and development of dedicated hardware for deep neural networks (DNNs). Binary neural networks (BNNs) (Courbariaux et al., 2016; Rastegari et al., 2016), i.e., neural networks with weights and perhaps activations constrained to only two possible values (e.g., -1 or +1), would bring great benefits to specialized DNN hardware for three major reasons: (1) the binary weights/activations reduce memory usage and model size 32 times compared to single-precision version; (2) if weights are binary, then most multiply-accumulate operations can be replaced by simple accumulations, which is beneficial because multipliers are the most space and power-hungry components of the digital implementation of neural networks; (3) furthermore, if both activations and weights are binary, the multiply-accumulations can be replaced by the bitwise operations: xnor and bitcount Courbariaux et al. (2016). This could have a big impact on dedicated deep learning hardware. For instance, a 32-bit floating point multiplier costs about 200 Xilinx FPGA slices (Govindu et al., 2004), whereas a 1-bit xnor gate only costs a single slice. Semiconductor manufacturers like IBM (Esser et al., 2016) and Intel (Venkatesh et al., 2016) have been involved in the research and development of related chips.

However, binarization usually cause severe prediction accuracy degradation, especially on complex tasks such as classification on ImageNet dataset. To take a closer look, Rastegari et al. (2016) shows that binarizing weights causes the accuracy of Resnet-18 drops from 69.3% to 60.8% on ImageNet dataset. If further binarize activations, the accuracy drops to 51.2%. Similar phenomenon can also be found in literatures such as (Hubara et al., 2016). Clearly there is a considerable gap between the accuracy of a full-precision model and a binary model.

This paper proposes a novel scheme for binarizing CNNs, which aims to alleviate, or even eliminate the accuracy degradation, while still significantly reducing inference time, resource requirement and power consumption. The paper makes the following major contributions.

We approximate full-precision weights with the linear combination of multiple binary weight bases. The weights values of CNNs are constrained to $\{-1,+1\}$, which means convolutions can be implemented by only addition and subtraction (without multiplication), or bitwise operation when activations are binary as well. We demonstrate that 3$\sim$5 binary weight bases are adequate to well approximate the full-precision weights.

We introduce multiple binary activations. Previous works have shown that the quantization of activations, especially binarization, is more difficult than that of weights (Cai et al., 2017; Courbariaux et al., 2016). By employing five binary activations, we have been able to reduce the Top-1 and Top-5 accuracy degradation caused by binarization to around 5% on ImageNet compared to the full precision counterpart.

It is worth noting that the multiple binary weight bases/activations scheme is preferable to the fixed-point quantization in previous works. In those fixed-point quantized networks one still needs to employ arithmetic operations, such as multiplication and addition, on fixed-point values. Even though faster than floating point, they still require relatively complex logic and can consume a lot of power. Detailed discussions can be found in Section 5.2.

Ideally, combining more binary weight bases and activations always leads to better accuracy and will eventually get very close to that of full-precision networks. We verify this on ImageNet using Resnet network topology. This is the first time a binary neural network achieves prediction accuracy comparable to its full-precision counterpart on ImageNet.

Related work

Quantized Neural Networks: High precision parameters are not very necessary to reach high performance in deep neural networks. Recent research efforts (e.g., (Hubara et al., 2016)) have considerably reduced a large amounts of memory requirement and computation complexity by using low bitwidth weights and activations. Zhou et al. (2016) further generalized these schemes and proposed to train CNNs with low bitwidth gradients. By performing the quantization after network training or using the “straight-through estimator (STE)" (Bengio et al., 2013), these works avoided the issues of non-differentiable optimization. While some of these methods have produced good results on datasets such as CIFAR-10 and SVHN, none has produced low precision networks competitive with full-precision models on large-scale classification tasks, such as ImageNet. In fact, (Zhou et al., 2016) and (Hubara et al., 2016) experiment with different combinations of bitwidth for weights and activations, and show that the performance of their highly quantized networks deteriorates rapidly when the weights and activations are quantized to less than 4-bit numbers. Cai et al. (2017) enhance the performance of a low bitwidth model by addressing the gradient mismatch problem, nevertheless there is still much room for improvement.

Binarized Neural Networks: The binary representation for deep models is not a new topic. At the emergence of artificial neural networks, inspired biologically, the unit step function has been used as the activation function (Toms, 1990). It is known that binary activation can use spiking response for event-based computation and communication (consuming energy only when necessary) and therefore is energy-efficient (Esser et al., 2016). Recently, Courbariaux et al. (2016) introduce Binarized-Neural-Networks (BNNs), neural networks with binary weights and activations at run-time. Different from their work, Rastegari et al. (2016) introduce simple, efficient, and accurate approximations to CNNs by binarizing the weights and even the intermediate representations in CNNs. All these works drastically reduce memory consumption, and replace most arithmetic operations with bitwise operations, which potentially lead to a substantial increase in power efficiency.

In all above mentioned works, binarization significantly reduces accuracy. Our experimental results on ImageNet show that we are close to filling the gap between the accuracy of a binary model and its full-precision counterpart. We relied on the idea of finding the best approximation of full-precision convolution using multiple binary operations, and employing multiple binary activations to allow more information passing through.

Binarization methods

In this section, we detail our binarization method, which is termed ABC-Net (Accurate-Binary-Convolutional) for convenience. Bear in mind that during training, the real-valued weights are reserved and updated at every epoch, while in test-time only binary weights are used in convolution.

Consider a $L$-layer CNN architecture. Without loss of generality, we assume the weights of each convolutional layer are tensors of dimension $(w,h,c_{\rm in},c_{\rm out})$, which represents filter width, filter height, input-channel and output-channel respectively. We propose two variations of binarization method for weights at each layer: 1) approximate weights as a whole and 2) approximate weights channel-wise.

where ${\bm{B}}=[{\rm vec}({\bm{B}}_{1}),{\rm vec}({\bm{B}}_{2}),\cdots,{\rm vec}({\bm{B}}_{M})]$, ${\bm{w}}={\rm vec}({\bm{W}})$ and ${\bm{\alpha}}=[\alpha_{1},\alpha_{2},\cdots,\alpha_{M}]^{\rm T}$. Here the notation ${\rm vec}(\cdot)$ refers to vectorization.

Although a local minimum solution to (1) can be obtained by numerical methods, one could not backpropagate through it to update the real-value weight filter ${\bm{W}}$. To address this issue, assuming the mean and standard deviation of ${\bm{W}}$ are ${\rm mean}({\bm{W}})$ and ${\rm std}({\bm{W}})$ respectively, we fix ${\bm{B}}_{i}$’s as follows:

where ${\bm{\bar{W}}}={\bm{W}}-{\rm mean}({\bm{W}}),$ and $u_{i}$ is a shift parameter. For example, one can choose $u_{i}$’s to be $u_{i}=-1+(i-1)\frac{2}{M-1},i=1,2,\cdots,M,$ to shift evenly over the range $\left[-{\rm std}({\bm{W}}),{\rm std}({\bm{W}})\right]$, or leave it to be trained by the network. This is based on the observation that the full-precision weights tend to have a symmetric, non-sparse distribution, which is close to Gaussian. To gain more intuition and illustrate the approximation effectiveness, an example is visualized in Section S2 of the supplementary material.

With ${\bm{B}}_{i}$’s chosen, (1) becomes a linear regression problem

in which ${\bm{B}}_{i}$’s serve as the bases in the design/dictionary matrix. We can then back-propagate through ${\bm{B}}_{i}$’s using the “straight-through estimator” (STE) (Bengio et al., 2013). Assume $c$ as the cost function, ${\bm{A}}$ and ${\bm{O}}$ as the input and output tensor of a convolution respectively, the forward and backward approach of an approximated convolution during training can be computed as follows:

In test-time, only (6) is required. The block structure of this approximated convolution layer is shown on the left side in Figure 1. With suitable hardwares and appropriate implementations, the convolution can be efficiently computed. For example, since the weight values are binary, we can implement the convolution with additions and subtractions (thus without multiplications). Furthermore, if the input ${\bm{A}}$ is binary as well, we can implement the convolution with bitwise operations: xnor and bitcount (Rastegari et al., 2016). Note that the convolution with each binary filter can be computed in parallel.

1.2 Approximate weights channel-wise

Compared to weights approximation as a whole, the channel-wise approach approximates weights more elaborately, however no extra cost is needed during inference. Since this approach requires more computational resources during training, we leave it as a future work and focus on the former approximation approach in this paper.

2 Multiple binary activations and bitwise convolution

As mentioned above, a convolution can be implemented without multiplications when weights are binarized. However, to utilize the bitwise operation, the activations must be binarized as well, as they are the inputs of convolutions.

Similar to the activation binarization procedure in (Zhou et al., 2016), we binarize activations after passing it through a bounded activation function $h$, which ensures $h(x)\in$. We choose the bounded rectifier as $h$. Formally, it can be defined as:

where $v$ is a shift parameter. If $v=0$, then $h_{v}$ is the clip activation function in (Zhou et al., 2016).

We constrain the binary activations to either 1 or -1. In order to transform the real-valued activation ${\bm{R}}$ into binary activation, we use the following binarization function:

Here $\circ$ denotes the Hadamard product. As can be expected, binaizing activations as above is kind of crude and leads to non-trivial losses in accuracy, as shown in Rastegari et al. (2016); Hubara et al. (2016). While it is also possible to approximate activations with linear regression, as that of weights, another critical challenge arises – unlike weights, the activations always vary in test-time inference. Luckily, this difficulty can be avoided by exploiting the statistical structure of the activations of deep networks.

Our scheme can be described as follows. First of all, to keep the distribution of activations relatively stable, we resort to batch normalization (Ioffe and Szegedy, 2015). This is a widely used normalization technique, which forces the responses of each network layer to have zero mean and unit variance. We apply this normalization before activation. Secondly, we estimate the real-value activation ${\bm{R}}$ using the linear combination of $N$ binary activations ${\bm{A}}_{1},{\bm{A}}_{2},\cdots,{\bm{A}}_{N}$ such that ${\bm{R}}\approx\beta_{1}{\bm{A}}_{1}+\beta_{2}{\bm{A}}_{2}+\cdots+\beta_{N}{\bm{A}}_{N}$, where

Different from that of weights, the parameters $\beta_{n}$’s and $v_{n}$’s ($n=1,\cdots,N$) here are both trainable, just like the scale and shift parameters in batch normalization. Without the explicit linear regression approach, $\beta_{n}$’s and $v_{n}$’s are tuned by the network itself during training and fixed in test-time. They are expected to learn and utilize the statistical features of full-precision activations.

The resulting network architecture outputs multiple binary activations ${\bm{A}}_{1},{\bm{A}}_{2},\cdots,{\bm{A}}_{N}$ and their corresponding coefficients $\beta_{1},\beta_{2},\cdots,\beta_{N}$, which allows more information passing through compared to the former one. Combining with the weight approximation, the whole convolution scheme is given by:

which suggests that it can be implemented by computing $M\times N$ bitwise convolutions in parallel. An example of the whole convolution scheme is shown in Figure 1.

3 Training algorithm

A typical block in CNN contains several different layers, which are usually in the following order: (1) Convolution, (2) Batch Normalization, (3) Activation and (4) Pooling. The batch normalization layer (Ioffe and Szegedy, 2015) normalizes the input batch by its mean and variance. The activation is an element-wise non-linear function (e.g., Sigmoid, ReLU). The pooling layer applies any type of pooling (e.g., max,min or average) on the input batch. In our experiment, we observe that applying max-pooling on binary input returns a tensor that most of its elements are equal to +1, resulting in a noticeable drop in accuracy. Similar phenomenon has been reported in Rastegari et al. (2016) as well. Therefore, we put the max-pooling layer before the batch normalization and activation.

Since our binarization scheme approximates full-precision weights, using the full-precision pre-train model serves as a perfect initialization. However, fine-tuning is always required for the weights to adapt to the new network structure. The training procedure, i.e., ABC-Net, is summarized in Section S1 of the supplementary material.

Experiment results

In this section, the proposed ABC-Net was evaluated on the ILSVRC12 ImageNet classification dataset (Deng et al., 2009), and visual perception of forest trails datasets for mobile robots (Giusti et al., 2016) in Section S6 of supplementary material.

The ImageNet dataset contains about 1.2 million high-resolution natural images for training that spans 1000 categories of objects. The validation set contains 50k images. We use Resnet ((He et al., 2016)) as network topology. The images are resized to 224x224 before fed into the network. We report our classification performance using Top-1 and Top-5 accuracies.

We first evaluate the weight approximation technique by examining the accuracy improvement for a binary model. To eliminate variables, we leave the activations being full-precision in this experiment. Table 1 shows the prediction accuracy of ABC-Net on ImageNet with different choices of $M$. For comparison, we add the results of Binary-Weights-Network (denoted ‘BWN’) reported in Rastegari et al. (2016) and the full-precision network (denoted ‘FP’). The BWN binarizes weights and leaves the activations being full-precision as we do. All results in this experiment use Resnet-18 as network topology. It can be observed that as $M$ increases, the accuracy of ABC-Net converges to its full-precision counterpart. The Top-1 gap between them reduces to only 0.9 percentage point when $M=5$, which suggests that this approach nearly eliminates the accuracy degradation caused by binarizing weights.

For interested readers, Figure S4 in section S5 of the supplementary material shows that the relationship between accuracy and $M$ appears to be linear. Also, in Section S2 of the supplementary material, a visualization of the approximated weights is provided.

1.2 Configuration space exploration

We explore the configuration space of combinations of number of weight bases and activations. Table 2 presents the results of ABC-Net with different configurations. The parameter settings for these experiments are provided in Section S4 of the supplementary material.

As balancing between multiple factors like training time and inference time, model size and accuracy is more a problem of practical trade-off, there will be no definite conclusion as which combination of ($M,N$) one should choose. In general, Table 2 shows that (1) the prediction accuracy of ABC-Net improves greatly as the number of binary activations increases, which is analogous to the weight approximation approach; (2) larger $M$ or $N$ gives better accuracy; (3) when $M=N=5$, the Top-1 gap between the accuracy of a full-precision model and a binary one reduces to around 5%. To gain a visual understanding and show the possibility of extensions to other tasks such object detection, we print the a sample of feature maps in Section S3 of supplementary material.

1.3 Comparison with the state-of-the-art

Table 3 presents a comparison between ABC-Net and several other state-of-the-art models, i.e., full-precision Resnet-18, BWN and XNOR-Net in (Rastegari et al., 2016), DoReFa-Net in (Zhou et al., 2016) and BNN in (Courbariaux et al., 2016) respectively. All comparative models use Resnet-18 as network topology. The full-precision Resnet-18 achieves 69.3% Top-1 accuracy. Although Rastegari et al. (2016)’s BWN model and DeReFa-Net perform well, it should be noted that they use full-precision and 4-bit activation respectively. Models (XNOR-Net and BNN) that used both binary weights and activations achieve much less satisfactory accuracy, and is significantly outperformed by ABC-Net with multiple binary weight bases and activations. It can be seen that ABC-Net has achieved state-of-the-art performance as a binary model.

One might argue that 5-bit width quantization scheme could reach similar accuracy as that of ABC-Net with 5 weight bases and 5 binary activations. However, the former one is less efficient and requires distinctly more hardware resource. More detailed discussions can be found in Section 5.2.

Discussion

Intuitively, the multiple binarized weight bases/activations scheme works because it allows more information passing through. Consider the case that a real value, say 1.5, is passed to a binarized function $f(x)={\rm sign}(x)$, where ${\rm sign}$ maps a positive $x$ to 1 and otherwise -1. In that case, the outputs of $f(1.5)$ is 1, which suggests that the input value is positive. Now imagine that we have two binarization function $f_{1}(x)={\rm sign}(x)$ and $f_{2}(x)={\rm sign}(x-2)$. In that case $f_{1}$ outputs 1 and $f_{2}$ outputs -1, which suggests that the input value is not only positive, but also must be smaller than 2. Clearly we see that each function contributes differently to represent the input and more information is gained from $f_{2}$ compared to the former case.

From another point of view, both coefficients ($\beta$’s) and shift parameters are expected to learn and utilize the statistical features of full-precision tensors, just like the scale and shift parameters in batch normalization. If we have more binarized weight bases/activations, the network has the capacity to approximate the full-precision one more precisely. Therefore, it can be deduced that when $M$ or $N$ is large enough, the network learns to tune itself so that the combination of $M$ weight bases or $N$ binarized activations can act like the full-precision one.

2 Advantage over the fixed-point quantization scheme

It should be noted that there are key differences between the multiple binarization scheme ($M$ binarized weight bases or $N$ binarized activations) proposed in this paper and the fixed-point quantization scheme in the previous works such as (Zhou et al., 2016; Hubara et al., 2016), though at first thought $K$-bit width quantization seems to share the same memory requirement with $K$ binarizations. Specifically, our $K$ binarized weight bases/activations is preferable to the fixed K-bit width scheme for the following reasons:

(1) The $K$ binarization scheme preserves binarization for bitwise operations. One or several bitwise operations is known to be more efficient than a fixed-point multiplication, which is a major reason that BNN/XNOR-Net was proposed.

(2) A $K$-bit width multiplier consumes more resources than $K$ 1-bit multipliers in a digital chip: it requires more than $K$ bits to store and compute, otherwise it could easily overflow/underflow. For example, if a real number is quantized to a 2-bit number, a possible choice is in range {0,1,2,4}. In this 2-bit multiplication, when both numbers are 4, it outputs $4\times 4=16$, which is not within the range. In (Zhou et al., 2016), the range of activations is constrained within , which seems to avoid this situation. However, fractional numbers do not solve this problem, severe precision deterioration will appear during the multiplication if there are no extra resources. The fact that the complexity of a multiplier is proportional to THE SQUARE of bit-widths can be found in literatures (e.g., sec 3.1.1. in (Grabbe et al., 2003)). In contrast, our $K$ binarization scheme does not have this issue – it always outputs within the range {-1,1}. The saved hardware resources can be further used for parallel computing.

(3) A binary activation can use spiking response for event-based computation and communication (consuming energy only when necessary) and therefore is energy-efficient (Esser et al., 2016). This can be employed in our scheme, but not in the fixed $K$-bit width scheme. Also, we have mentioned the fact that $K$-bit width multiplier consumes more resources than $K$ 1-bit multipliers. It is noteworthy that these resources include power.

To sum up, $K$-bit multipliers are the most space and power-hungry components of the digital implementation of DNNs. Our scheme could bring great benefits to specialized DNN hardware.

3 Further computation reduction in run-time

On specialized hardware, the following operations in our scheme can be integrated with other operations in run-time and further reduce the computation requirement.

(1) Shift operations. The existence of shift parameters seem to require extra additions/subtractions (see (2) and (8)). However, the binarization operation with a shift parameter can be implemented as a comparator where the shift parameter is the number for comparison, e.g., $H_{v}({\bm{R}})=\left\{\begin{matrix}{\bm{1}},&{\bm{R}}\geq 0.5-v;\\ \bm{-1},&{\bm{R}}<0.5-v.\end{matrix}\right.$ ($0.5-v$ is a constant), so no extra additions/subtractions are involved.

(2) Batch normalization. In run-time, a batch normalization is simply an affine function, say, ${\rm BN}({\bm{R}})=a{\bm{R}}+b$, whose scale and shift parameters $a,b$ are fixed and can be integrated with $v_{n}$’s. More specifically, a batch normalization can be integrated into a binarization operation as follow: $H_{v}({\rm BN}({\bm{R}}))=\left\{\begin{matrix}{\bm{1}},&a{\bm{R}}+b\geq 0.5-v;\\ \bm{-1},&a{\bm{R}}+b<0.5-v.\end{matrix}\right.=\left\{\begin{matrix}{\bm{1}},&{\bm{R}}\geq(0.5-v-b)/a;\\ \bm{-1},&{\bm{R}}<(0.5-v-b)/a.\end{matrix}\right.$ Therefore, there will be no extra cost for the batch normalization.

Conclusion and future work

We have introduced a novel binarization scheme for weights and activations during forward and backward propagations called ABC-Net. We have shown that it is possible to train a binary CNN with ABC-Net on ImageNet and achieve accuracy close to its full-precision counterpart. The binarization scheme proposed in this work is parallelizable and hardware friendly, and the impact of such a method on specialized hardware implementations of CNNs could be major, by replacing most multiplications in convolution with bitwise operations. The potential to speed-up the test-time inference might be very useful for real-time embedding systems. Future work includes the extension of those results to other tasks such as object detection and other models such as RNN. Also, it would be interesting to investigate using FPGA/ASIC or other customized deep learning processor (Liu et al., 2016) to implement ABC-Net at run-time.

Acknowledgement

We acknowledge Mr Jingyang Xu for helpful discussions.

References

S1 Summary of training algorithm in Section 3.3

S2 Weight approximation

In this section we explore how well the weight approximation can achieved given adequate binary weight bases (Section 3.1). To gain a visual intuition, we randomly sample a slice of weight tensor from a full-precision Resnet-18 model pretrained on ImageNet. The sliced tensor is then vectorized, and we approximate it with $M$ bases using linear regression (see (3)). The results are presented in Figure S2, where the left subfigure shows the root mean square (RMSE) for the estimated weights with increasing number of bases, and the right one shows 5 fitting results, whose choice of $M$ are respectively 1 to 5 from top to bottom. The blue line in the right subfigure draws the groundtruth weights from the full-precision pretrained model, and the red line is the estimated one. It can be observed that $M=3$ is adequate to have a rough fitting, and it gets almost perfect when $M=5$.

S3 Feature map

It is also possible to perform more complex tasks beyond classification using ABC-Net, as long as the model is built upon a CNN, such as faster RCNN for object detection, in which the classification model serves as a pre-train model. Thus, one might be interested in whether ABC-Net learns similar feature maps as its full-precision counterpart. Figure S3 shows several example image and the corresponding feature maps of these two models, from which we see that they are indeed similar. This shows the potential for ABC-Net to further generalize on more complex tasks mentioned above.

S4 Parameter settings for the experiment in Section 4.1.2

The parameters $u_{i}$’s, the initial values for $\beta_{n}$’s and $v_{n}$’s can be treated as hyperparameters. At the beginning of our exploration we randomly choose these initial values. Bit by bit we began to find certain patterns to achieve good performance: for $u_{i}$’s, usually symmetric; for $v_{n}$’s, maybe slightly shift towards the negative direction. These are based on tunings and also the observation of the full-precision distribution of weights/activations. Table S4 provides the parameter settings for the experiment in Section 4.1.2. All ABC-Net models in the experiments are trained using SGD with momentum, and the initial learning rate is set to 0.01.

S5 Relationship between accuracy and number of binary weight bases M𝑀M

Figure S4 shows that the relationship between accuracy and the number of binary weight bases $M$ appears to be linear. Note that we keep the activations being full-precision in this experiment.

S6 Application on visual perception of forest trails

A VGG-like network topology is used for visual perception of forest trails as illustrated in Figure S5.

S6.2 Experiment results on visual perception of forest trails dataset

Giusti et al. (2016) cast the forest or mountain trails perception problem for mobile robots as a image classification task based on Deep Neural Networks. The dataset is composed by 8 hours of $1920\times 1080$ 30fps video acquired by a hiker equipped with three head-mounted cameras . Each image is labelled in one of three classes: turn right, go straight, turn left. We evaluate ABC-Net against its full precision counterpart using this dataset. The classification result is shown in Table S5 by fixing both number of weight bases $M$ and activation bases $N$ to be 5.