Improving Efficiency in Convolutional Neural Network with Multilinear Filters

09/28/2017 ∙ by Dat Thanh Tran, et al. ∙ Tampereen teknillinen yliopisto Aarhus Universitet 0

The excellent performance of deep neural networks has enabled us to solve several automatization problems, opening an era of autonomous devices. However, current deep net architectures are heavy with millions of parameters and require billions of floating point operations. Several works have been developed to compress a pre-trained deep network to reduce memory footprint and, possibly, computation. Instead of compressing a pre-trained network, in this work, we propose a generic neural network layer structure employing multilinear projection as the primary feature extractor. The proposed architecture requires several times less memory as compared to the traditional Convolutional Neural Networks (CNN), while inherits the similar design principles of a CNN. In addition, the proposed architecture is equipped with two computation schemes that enable computation reduction or scalability. Experimental results show the effectiveness of our compact projection that outperforms traditional CNN, while requiring far fewer parameters.



There are no comments yet.


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.

I Introduction

In recent years, deep neural network architectures have excelled in several application domains, ranging from machine vision [1, 2, 3]

, natural language processing

[4, 5] to biomedical [6, 7] and financial data analysis [8, 9]

. Of those important developments, Convolutional Neural Network (CNN) has evolved as a main workhorse in solving computer vision tasks nowadays. The architecture was originally developed in the 1990s for handwritten character recognition using only two convolutional layers

[10]. Over the years, with the development of Graphical Processing Units (GPUs) and efficient implementation of convolution operation, the depth of CNNs has been increased to tackle more complicated problems. Nowadays, prominent architectures such as Residual Network (ResNet) [11] or Google Inception [12] with hundreds of layers have become saturated. Researchers started to wonder whether millions of parameters are essential to achieve such performance. In order to extend the benefit of such deep nets to embedded devices with limited computation power and memory, recent works have focused on reducing the memory footprint and computation of a pre-trained network, i.e. they apply network compression in the post-training stage. In fact, recent works have shown that traditional network architectures such as Alexnet, VGG or Inception are highly redundant structures [13, 14, 15, 16, 17, 18, 19, 20, 21, 22]. For example, in [13]

a simple heuristic based on magnitude of the weights was employed to eliminate the connections in a pre-trained network, which achieved considerable amount of compression without hurting the performance much. Additionally, representing network parameters with low bitwidth numbers, like in

[23, 24, 25], has shown that the performance of a 32-bit network can be closely retained with only 4-bit representations. It should be noted that the two approaches are complementary to each other. In fact, a compression pipeline called “Deep Compression” [13] which consists of three compression procedures, i.e. weight pruning, weight quantization and Huffman-based weight encoding, achieved excellent compression performance on AlexNet and VGG-16 architectures.

Along pruning and quantization, low-rank approximation of both convolutional layers and fully connected layers was also employed to achieve computational speed up [26, 27, 28]

. Viewed as high-order tensors, convolutional layers were decomposed using traditional tensor decomposition methods, such as CP decomposition

[21, 20, 29] or Tucker decomposition [30], and the convolution operation is approximated by applying consecutive 1D convolutions.

Overall, efforts to remove redundancy in already trained neural networks have shown promising results by determining networks with a much simpler structure. The results naturally pose the following question: why should we compress an already trained network and not seek for a compact network representation that can be trained from scratch?. Subsequently, one could of course exploit the above mentioned compression techniques to further decrease the cost. Under this perspective, the works in [19, 22] utilizing a low-rank approximation approach were among the first to report simplified network structures.

The success of Convolutional Neural Networks can be attributed to four important design principles: sparse connectivity, parameter sharing, pooling and multilayer structure. Sparse connectivity (in convolutional layers) only allows local interaction between input neurons and output neurons. This design principle comes from the fact that in many natural data modalities such as images and videos local/neighboring values are often highly correlated. These groups of local values usually contain certain distinctive patterns, e.g. edges and color blobs, in images. Parameter sharing mechanism in CNNs enables the underlying model to learn location invariant cues. In other words, by sliding the filters over the input, the patterns can be detected regardless of the location. Pooling and multilayer structure design of deep neural networks in general and CNN in particular, captures the compositional hierarchies embedded within many natural signals. For example, in facial images, lower level cues such as edges, color and texture patterns form discriminative higher level cues of facial parts, like nose, eyes or lips. Similar compositional structure can be seen in speech or text, which are composed of phonemes, syllables, words and sentences. Although the particular structure of a deep network has evolved over time, the above important design principles remain unchanged. At the core of any convolution layer, each filter with

