Local Binary Pattern Networks

03/19/2018 ∙ by Jeng-Hau Lin, et al. ∙ University of California, San Diego 0

Memory and computation efficient deep learning architec- tures are crucial to continued proliferation of machine learning capabili- ties to new platforms and systems. Binarization of operations in convo- lutional neural networks has shown promising results in reducing model size and computing efficiency. In this paper, we tackle the problem us- ing a strategy different from the existing literature by proposing local binary pattern networks or LBPNet, that is able to learn and perform binary operations in an end-to-end fashion. LBPNet1 uses local binary comparisons and random projection in place of conventional convolu- tion (or approximation of convolution) operations. These operations can be implemented efficiently on different platforms including direct hard- ware implementation. We applied LBPNet and its variants on standard benchmarks. The results are promising across benchmarks while provid- ing an important means to improve memory and speed efficiency that is particularly suited for small footprint devices and hardware accelerators.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

Convolutional Neural Networks (CNN) [15] have had a notable impact on many applications. Modern CNN architectures such as AlexNet [14], VGG [23], GoogLetNet [24], and ResNet [7] have greatly advanced the use of deep learning techniques [8]

into a wide range of computer vision applications

[4, 19]. These gains have surely benefited from the continuing advances in computing and storage capabilities of modern computing machines. Table 1 lists recognition accuracy, number of parameters, model size, and floating point operations (FLOP), for three well-known architectures [14, 23, 24]. While there have been improvements, these model sizes and computational demands primarily require the use of desktop- or server-class machines in real-world applications.

AlexNet [14] VGG16 [23] GoogLeNet [24]
Accuracy 84.7% 92.38% 93.33%
Parameters 61 million 138 million 6.8 million
Memory 233MB 526MB 26MB
FLOP 1.5 billion 3 billion 1.5 billion
Table 1:

Model size and computational requirements for three well-known CNN architectures for the classification on ImageNet.

As CNN-family models mature and take on increasingly complex pattern recognition tasks, the commensurate increase in the use of computational resources further limits their use to compute-heavy CPU and GPU platforms with sophisticated (and expensive) memory systems. By contrast, the emerging universe of embedded devices especially when used as edge-devices in distributed systems presents a much greater range of potential applications. These systems can enable new system-level services that use sophisticated in-situ learning and analysis tasks. The primary obstacle to this vision is the need for significant improvements in memory and computational efficiency of deep learning networks both in their model size as well as working set size.

Various methods have been proposed to perform network pruning [16, 5], compression [6, 11], or sparsification[18]. Impressive results have been achieved lately by using binarization of selected operations in CNNs [2, 10, 22]. At the core, these efforts seek to approximate the internal computations from floating point to binary while keeping the underlying convolution operation exact or approximate.

Figure 1: An illustration of the LBPNet architecture. The LBP operation is composed of comparison and bit-allocation, while the channel fusion is done by random projection.

In this paper, we explore an alternative using non-convolutional operations that can be executed in an architectural and hardware-friendly manner, trained in an end-to-end fashion from scratch (distinct to the previous attempts of binarizing the CNN operations). We note that this work has roots in research before the current generation of deep learning methods. Namely, the adoption of local binary patterns (LBP) [21], which uses a number of predefined sampling points that are mostly on the perimeter of a circle, to compare with the pixel value at the center. The combination of multiple logic outputs (“” if the value on a sampling point is greater than that on the center point and “” otherwise) gives rise to a surprising rich representation [25] about the underlying image patterns and has shown to be complementary to the SIFT-kind features [20]. However, LBP has been under-explored in the deep learning research community where the feature learning part in the existing deep learning models [14, 7] primarily refers to the CNN features in a hierarchy. In the past, despite some existing attempts [13], the logic operation (comparison) in LBP was not directly made into the existing CNN frameworks, due to the intrinsic difference between the convolution and comparison operations.

Here, we aim at building a hardware friendly neural network architecture by learning and executing binary operations in an end-to-end fashion. We name our algorithm local binary pattern networks (LBPNet). We note that LBPNet performs non-convolutional comparisons instead of arithmetic operations. All the binary logic operations in LPBNet are directly learned, which is in a stark distinction to previous attempts that try to either binarize CNN operations [10, 22] or to approximate LBP with convolution operations [13]