elements operates as a micro feature extractor that performs linear projection of each data patch/volume from a feature space of dimensions to a real value. In order to enhance the discrimination power of this micro feature extractor, the authors of [31]

proposed to replace the GLM model by a general nonlinear function approximator, particularly the multilayer perceptron (MLP). The resulting architecture was dubbed Network in Network (NiN) since it consists of micro networks that perform the feature extractor functionality instead of simple linear projection.

In this paper, instead of seeking a more complex feature extractor, we propose to replace the linear projection of the traditional CNN by multilinear projection in the pursuit of simplicity. There has been a great effort to extend traditional linear methods to multilinear ones in an attempt to directly learn from the natural representation of the data as high order tensors [32, 33, 34, 35, 36, 37]. The beauty of multilinear techniques lies in the property that the input tensor is projected simultaneously in each tensor mode, allowing only certain connections between the input dimensions and output dimensions, hence greatly reducing the number of parameters. Previous works on multilinear discriminant learning and multilinear regression [38, 32, 33, 34, 35, 36] have shown competitive results of multilinear-based techniques. The proposed architecture still inherits the four fundamental design properties of a traditional deep network while utilizing multilinear projection as a generic feature extractor. The complexity of each feature extractor can be easily controlled through the “rank” hyper-parameter. Besides a fast computation scheme when the network is compact, we also propose an alternative computation method that allows efficient computation when complexity increases.

The contribution of our paper can be summarized as follows:

  • We propose a generic feature extractor that performs multilinear mapping to replace the conventional linear filters in CNNs. The complexity of each individual feature extractor can be easily controlled via its rank, which is a hyperparameter of the method. By having the ability to adjust individual filter’s complexity, the complexity of the entire network can be adjusted without the need of increasing the number of filters in a layer, i.e. the width of the layer. Since the proposed mapping is differentiable, the entire network can be easily trained end-to-end by using any gradient descent-based training process.

  • We provide the analysis of computation and memory requirements of the proposed structure. In addition, based on the properties of the proposed mapping, we propose two efficient computation strategies leading to two different complexity settings.

  • The theoretical analysis of the proposed approach is supported by experimental results in real-world classification problems, in comparison with CNN and the low-rank scheme in [19].

The remainder of the paper is organized as follows: In section 2, we provide an overview of the related works focusing on designing compact network structures. Section 3 gives the necessary notations and definitions before presenting the proposed structure and its analysis. In section 4, we provide details of our experiment procedures, results and quantitative analysis. Section 5 concludes our work and discusses possible future extensions.

Ii Related Work

Research focusing on the design of a less redundant network architecture has gained much more attention recently. One of the prominent design pattern is the bottleneck unit which was first introduced in the ResNet architecture [11]. The bottleneck pattern is formed by two convolution layers with some convolution layers in between. The first convolution layer is used to reduce the number of input feature maps while the latter is used to restore the number of output feature maps. Several works such as [39, 40, 41] have incorporated the bottleneck units into their network structure to reduce computation and memory consumed. Recently MobileNet architecture [42] was proposed which replaced normal convolution operation by depthwise separable convolution layers. Constituted by depthwise convolution and pointwise convolution, the depthwise separable convolution layer performs the filtering and combining steps independently. The resulting structure is many times more efficient in terms of memory and computation. It should be noted that bottleneck design or depthwise separable convolution layer is a design on a macro level of the network structure in which the arrangements of layers are investigated to reduce computation.

On a micro level, the works in [19] and [22]

assumed a low rank structure of convolutional kernels in order to derive a compact network structure. In fact, low rank assumption has been incorporated into several designs prior to deep neural networks, such as dictionary learning, wavelet transform of high dimensional data. The first incorporation of low rank assumption in neural network compression was proposed in