. In the current CNN frameworks, operations like max-pooling and ReLU can be made logical since no addition or multiplication operations are needed. This makes the convolution and fusion (implemented mostly by summation of channels or

convolution) to be the main computational challenge. We solve it by deriving a differentiable function to learn the binary pattern and adopt random projection for the fusion operations. Fig. 1 illustrates the overview of LBPNet. The resulting LBPNet can thus be trained end-to-end using binary operations. Results show that thus configured LBPnet achieves modest results on benchmark datasets but it is a significant improvement in the parameter size reduction gain (hundreds) and speed improvement (thousand times faster). Our experiments demonstrate the value of LBPNet in embedded system platforms to enable emerging internet of things (IoT) applications.

2 Related Works

Related work falls along three primary dimensions.

Binarization for CNN. Binarizing CNNs to reduce the model size has been an active research direction [2, 10, 22]. The main focus of [2]

is to build binary connections between the neurons. The binarized neural networks work (BNN)

[10]

successfully broke the curse of dimensionality as it relates to precision in hardware. Through binarizing both weights and activations, the model size was reduced, and the multiplication can be replaced by logic operation. Non-binary operations like batch normalization with scaling and shifting are still implemented in floating-point 

[10]

. As a result, BNN is not totally bit-wise but it intelligently moves the inter-neuron traffic to intra-neuron computation. The XNOR-Net 

[22] introduces extra scaling layer to compensate the loss of binarization, and achieves a state-of-the-art accuracy on ImageNet. Both BNNs and XNORs can be considered as the discretization of real-numbered CNNs, while the core of the two works are still based on spatial convolution.

CNN approximation for LBP operation. Recent work on local binary convolutional neural networks (LBCNN) in [13] takes an opposite direction to BNN [10]. LBCNN utilizes subtraction between pixel values together with a ReLU layer to simulate the LBP operations. The convolution between the sparse binary filters and images is actually a difference filtering, thus making LBCNN work like an edge detector. During the training, the sparse binarized difference filters are fixed, only the successive -by- convolution serving as channel fusion mechanism and the parameters in batch normalization layers are learned. However, the feature maps of LBCNN are still in floating-point numbers, resulting in significantly increased model complexity as shown in Tables 4 and 6. By contrast, LBPNet learns binary patterns and logic operations from scratch, resulting in orders of magnitude reduction in memory size and testing speed up than LBCNN.

Active or deformable convolution. Among notable line of recent work that learns local patterns are active convolution [12] and deformable convolution [3], where data dependent convolution kernels are learned. Both of these are quite different from LBPNet since they do not seek to improve the network efficiency. Our binary patterns learn the position of the sampling points in an end-to-end fashion as logic operations that do not have the addition operations whereas [3] essentially learns data-dependent convolutions.

3 Local Binary Pattern Network

An overview of the LBPNet architecture is shown in Fig. 1. The forward propagation is composed of two steps: LBP operation and channel fusion. We introduce the patterns in LBPNets and the two steps in the following sub-sections, and then move on to the engineered network structures for LBPNets.

3.1 Patterns in LBPNets

Figure 2:

(a) A traditional local binary pattern is a fixed pattern without much variety. (b)-(d) In this paper, local binary patterns are initialized using a normal distribution of positions within a given area, followed by end-to-end supervised learning. The red arrows denote pushing forces during training.

In LBPNet, there are multiple patterns defining the positions of sampling points to generate multiple output channels. Patterns are randomly initialized with a normal distribution of locations on a predefined square area, and then subsequently learned in an end-to-end supervised learning fashion. Fig. 2 (a) shows a traditional local binary pattern; there are eight sampling points denoted by green circles, surrounding a pivot point in the meshed star at the center of pattern; Fig. 2(b)-(d) shows a learnable pattern with eight sampling points in green, and a pivot point as a star at the center. Different sizes of the green circle stand for the bit position of the true-false outcome on the output magnitude. We allocate the comparison outcome of the largest green circle to the most significant bit of the output pixel, the second largest to the 2nd bit, and so on. The red arrows represents the driving forces that can push the sampling points to better positions to minimize the classification error. We describe the details of forward propagation in the following two sub-sections.