[21, 29, 20]. In [29], CP decomposition was proposed to decompose the entire 4D convolutional layer into four 1D convolutions. Although the effective depth of the network remains the same, replacing one convolution operation by four can potentially lead to difficulty in training the network from scratch. With a carefully designed initialization scheme, the work of [22] was able to train a mixture of low-rank filters from scratch with competitive performances. Improving on the idea of [29], a different low-rank structure that allows both approximating an already trained network and training from scratch was proposed in [19]. Specifically, let us denote a convolution layer of kernels by , where and are the number of input feature maps and spatial size of the kernel, respectively. [19] proposed to approximate using a vertical kernel and a horizontal kernel . The approximation is in the following form:


where the superscript and subscript denote the index of the channel and the kernel respectively. is a hyper-parameter controlling the rank of the matrix approximation. Here is just the 2D kernel weight of the -th filter applied to the -th channel of the input feature map; and are just

-dimensional vectors.

As can be seen from (1), the authors simplify a convolutional layer by two types of parameter sharing. The first is the sharing of right singular vectors () across all input channels within the -th filter while the second enforces the sharing of left singular vectors () across all filters. The work in [19]

is closely related to ours since we avoid designing a particular initialization scheme by including a Batch Normalization step

[43]. The resulting structure was easily trained from scratch with different network configurations.

Iii Proposed Method

We start this section by introducing some notations and definitions related to our work. We denote scalar values by either low-case or upper-case characters , vectors by low-case bold-face characters , matrices by upper-case bold-face characters and tensors by calligraphic capital characters . A tensor is a multilinear matrix with modes, and is defined as , where denotes the dimension in mode-. The entry in the th index in mode- for is denoted as .

Iii-a Multilinear Algebra Concepts

Definition 1 (Mode- Fiber and Mode- Unfolding)

The mode- fiber of a tensor is a vector of -dimensional, given by fixing every index but . The mode- unfolding of , also known as mode- matricization, transforms the tensor to matrix , which is formed by arranging the mode- fibers as columns. The shape of is with .

Definition 2 (Mode- Product)

The mode- product between a tensor and a matrix is another tensor of size and denoted by . The element of is defined as .

For convenience, we denote by .

One of the nice properties of mode- product is that the result of the projection does not depend on the order of projection, i.e.


The above property allows efficient computation of the projection by selecting the order of computation.

Iii-B Multilinear filter as generic feature extractor

Fig. 1: Illustration of the proposed multilinear mapping according to equation (6) in sequence: mode-, mode- and mode-

Let and denote the input patch centered at spatial location and the convolution kernel respectively. At the core of a classic CNN, each convolution kernel operates as a feature extractor sliding through the input tensor to generate a higher level representation. Specifically, the kernel performs the following linear mapping:


where and denotes the response at and the intercept term respectively. denotes the dot-product between two tensors. After the above linear projection, a nonlinearity is applied to

using the layer’s activation function.

We propose to replace the above linear projection by the following multilinear mapping:


where is the rank hyper-parameter of the projection and denotes the projection along mode-. In our case, .

Since the mapping in Eq. (4) operates on similar input patch and yields a scalar response as a linear mapping does in CNNs, the proposed multilinear mapping acts as a generic feature extractor and can be incorporated into any design of the CNN topology, such as AlexNet [44], VGG [45], Inception [41] or ResNet [11]. In addition, since the mapping in Eq. (4) is differentiable with respect to each individual weight vector , the resulting network architecture can be trained in an end-to-end fashion by back propagation algorithm. We hereby denote the layer employing our proposed multilinear mapping as MLconv.

Recently, mode- multiplication has been introduced as a tensor contraction layer in [46] to project the entire input layer as a high-order tensor to another tensor. This is fundamentally different from our approach since the tensor contraction layer is a global mapping which does not incorporate sparse connectivity and parameter sharing principles. In general, mode- multiplication can be applied to an input patch/volume to output another tensor instead of a scalar as in our proposal. We restrict the multilinear projection in the form of Eq. (4) to avoid the increase in the output dimension which leads to computation overhead in the next layer. Moreover, tensor unfolding operation required to perform the multilinear projection that transforms a tensor to another tensor will potentially increase the computation. On the contrary, our proposed mapping is a special case of the general multilinear mapping using mode- product in which the output tensor degenerates to a scalar. This special case allows efficient computation of the projection, as shown in the next section.