3.2 LBP Operation

(a) LBP operations for channel ch.a; (b) LBP operations for channel ch.b.
Figure 3: An example of LBP operation on multiple input channels. Each local binary pattern has 4 sampling points restricted within -by- areas.

First, LBPNet samples pixels from incoming images and compares the sampled pixel value with the center sampled point, the pivot. If the sampled pixel value is larger than that of the center one, the output is a bit “”; otherwise, the output is set to “.” Next, we allocate the output bits to a number’s different binary digits based on a predefined ordering. The number of sampling points defines the number of bits of an output pixel on a feature map. Then we slide the local binary pattern to the next location and perform the aforementioned steps until a feature map is generated. In most case, the incoming image has multiple channels, hence we perform the aforementioned comparison on every input channel.

Fig. 3 shows a snapshot of the LBP operations. Given two input channels, ch.a and ch.b, we perform the LBP operation on each channel with different kernel patterns. The two 4-bit response binary numbers of the intermediate output are shown on the bottom. For clarity, we use green dashed arrows to mark where the pixel are sampled, and list the comparison equations under each bit. A logical problem has emerged: we need a channel fusion mechanism to avoid the explosion of the channels.

3.3 Channel Fusion with Random Projection

We use random projection [1] as a dimension-reducing and distance-preserving process to select output bits among intermediate channels for the concerned output channel as shown in Fig. 4. The random projection is implemented with a predefined mapping table for each output channel. The projection map is fixed upon initialization. All output pixels on the same output channel share the same mapping. In fact, random projection not only solves the channel fusion with a bit-wise operation, but also simplifies the computation, because we do not have to compare all sampling points with the pivots. For example, in Fig. 4, the two pink arrows from intermediate ch.a, and the two yellow arrows from intermediate ch.b bring the four bits for the composition of an output pixel. Only the MSB and LSB on ch.a and the middle two bits on ch.b need to be computed. If the output pixel is -bit, for each output pixel, there will be comparisons needed, which is irrelevant with the number of input channels. The more input channels simply bring the more combinations of channels in a random projection table.

Figure 4: An example of LBP channel fusing. The two 4-bit responses from Fig. 3 are fused together and assigned to pixel “” on the output feature map.

Throughout the forward propagation, there is no resource demanding multiplication or addition. Only comparison and memory access are used. Therefore, the design of LBPNets is efficient in the aspects of both software and hardware.

3.4 Network structures for LBPNet

Figure 5: Basic LBPNet blocks. (a) the well-known building block of residual networks. (b) The transition-type building block, in which a -by- convolutional layer is used for the channel fusion of a preceding LBP layer. (c) The multiplication and accumulation (MAC) free building block for LBPNet.

The network structure of LBPNet must be carefully designed. Owing to the nature of comparison, the outcome of a LBP layer is very similar to the outlines in the input image. In other words, our LBP layer is good at extracting high frequency components in the spatial domain, but relatively weak at understanding low frequency components. Therefore, we use a residual-like structure to compensate this weakness of LBPNet.

Fig. 5 shows three kinds of residual-net-like building blocks. Fig. 5 (a) is the typical building block for residual networks. The convolutional kernels learn to obtain the residual of the output after the addition. Our first attempt is to introduce the LBP layer into this block as shown in Fig. 5 (b), in which we utilize a -by- convolution to learn a better combination of LBP feature maps. However, the convolution incurs too many multiplication and accumulation operations especially when the LBP kernels increases. Then, we combine LBP operation with a random projection as mentioned in previous sections. Because the pixels in the LBP output feature maps are always positive, we use a shifted rectified linear layer (shifted-ReLU) to increase nonlinearities. The shifted-ReLU truncates any magnitudes below the half the the maximum of the LBP output. More specifically, if a pattern has sampling points, the shifted-ReLU is defined as Eq. 1.

(1)

As mentioned earlier, the low-frequency components can be lost when the information is passing through several LBP layers. To make the block totally MAC-free, we use a joint operation to cascade the input tensor of the block and the output tensor of the shifted-ReLU along the channel dimension. Although the jointing of tensors brings back the risk of channel explosion, the number of channels can be controlled if we carefully design the number of LBP kernels.