Iii-C Memory and Computation Complexity

One the most obvious advantages of the mapping in Eq. (4

) is that it requires far fewer parameters to estimate the model, compared to the linear mapping in a CNN. In a CNN utilizing the mapping in Eq. (

3), a layer with kernels requires the storage of parameters. On the other hand, a similar layer configuration with mappings utilizing the projection in Eq. (4) requires only parameters. The gain ratio is:


As compared to a similar CNN topology, the memory reduction utilizing the mapping in Eq. (4) varies for different layers. The case where (which is the usual case) leads to a gain ratio approximately equal to . In our experiments, we have seen that with and in all layers, memory reduction is approximately , while having competitive performance compared to a CNN with similar network topology.

Let us denote by and the input and kernels of the -th convolutional layer having input feature maps and

output feature maps. In addition, we assume zero-padding and sliding window with stride of

. By using linear projection as in case of CNN, the computational complexity of this layer is . Before evaluating the computational cost of a layer using the proposed method, it should be noted that the projection in Eq. (4) can be efficiently computed by applying three consecutive convolution operations. Details of the convolution operations depend on the order of three modes. Therefore, although the result of the mapping in Eq. (4) is independent of the order of mode- projection, the computational cost actually depends on the order of projections. For , it is computationally more efficient to first perform the projection in mode- in order to reduce the number of input feature maps for subsequent mode- and mode- projection:


The response in Eq. (6) is the summation of independent projections with each projection corresponding to the following three consecutive steps, as illustrated in Figure 1:

  • Projection of along the third mode which is the linear combination of input feature maps. The result is a tensor of size .

  • Projection of along the first mode which is the linear combination of rows. The result is a tensor of size .

  • Projection of along the second mode which is the linear combination of elements.

With the aforementioned configuration of the -th layer, the computational complexity of the -th MLconv layer utilizing our multilinear mapping is as follows:

  • Mode- projection that corresponds to applying convolutions to the input with kernels of size elements, having computational complexity of . The output of the projection along the third mode is a tensor of size .

  • Mode- projection is equivalent to applying convolution with one separable convolution kernel, having complexity of . This results in a tensor of size .

  • Mode-, similar to mode- projection, can be computed by applying convolution with one separable convolution kernel, requiring computation. This results in a tensor of size . By summing over ranks, we arrive at the output of layer of size .

The total complexity of layer using our proposed mapping is thus . Compared to linear mapping, our method achieves computational gain of:


From Eqs. (5) and (7), we can conclude that the proposed feature extractor achieves approximately savings in both computation and memory when .

Iii-D Initialization with pre-trained CNN

The proposed mapping in Eq. (4) can be viewed as a constrained form of convolution kernel as follows:


where is expressed in Kruskal form as the outer-product of the corresponding projection in three modes. By calculating using mode- product definition as in Eq. (4) and using dot-product as in Eq. (8), the equivalance of Eq. (4) and Eq. (8) can be found [47].

Consequently, a convolution layer can be converted to an MLconv layer by decomposing each convolution filter into Kruskal form using any CP decomposition method [47]. It should be noted here that, since there is no closed-form solution of the CP decomposition, such a conversion corresponds to an approximation step. Under this perspective, a pre-trained CNN can be used to initialize our network structure to speed up the training process. However, as we will show in the experimental section, random initialization of multilinear filters can lead to better performance.

In addition to an initialization scheme, Eq. (8) also complements our proposed mapping with an efficient computation strategy when is large. The computation cost discussed in the previous subsection depends linearly with parameter . When is large, it is more efficient to compute the mapping according to Eq. (8) by first calculating and then convolving the input with . The computational complexity of the first step is while for the convolution step is , resulting to an overall complexity of for the entire layer. The ratio between normal convolution layer and MLconv layer using this computation strategy is:


It is clear that is usually much larger than , therefore, the increase in computation as compared to normal convolution is marginal. Following this calculation strategy, a rank network is marginally slower than a rank network or a CNN. This will be demonstrated in our experiment section. In conclusion, the computation method discussed in this subsection allows the scalability of our proposed mapping when is large while previous subsection proposes an efficient computation scheme that allows computation savings when is small. Overall, we can conclude that the computation of the proposed layer structure is efficient while, as will be shown in the experimental evaluation, changing the rank of the adopted tensor definitions can increase performance.

Iv Experiments

In this section, we provide experimental results to support the theoretical analysis in section III. The experimental protocol and datasets are described first, followed by the discussion of the experimental results.

Iv-a Network Topology

Traditional CNN topology consists of two modules: feature extractor module and classifier module. Several convolution and pooling layers stacked on top of each other act as feature extractor while one or two fully-connected layers act as the classifier. In order to evaluate the effectiveness of the proposed multilinear filter, we constructed the network architecture with only feature extractor layers, i.e. convolution layer or MLconv layer together with pooling layer while skipping fully-connected layer. As the name suggests, fully-connected layer has dense connections, accounting for large number of parameters in the network while being prone to overfitting. Moreover, a powerful and effective feature extractor module is expected to produce a highly discriminative latent space in which the classification task is made simple. Such fully-convolutional networks have attracted much attention lately due to their compactness and excellent performance in image-related problems like semantic segmentation, object localization and classification

[31, 2, 48]

The configuration of the baseline network adopted in our experiment benchmark is shown in Table I where denotes kernels with spatial dimension, BN denotes Batch Normalization [43]

and LReLU denotes Leaky Rectified Linear Unit

[49] with . Our baseline architecture is similar to the one proposed in [50] with four key differences. Firstly, we choose to retain a proper pooling layer instead of performing convolution with a stride of as proposed in [50]

. Secondly, Batch Normalization was applied after every convolution layer except the last one where the output goes through softmax to produce the class probability. In addition, LReLU activation unit was applied to the output of batch normalization. It has been shown that the adoption of BN and LReLU speeds up the learning process of the network by being more tolerant to the learning rate with the possibility of arriving at better minimas

[43, 51].

Input layer
- BN - LReLU
- BN - LReLU
- BN - LReLU
- BN - LReLU
- BN - LReLU
- BN - LReLU
- BN - LReLU
- BN - LReLU
Global Average over spatial dimension
softmax activation

TABLE I: Baseline Network Architecture

Based on the configuration of the network topology, we compare the performance between standard linear convolution kernel (CNN), our proposed multilinear kernel (MLconv) and the low-rank (LR) structure proposed in [19]. The last two convolution layers were not replaced by LR or MLconv layer. It should be noted that BN and LReLU are applied to all three competing structures in our experiments while in [19], BN was not applied to the baseline CNN which could potentially lead to biased result.

Iv-B Datasets

Iv-B1 CIFAR-10 and CIFAR-100

CIFAR dataset [52] is an object classification dataset which consists of color images for training and for testing with the resolution pixels. CIFAR-10 refers to the 10-class classification problem of the dataset in which each class has images for training and images for testing while CIFAR-100 refers to a more fine-grained classification of the images into classes.

Iv-B2 Svhn

SVHN [53] is a well-known dataset for hand-written digit recognition problem which consists of more than images of house numbers extracted from natural scenes with varying number of samples from each class. This dataset poses a much harder character recognition problem as compared to the MNIST dataset [10]. We used cropped images provided by the database from which each individual image might contain some distracting digits on the sides.

CNN MLconv1 LR26 MLconv2 LR53 MLconv4 LR106 MLconv6
# Parameters

TABLE II: CIFAR-10 Classification error (%)
CNN MLconv1 LR26 MLconv2 LR53 MLconv4 LR106 MLconv6
# Parameters

TABLE III: CIFAR-100 Classification error (%)

Iv-C Experimental settings