3.5 Hardware Benefits

Device Name #bits #gates Energy (J)
Adder 4 20 3E-14
32 160 9E-13
Multiplier 32 144 3.7E-12
Comparator 4 11 3E-14
Table 2: The number of logic gates for arithmetic units. Energy use data for technology node: nm.

LBPNet saves in hardware cost by avoiding the convolution operations. Table 2 lists the reference numbers of logic gates of the concerned arithmetic units. A ripple-carry full-adder requires gates for each bit. A 32-bit multiplier includes a data-path logic and a control logic. Because there are too many feasible implementations of the control logic circuits, we conservatively use an open range to express the sense of the hardware expense. The comparison can be made with pure combinational logic circuit of gates, which also means only the infinitesimal internal gate delays dominate the computation latency. Comparison is not only cheap in terms of its gate count but also fast due to a lack of sequential logic inside. Slight difference on numbers of logic gates may apply if different synthesis tools or manufacturers are chosen. Assuming the capability of a LBP layer is as strong as a convolutional layer in terms of classification accuracies. Replacing the convolution operations with comparison directly gives us a X saving of hardware cost.

Another important benefit is energy saving. The energy demand for each arithmetic device has been shown in [9]. If we replace all convolution operations with comparisons, the energy consumption is reduced by X.

4 Backward Propagation of LBPNet

To train LBPNets with gradient-based optimization methods, we need to tackle two problems: 1). The non-differentiability of comparison; and 2). the lack of a source force to push the sampling points in a pattern.

4.1 Differentiability

Figure 6: We approximate the comparison operation with a scaled and shifted hyperbolic tangent function. On the left sub-figure, the orange line denotes the comparison function, and the blue curve is the differentiable approximation. The right sub-figure shows the derivative of the approximation for convex optimization. The scaling parameter is in this figure.

The first problem can be solved if we approximate the comparison operation shown in Eq. 2 with a shifted and scaled hyperbolic tangent function as shown in Eq. 3.

(2)
(3)

where is the scaling parameters to accommodate the number of sampling points from a preceding LBP layer. The hyperbolic tangent function is differentiable and has a simple closed-form for the implementation, as depicted in Fig. 6.

4.2 Deformation with Optical Flow Theory

To deform the local binary patterns, we resort to the concept from optical flow theory. Assuming the image content in the same class share the same features, even though there are certain minor shape transformations, chrominance variations or different view angles, the optical flow on these images should share similarities with each others.

(4)

Eq. 4 shows the optical flow theory, where is the pixel value, a.k.a luminance, and represent the two orthogonal components of the optical flow among the same or similar image content. The LHS of optical flow theory can be interpreted as a dot-product of image gradient and optical flow, and this product is the inverse the derivative of luminance versus time across different images.

To minimize the difference between images in the same class is equivalent to extract similar features of image in the same class for classification. However, both the direction and magnitude of the optical flow underlying the dataset are unknown. The minimization of a dot-product cannot be done by changing the image gradient to be orthogonal with the optical flow. Therefore, the only feasible path to minimize the magnitude of the RHS is to minimize the image gradient. Please note the sampled image gradient can be changed by deforming the apertures, which are the sampling points of local binary patterns.

When applying calculus chain rule on the cost of LBPNet with regard to the position of each sampling point, one can easily reach a conclusion that the last term of the chain rule is the image gradient. Since the sampled pixel value is the same as the pixed value on the image, the gradient of sampled value with regard to the sampling location on a pattern is equivalent to the image gradient on the incoming image. Eq. 

5 shows the gradient from the output loss through a fully-connected layer with weights, , toward the image gradient.

(5)

where is the backward propagated error,

is the derivative of activation function, and

is the gradient of Eq. 3 also plotted in Fig.6.

Figure 7: A set of 6 Gaussian peaks, and the center one is moving toward right-bottom slightly. (a) the previous contour map and image gradient; (b) the current contour map and image gradient; (c) a side-view of the Gaussian peaks; (d) the optical flow of the highest Gaussian peak.