All networks were trained using both SGD optimizer [54] as well as Adam [55]. While the proposed structure tends to arrive at better minimas with Adam, this is not the case for the other two methods. For SGD optimizer, the momentum was fixed to . We adopted two sets of learning rate schedule and . Each schedule has initial learning rate and decreases to the next value after epochs where was cross-validated from the set . We trained each network with maximum of and epochs for CIFAR and SVHN respectively. The batch size was fixed to samples for all competing networks.

Regarding data augmentation, for CIFAR dataset, random horizontally flipped samples were added as well as random translation of the images by maximum pixels were performed during the training process; for SVHN dataset, only random translation of maximum pixels was performed. For both dataset, no further preprocessing step was applied.

Regarding regularization, both weight decay and max-norm [56] are individually and together exploited in our experiments. Max-norm regularizer was introduced in [56] where it was used together with Dropout. During the training process, the norm of each individual filter is constrained to lie inside the ball of a given radius which was cross-validated from the set . The weight decay hyper-parameter was searched from the set . In addition, Dropout with was applied to the input and Dropout with was applied to the output of all pooling layers with the optimal obtained from the set . Due to the differences between the three competing structures, we observed that while the baseline CNN and LR networks work well with weight decay, applying weight decay to the proposed network structure tends to drive all the weight values close to zeros when is large, or the regularization effect is marginal when using a small value for , leading to the exhaustive search of suitable hyper-parameter . On the other hand, max-norm regularization works well with our method without being too sensitive to the performance.

For MLconv and LR structures, we experimented with several values for the rank parameter, namely for the proposed mapping and in Eq. (1) from [19]. In all of our experiments, we made no attempt to optimize and for each individual filter and layer in order to get the maximal compact structure, since such an approach is impractical in real cases. We instead used the same rank value throughout all layers. The experiments are, hence, different from [19] where the authors reported performance for different values of at each layer without discussing the rank selection method. The experiments were conducted with and the corresponding structures are denoted as MLconv1, MLconv2, MLconv4, MLconv6. The values of are selected so that the number of parameters in an LR network is similar to the number of parameters of its MLconv counterpart with given . The corresponding LR structures are denoted as LR26, LR53 and LR106, where the number denotes the value of . We did not perform experiments with , which corresponds to , since training the network is computationally much slower and falls out of the objective of this paper.

All of three competing structures training from scratch were initialized with random initialization scheme proposed in [57]. We additionally trained MLconv and LR structure with weights initialized from an optimal pre-trained CNN on CIFAR dataset. The aforementioned protocols were also applied for this configuration. The weights of MLconv were initialized with CP decomposition using canonical alternating least square method [47], while for the LR structure we followed the calculation proposed in [19].

Fig. 2: Model size versus Classification Error on CIFAR-10 for different structures. MLconv and LR network initialized with CNN marked with ”i” at last

Iv-D Experimental results

Fig. 3: Model size versus Classification Error on CIFAR-100 for different structures. MLconv and LR network initialized with CNN marked with ”i” at last

After obtaining the optimal hyper-parameter values, each network was trained for five times and the median value is reported. The second row of Tables II and III shows the classification errors of all competing methods trained from scratch on CIFAR-10 and CIFAR-100, respectively, while the third row shows the performance when initialized with a pre-trained CNN. The last row reports the model size of each network. As can be seen from both Tables II and III, using the proposed multi-linear filters leads to a reduction in memory, while outperforming the standard convolution filters in both coarse and fine-grained classification in CIFAR datasets. More interestingly, in CIFAR-100, a rank multi-linear filter network attains an improvement over . As we increase the number of projections in each mode to , i.e. when using , the performance of the network increases by a small margin. In both CIFAR-10 and CIFAR-100, constraining gains memory reduction while keeping the performance relatively closed to the baseline CNN with less than increment in classification error. Further limiting to maximizes the parameter reduction to nearly with the cost of and increase in error rate for CIFAR-10 and CIFAR-100, respectively. A graphical illustration of the compromise between number of network’s parameters and classification error on CIFAR-10 and CIFAR-100 is illustrated in Figures 2 and 3, respectively.

The classification error of each competing network trained from scratch on SVHN dataset is shown in Table IV. Using our proposed MLconv layers, we achieved reduction in model size while slightly outperforming CNN. At the most compact configuration of MLconv structure, i.e. MLconv1, we only observed a small increment of in classification error as compared to CNN baseline. As we increased the complexity of MLconv layers, little improvement was seen with MLconv4 while MLconv6 layers became slightly overfitted.

Comparing the proposed multi-linear filter with the low rank structure LR, all configurations of MLconv network significantly outperform their LR counterparts. Specifically, in the most compact configuration, MLconv1 is better than LR26 by and on CIFAR-10 and CIFAR-100, respectively. The margin shrinks as the complexity increases but the proposed structure consistently outperforms LR when training the network from scratch. Similar comparison results can be observed on SVHN dataset: using MLconv layers obtained lower classification errors as compared to LR layers at all complexity configurations. As opposed to the experimental results reported in [19], we observed inferior results of the LR structure compared to standard CNN when training from scratch. The difference might be attributed to two main reasons: we incorporated batch normalization into the baseline CNN which could potentially improve the performance of the baseline CNN; our baseline configuration has no fully-connected layer to solely benchmark the efficiency of different filter structures as a feature extractor.

Error (%) #Parameters




TABLE IV: SVHN Classification error
MLconv1 LR26 MLconv2 LR53 MLconv4 LR106 MLconv6 MLconv1* MLconv2* MLconv4* MLconv6*

TABLE V: Forward Computation Time on CIFAR10 (normalized with respect to Conv)

One interesting phenomenon was observed when we initialized MLconv and LR with a pre-trained CNN. For the LR structure, most configurations enjoy substantial improvement by initializing the network with weights decomposed from a pre-trained CNN on CIFAR dataset. The contrary happens for our proposed MLconv structure, since most configurations observe a degradation in performance. This can be explained by the fact that LR structure was designed to approximate each individual 2D convolution filter at every input feature map and the resulting structure comes with a closed-form solution for the approximation. With good initialization from a CNN, the network easily arrived at a good minimum while training a low-rank setting from scratch might have difficulty at achieving a good local minimum. Although the proposed mapping can be viewed as a form of convolution filter, the mapping in Eq. (4) embeds a multi-linear structure, hence possessing certain degree of difference. Initializing the proposed mapping by applying CP decomposition, which has no closed-form solution, may lead the network to a suboptimal state.

Table V reports the average forward propagation time of a single sample measured on CPU for all three network structures on CIFAR-10. The second and third columns report the theoretical and actual speed-ups, respectively, measured by the number of multiply-accumulate operations normalized with respect to their convolution counterparts. For the proposed MLconv structure, we report the computation cost of both calculation strategies discussed in Section III

. We refer to the first calculation strategy using the separable convolution as Scheme1, while the latter one using normal convolution as Scheme2. Results from Scheme2 are denoted with the asterisk. All the networks are implemented using Keras library


with Tensorflow

[59] backend. It is clear that there is a gap between theoretical speed-up and actual speed-up, especially for the proposed structure implemented by an unoptimized separable convolution operation. In fact, at the time of writing, implementation of separable convolution operation is still missing in most libraries, not to mention efficient implementation. On the contrary, results from Scheme2 using normal convolution show a near perfect match between theory and implementation. This is due to the fact that normal convolution operation has been efficiently implemented and optimized in most popular libraries. This also explains why the computation gain of LR structure is inferior to MLconv structure (Scheme1) in theory but similar to ours in practice since LR structure is realized by normal convolution operation. The last four columns of Table V additionally prove the scalability of Scheme2 with respect to the hyper-parameter rank as discussed in Section III-D.

V Conclusions

In this paper, we proposed a multilinear mapping to replace the conventional convolution filter in Convolutional Neural Networks. The resulting structure’s complexity can be flexibly controlled by adjusting the number of projections in each mode through a hyper-parameter . The proposed mapping comes with two computation schemes which either allow memory and computation reduction when is small, or the scalability when is large. Numerical results showed that with far fewer parameters, architectures employing our mapping could outperform standard CNNs. This are promising results and opens future research directions focusing on optimizing parameter on individual convolution layers to achieve the most compact structure and performance.