Fig. 7 illustrates an example of optical flow theory. In this figure, the highest peak is moving toward the right-bottom, and the image gradients are different. The calculation of optical flow requires heavy linear algebraic manipulation, and the result is shown in sub-figure (d). The optical flow reveals the motion of the highest peak and is often used for object tracking. Utilizing Eq. 5

to train LBPNet is to calculate the vector sums over the image gradients. After the update, the sampling points (apertures) will move downhill or uphill depending on the error

in Eq. 5. Without computing the optical flow, the sampling points are still pushed to a position with minimal average image gradient and a minimum absolute value of the RHS in Eq. 4 is guaranteed.

5 Experiments

In this section, we conduct a series of experiments on three datasets: MNIST, SVHN, and CIFAR-10 to verify the capability of LBPNet. Here is the description of the datasets and setups.

5.1 Experiment Setup

Images in the MNIST dataset are hand-written numbers from to in -by- gray scale bitmap format. The dataset is composed with a training set of examples and a test set of

examples. The manuscripts were written by both staff and students. Although most of the images can be easily recognized and classified, there are still a portion of sloppy images inside MNIST.

SVHN is an image dataset of house numbers. Although cropped, images in SVHN include some distracting numbers around the labeled number in the middle of the image. The distracting parts increase the difficulty of classifying the printed numbers. There are training examples and test examples in SVHN.

CIFAR-10 is composed of daily objects, such as airplanes, cats, dogs, and trucks. The size of images is in -by- and has channels of RGB colors. The training set includes examples, and the test set includes examples as well.

In all of the experiments, we use all training examples to train LBPNets, and directly validate on test sets. To avoid peeping, the validation errors are not employed in the backward propagation. There are no data augmentations used in the experiments. Because CIFAR-10 is relatively harder than the other two datasets, we convert RGB channels into YUV channels to improve the classification accuracy.

Figure 8: The MLP block that is shared by the variants of our LBPNet models, which is made with two fully-connected layers of and neurons. Besides the nonlinearities, there are two Dropout layers with possibility and one batch-normalization layer.

The goal of the experiments is to compare LBPNet with convolution-based methods. We implement two versions of LBPNet using the two building blocks shown in Fig. 5 (b) and (c). For the remaining parts of this paper, we call the LBPNet using -by- convolution as the channel fusion mechanism LBPNet(x) (has convolution in the fusion part), and the version of LBPNet utilizing random projection LBPNet(RDP) (totally convolution-free). The number of sampling points in a pattern is set to , and the area size for the pattern to deform is -by-

. LBPNet also has an additional multilayer perceptron (MLP) block, which is a

-layer fully-connected as shown in Fig. 8. The MLP block’s performance without any convolutional layers or LBP layers on the three datasets is shown in Table 456. The model size and speed of the MLP block are excluded in the comparisons since all models have an MLP block.

5.2 Experimental Results

Arithmetic #cycles
32-32bit Multiplication 4
32-1bit Multiplication 1
1-1bit Multiplication 1
32bit Addition 1
4bit Comparison 1
Table 3: The cycle count of different arithmetics involved in the experiments. For the corresponding hardware description, please refer to Sec. 3.5.

To understand the capability of LBPNet when compared with existing convolution based methods, we build two feed-forward streamline CNNs as our baseline. The basic block of the CNNs contains a spatial convolution layer (Conv) followed by a batch normalization layer (BatchNorm) and a rectified linear layer (ReLU). For MNIST, the baseline is a 4-layer CNN with kernel number of --- before the classifier. The baseline CNN for SVHN and CIFAR-10 has 10 layers (---------) before the classifier because the datasets are larger and include more complicated content.

In addition to the baseline CNNs, we also build three shallow CNNs subject to comparable memory sizes of LBPNets(RDP) to demonstrate the efficiency of LBPNet. We call the shallow CNNs as CNN(lite). For MNIST, the CNN(lite) model contains only one convolutional layer with kernels. The CNN(lite) model for SVHN has convolutional layers (-). The CNN(lite) model for CIFAR-10 also has convolutional layers (-).

In the BNN [10] paper, the classification on MNIST is done with a binarized multilayer perceptron network (MLP). We adopt the binarized convolutional neural network (BCNN) in [10] for SVHN to perform the classification and re-produce the same accuracy as shown in [17] on MNIST.

The learning curves of LBPNets on the three datasets are plotted in Fig. 9, and the error rates together with model sizes and speedups are described as follows.

Figure 9: Error curves on benchmark datasets. (a) test errors on MNIST; (b) test errors on SVHN; (c) test errors on CIFAR-10

MNIST.Table 4 shows the experimental results of LBPNet on MNIST together with the baseline and previous works. We list the classification error rates, model size, latency of the inference, and the speedup compared with the baseline CNN. Please note the calculation of latency in cycles is made with an assumption that no SIMD parallelism and pipelining optimization is applied. Because we need to understand the total number of computations in every network but both floating-point and binary arithmetics are involved, we cannot use FLOPs as a measure. Therefore, we adopt typical cycle counts shown in Table 3 as the measure of latencies. For the calculation of model size, we exclude the MLP blocks and count the required memory for necessary variables to focus on the comparison between the intrinsic operations in CNNs and LBPNets, respectively the convolution and the LBP operation.

Error Size Latency Speedup
(Bytes) (cycles)
MLP Block 24.22% - - -
CNN (4-layer) 0.29% 7.00M 3.10G 1X
CNN (lite) 0.97% 1.6K 1.843M 1682.67X
BCNN 0.47% 1.89M 0.306G 10.13X
LBCNN 0.49% 12.18M 8.776G 0.35X
LBPNet (this work)
LBPNet (1x1) 0.51% 1.91M 44.851M 69.15X
LBPNet (RDP) 0.50% 1.59K 2.609M 1188.70X
Table 4: The performance of LBPNet on MNIST.

The baseline CNN achieves the lowest classification error rate %, but using a significantly larger model. The BCNN possesses a decent memory reduction and speedup while maintaining the classification. While LBCNN claimed its saving in memory footprint, to achieve % error rate, layers of LBCNN basic blocks are used. As a result, LBCNN loses memory gain and the speedup. The -layer LBPNet(1x1) with LBP kernels and -by- convolutional kernels achieves %. The -layer LBPNet(RDP) with ---- LBP kernels reach % error rate. Although LBPNet’s performance is slightly inferior, the model size of LBPNet(RDP) is reduced to KB and the speedup is X faster than the baseline CNN. Even BNN cannot be on par with such a huge memory reduction and speedup. The worst error rate is resulted from CNN(lite). Although we can shrink the CNN model down to the same memory size of LBPNet(RDP), the classification error of CNN(lite) is greatly sacrificed.

Error Size Latency Speedup
(Bytes) (cycles)
MLP Block 77.78% - - -
CNN (10-layer) 6.80% 31.19M 1.426G 1X
CNN (lite) 69.14% 2.80K 1.576M 904.72X
BCNN 2.53% 1.89M 0.312G 4.58X
LBCNN 5.50% 6.70M 7.098G 0.20X
LBPNet (this work)
LBPNet (1x1) 8.33% 1.51M 91.750M 155.40X
LBPNet (RDP) 8.70% 2.79K 4.575M 311.63X
Table 5: The performance of LBPNet on SVHN.

SVHN. Table 5 shows the experimental results of LBPNet on SVHN together with the baseline and previous works. BCNN outperforms our baseline and achieves % with smaller memory footprint and higher speed. The LBCNN for SVHN dataset used layers, and each layer contains only binary kernels and -by- kernels. As a result, LBCNN roughly cut the model size and the latency into a half of the LBCNN designed for MNIST. The -layer LBPNet(1x1) with LBP kernels and -by- convolutional kernels achieve %, which is close to our baseline CNN’s %. The convolution-free LBPNet(RDP) for SVHN is built with layers of LBP basic blocks, ----, as shown in Fig. 5. Compared with CNN(lite)’s high error rate, the learning of LBPNet’s sampling point positions is proven to be effective and economical.

Error Size Latency Speedup
(Bytes) (cycles)
MLP Block 65.91% - - -
CNN (10-layer) 8.39% 31.19M 1.426G 1X
CNN (lite) 53.20% 1.90K 1.355M 1052.43X
BCNN 10.15% 7.19M 4.872G 0.29X
LBCNN 7.01% 211.93M 193.894G 0.01X
LBPNet (this work)
LBPNet (1x1) 22.94% 5.35M 48.538M 29.37X
LBPNet (RDP) 25.90% 1.99K 3.265M 436.75X
Table 6: The performance of LBPNet on CIFAR-10.

CIFAR-10. Table 6 shows the experimental results of LBPNet on CIFAR-10 together with the baseline and previous works. The 10-layer baseline CNN achieves % error rate with model size MB. BCNN achieved a slightly higher error rate but maintained a decent memory reduction. Due to the relatively large number of binary kernels, the batch normalization layer in BCNN’s basic blocks still needs to perform floating-point multiplications hence drags down the speed up. LBCNN uses basic blocks to achieve the stat-of-the-art accuracy % error rate. Once again, the large model of the 50-layer LBCNN with binary kernels and -by- floating number kernels has no memory gain and speedup compared with the baseline. The -layer LBPNet(1x1) using LBP kernels and -by- kernels achieves % error rate, and the -layer LBPN(RDP) with ---- LBP kernels achieves %. Reducing the CNN model size to KB, we obtain the CNN(lite) for CIFAR-10, but the performance of CNN(lite) is seriously degraded to %.

5.3 Discussion

Figure 10: The transition of feature maps on the first two LBP layers.(a) an input cat image with the corresponding feature maps; (b) an input airplane image with its corresponding feature maps. The vertical bars and numbers along subfigures show the response values.

The learning curves of LBPNets are plotted in Fig. 9. We also plot the baseline CNNs’ error rates in blue as a reference. Throughout the three datasets, the LBPNet(1x1)’s learning curves oscillate most because a slight shift of the local binary pattern will require the following -by- convolutional layer to change a lot to accommodate the intermediate feature maps. This is not a big issue as the trend of learning still functions correctly towards a lower error rate state.

Fig. 10 shows two examples of the learning transition of feature maps on CIFAR-10. The left hand side of Fig. 10 is to learn a cat on the ground. The right hand side of Fig. 10

is to learn a airplane flying in the sky. As we can see the transition from Epoch 1 to Epoch 300, the features become more clear and recognizable. The cat’s head and back are enhanced, and the outline of the airplane is promoted after the learning of local binary patterns.

On CIFAR-10, the main reason that stops LBPNets from getting a lower error rate is due to the discontinuity of comparison. Unlike MNIST and SVHN having distinct strokes and outlines, CIFAR-10 is composed with daily objects, which often have gradient transitions and obscure boundaries. LBPNets experience a hard time while extracting edges among the images in CIFAR-10, and hence the classification results are not as good as other previous works. LBCNN can overcome the lack of edges because it is not a genuine bit-wise operation. LBCNN binarized and sparsified the convolutional kernels to make LBP-like, but it still took advantage of floating point arithmetic and floating point feature maps during convolving.

In summary, the learning of local binary patterns results in an unprecedentedly efficient model since, to the best of our knowledge, there is no compression/discretization of CNN can achieve the KB level model size while maintaining the an error rate as low as %, %, and % for MNIST, SVHN and CIFAR-10, respectively.

6 Conclusion and Future Works

We have built a convolution-free, end-to-end, and bitwise LBPNet from scratch for deep learning and verified its effectiveness on MNIST, SVHN, and CIFAR-10 with orders of magnitude speedup (hundred times) in testing and model size reduction (thousand times), when compared with the baseline and the binarized CNNs. The improvement in both size and speed is achieved due to our convolution-free design with logic bitwise operations that are learned directly from scratch. Both the memory footprints and computation latencies of LBPNet and previous works are listed. LBPNet points to a promising direction for building new generation hardware-friendly deep learning algorithms to perform computation on the edge.

Acknowledgement This work is supported in part by CRAFT project (DARPA Award HR0011-16-C-0037), NSF IIS-1618477, NSF IIS-1717431, and a research project sponsored by Samsung Research America. We thank Zeyu Chen for the initial help in this project.

References

  • [1] Bingham, E., Mannila, H.: Random projection in dimensionality reduction: applications to image and text data. In: ACM SIGKDD (2001)
  • [2] Courbariaux, M., Bengio, Y., David, J.P.: BinaryConnect: Training Deep Neural Networks with binary weights during propagations. Advances in Neural Information Processing Systems (NIPS) pp. 3123–3131 (2015)
  • [3] Dai, J., Qi, H., Xiong, Y., Li, Y., Zhang, G., Hu, H., Wei, Y.: Deformable convolutional networks. In: ICCV (2017)
  • [4] Girshick, R., Donahue, J., Darrell, T., Malik, J.: Rich Feature Hierarchies for Accurate Object Detection and Semantic Segmentation. In: CVPR (2014)
  • [5] Guo, Y., Yao, A., Chen, Y.: Dynamic network surgery for efficient dnns. In: NIPS (2016)
  • [6] Han, S., Mao, H., Dally, W.J.: Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In: ICLR (2015)
  • [7] He, K., Zhang, X., Ren, S., Sun, J.: Deep Residual Learning for Image Recognition (2016)
  • [8] Hinton, G.E., Osindero, S., Teh, Y.W.: A fast learning algorithm for deep belief nets. Neural computation 18, 1527–1554 (2006)
  • [9] Horowitz, M.: 1.1 computing’s energy problem (and what we can do about it). In: Solid-State Circuits Conference Digest of Technical Papers (ISSCC), 2014 IEEE International. pp. 10–14. IEEE (2014)
  • [10] Hubara, I., Courbariaux, M., Soudry, D., El-Yaniv, R., Bengio, Y.: Binarized neural networks. In: NIPS. pp. 4107–4115 (2016)
  • [11] Iandola, F.N., Han, S., Moskewicz, M.W., Ashraf, K., Dally, W.J., Keutzer, K.: Squeezenet: Alexnet-level accuracy with 50x fewer parameters and¡ 0.5 mb model size. arXiv preprint arXiv:1602.07360 (2016)
  • [12] Jeon, Y., Kim, J.: Active convolution: Learning the shape of convolution for image classification. In: CVPR (2017)
  • [13] Juefei-Xu, F., Boddeti, V.N., Savvides, M.: Local binary convolutional neural networks. In: CVPR (2017)
  • [14] Krizhevsky, A., Sutskever, I., Hinton, G.E.: Imagenet classification with deep convolutional neural networks. In: NIPS. pp. 1097–1105 (2012)
  • [15]

    LeCun, Y., Boser, B., Denker, J.S., Henderson, D., Howard, R.E., Hubbard, W., Jackel, L.D.: Backpropagation applied to handwritten zip code recognition. Neural computation 1(4), 541–551 (1989)

  • [16] LeCun, Y., Denker, J.S., Solla, S.A., Howard, R.E., Jackel, L.D.: Optimal brain damage. In: NIPS (1989)
  • [17] Lin, J.H., Xing, T., Zhao, R., Srivastava, M., Zhang, Z., Tu, Z., Gupta, R.: Binarized convolutional neural networks with separable filters for efficient hardware acceleration. Computer Vision and Pattern Recognition Workshop (CVPRW) (2017)
  • [18] Liu, B., Wang, M., Foroosh, H., Tappen, M., Pensky, M.: Sparse convolutional neural networks. In: CVPR (2015)
  • [19] Long, J., Shelhamer, E., Darrell, T.: Fully convolutional networks for semantic segmentation. CVPR (2015)
  • [20] Lowe, D.G.: Distinctive image features from scale-invariant keypoints. International journal of computer vision 60(2), 91–110 (2004)
  • [21] Ojala, T., Pietikäinen, M., Harwood, D.: A comparative study of texture measures with classification based on featured distributions. Pattern recognition 29(1), 51–59 (1996)
  • [22] Rastegari, M., Ordonez, V., Redmon, J., Farhadi, A.: XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks. In: ECCV (2016)
  • [23] Simonyan, K., Zisserman, A.: Very deep convolutional networks for large-scale image recognition. In: ICLR (2015)
  • [24] Szegedy, C., Liu, W., Jia, Y., Sermanet, P., Reed, S., Anguelov, D., Erhan, D., Vanhoucke, V., Rabinovich, A.: Going deeper with convolutions. In: CVPR (2015)
  • [25] Wang, X., Han, T.X., Yan, S.: An hog-lbp human detector with partial occlusion handling. In: CVPR (2009)