# Efficient Architecture for Deep Neural Networks with Heterogeneous Sensitivity

###### Abstract

This work presents a neural network that consists of nodes with heterogeneous sensitivity. Each node in a network is assigned a variable that determines the sensitivity with which it learns to perform a given task. The network is trained by a constrained optimization that maximizes the sparsity of the sensitivity variables while ensuring the network’s performance. As a result, the network learns to perform a given task using only a small number of sensitive nodes. Insensitive nodes, the nodes with zero sensitivity, can be removed from a trained network to obtain a computationally efficient network. Removing zero-sensitivity nodes has no effect on the network’s performance because the network has already been trained to perform the task without them. The regularization parameter used to solve the optimization problem is found simultaneously during the training of networks. To validate our approach, we design networks with computationally efficient architectures for various tasks such as autoregression, object recognition, facial expression recognition, and object detection using various datasets. In our experiments, the networks designed by the proposed method provide the same or higher performance but with far less computational complexity.

## I Introduction

Neural networks often consist of a large number of nodes arranged in deep layers. As researchers have addressed an increasingly wide variety of problems using neural networks, these network architectures have become increasingly complicated. High-performance networks often contain thousands of nodes [1, 2, 3, 4, 5]. One property of neural networks is that nodes share the workload [6]. A network is trained to perform a given task utilizing all the available nodes. Thus, all the nodes provided in a network architecture contribute towards solving a given problem.

As neural networks are implemented on platforms with less computational power, and as neural networks are asked to perform more tasks on platforms with massive but still finite computational power, designing a network with less computational complexity has become an important issue [7, 8]. Numerous studies have been conducted to determine how to prune network nodes and obtain a computationally efficient network [9, 10, 11, 12, 13, 14, 15, 16, 17, 18]. In these approaches, the networks are first trained with a large amount of nodes; then, the importance of each node is evaluated by analyzing the node weight using various measures. Finally, the nodes with less importance are removed from the trained network. However, because all the nodes in trained network share the workload, removing a node from a trained network—even if its node weight indicates that is has lesser importance, will degrade the network’s performance. Consequently, pruning approaches are usually followed by retraining the pruned network to recover the performance losses from pruning.

In this paper, we propose a network that consists of nodes with heterogeneous sensitivity. Each node in a network is assigned a variable that determines its sensitivity to learn a given task. Then, the network learns to perform the task by relying more on the sensitive nodes and less on the insensitive nodes. In extreme cases where the sensitivity of a node is zero, the network does not utilize the node at all; it is essentially disconnected. Node sensitivity is learned during training through a constrained optimization. The sparsity of the sensitivity is maximized while the network performance is constrained within a certain range. As a result, the network learns to perform a given task using only a small number of sensitive nodes. By simply removing the nodes with zero sensitivity, the computationally efficient architecture of a deep network for a given task is obtained. The regularization parameter used for the constrained optimization is determined simultaneously during the training based on the L-curve, which has previously been used to determine the regularization parameters for inverse problems [19, 20, 21, 22].

We assign sensitivity to nodes in a network by introducing a layer we call a sensitivity layer. The sensitivity layer can be implemented as a special type of dense or convolutional layer. Then, a network that includes these new sensitivity layers can be implemented and trained using functions available in standard deep learning packages [23, 24, 25]. Our approach does not require any special optimization routine to solve the constrained optimization problem that we designed to enforce the sparsity of the sensitivity variables while training.

We designed computationally efficient architectures with heterogeneous sensitivity for various tasks such as autoregression, object recognition, facial expression recognition, and object detection using various datasets. We first applied networks with heterogeneous sensitivity to design a simple autoencoder and a deep convolutional neural network (CNN) for analysis. The effects of the regularization parameters on the network’s performance and architecture are analyzed through the L-curve. Simultaneous selection of the regularization parameter during the training using the proposed algorithm is validated. Then, we applied the sensitivity layers to deep networks to solve various problems. Experiments are performed using various networks, autoencoder, CNN, LeNET [1], VGG [1], ResNet [4], and YOLO [5], and various dataset, Gaussian, MNIST [26], CIFAR-10 [27], CK+ [28], VOC [29], and ImageNet [36] for various types of classifications. By introducing nodes with heterogeneous sensitivity to the networks and enforcing the sparsity of the sensitivity, we were able to design networks that consist of notably fewer nodes but that exhibit the same or even better performance. The proposed method can be used to design an efficient network containing the optimal number of nodes.

The rest of this paper is organized as follows. We introduce networks with heterogeneous sensitivity and the constrained optimization to determine efficient network architecture in Section II-A and II-B, respectively. An algorithm for simultaneous selection of the regularization parameter during the network training is presented in Section II-C. The implementation of the nodes with heterogeneous sensitivity as the sensitivity layer is discussed in Section II-D. Comparisons to pruning approaches to find efficient network architecture are given in Section II-E. We present the experimental results and discussions for the autoencoder in Section III-A and III-B. We find efficient network architecture of deep networks with heterogeneous sensitivity in Section III-D to III-F. We compare the performance and complexity of the optimal deep networks to those of pruned networks reported in literatures in Section III-G to III-I. Section IV concludes the paper.

## Ii Efficient Architecture for Deep Neural Networks

### Ii-a Neural Networks with Heterogeneous Sensitivity

Consider a network whose th layer consists of the following operations. The intermediate output is computed by either a dense layer,

(1) |

or by a convolutional layer,

(2) |

where is the th intermediate output node, and are the the th nodes and the node volume in the th layers, respectively. The network parameters and denote a weight in the dense layer and a filter in the convolutional layer, respectively. The number of nodes in the th layer are denoted as . The intermediate output is activated by an activation function:

(3) |

The activated output is weighted by a newly introduced layer:

(4) |

where is a variable that determines the sensitivity of the th node in the th layer . We denote this new layer as a sensitivity layer. The schematics of the proposed network architecture is given in Fig. 1.

The sensitivity variable in the sensitivity layer allows us to apply heterogeneous sensitivity to the nodes in a network. Consider a network trained to minimize a cost function using backpropagation [30, 31]. The weight matrix , whose element is the weight of the th layer, is updated by

(5) |

where is the step size and is a vector whose elements are . In the th layer, each element of the sensitivity vector is

(6) |

The variable is a weight that reflects the sensitivity of a node. When the weights are updated, nodes with larger values of will respond more sensitively than those with smaller values. In the extreme case, when , the node is completely insensitive. These zero-sensitivity nodes can be regarded as disconnected nodes.

### Ii-B Optimization for Efficient Network Architecture

Node sensitivity (the sensitivity variable ) can be determined during the training so that a network learns to perform a given task using only a small number of sensitive nodes. To accomplish this, we designed an optimization problem to train the network:

(7) |

where is a vector whose elements are and is a deviation penalty that measures the deviations of network outputs from the ground truth values. The cost function, which is the sum of the norm of , makes the vector sparse, so that the network uses only a few sensitive nodes and includes as many disconnected nodes as possible. The constraint on guarantees the performance of the network within the threshold . The deviation penalty is a typical cost function used to train a network. The last layer of a network is usually determined by a specific task. We set the sensitivity variable for the last layer to one.

The optimization problem can be rewritten as follows:

(8) |

where the regularization parameter weighs the deviation penalty and the sparsity penalty . When is large, the sparsity penalty dominates the cost function in (8). The trained network will consist of a small number of sensitive nodes with as many insensitive (i.e., disconnected) nodes as possible. However, because the deviation penalty is neglected during the training, the network will fail to provide accurate outputs. In contrast, when is small, the deviation penalty dominates the cost function, and the network will be trained to provide accurate outputs but will utilize most of the available nodes. Thus few insensitive (i.e., disconnected) nodes will exist. Ideally, the goal is to find a that balances the deviation and sparsity penalties.

### Ii-C Regularization Parameter Selection Via L-Curve

An L-curve is a plot of the two penalties for various values of . The L-curve has previously been used in inverse problems [19, 20, 21, 22]. In our problem, the L-curve shows the deviation penalty vs. the sparsity penalty for various values of . Let the deviation and sparsity penalties when the network is trained with the regularization parameter be and . The L-curve is given by

(9) |

where is an increasing function such as the log function. One region of the L-curve corresponds to solutions that are dominated by the deviation penalty, and another region of the L-curve corresponds to solutions that are dominated by the sparsity penalty. The curve generally has an L-shape. The corner of the L-curve provides a solution for which the two penalties are balanced. We use the L-curve to determine the best value of the regularization parameter for the optimization problem in (8).

The operation of a deep network is usually composed of multiple layers with non-linear activation function. Parameter selection methods based on diagonalization of a matrix that represents a linear operation of a system [32, 33] are not applicable to determine the regularization parameter for deep networks. Also, the training of a deep network usually requires large amount of computation. Parameter selection methods that find the maximum curvature point of the L-curve [19] are not practical, because the L-curve has to be constructed for many values of .

We determine the regularization parameter simultaneously during the training of a deep network. The network training is initialized with random weight ’s and a small initial regularization parameter . The network is trained for a given number of epochs and the deviation cost is measured. While the measured deviation penalty is smaller than , the regularization parameter is increased by , the sensitivity variables are initialized randomly, and the network is trained for a given number of epochs. When the regularization parameter becomes too large, the network cannot provide outputs close to the ground truth. The deviation penalty increases substantially and becomes larger than . We find the largest regularization parameter value that provides the deviation penalty . Then, the training of the network continues with the found regularization parameter until the termination condition for the network training is met. The algorithm for the simultaneous network training and regularization parameter selection is given in Algorithm 1.

### Ii-D Sensitivity Layer Implementation

The sensitivity layer can be regarded as a special type of dense or a convolutional layer. A sensitivity layer added after a dense layer with nodes can regarded as a set of (dense) layers with one input node, one output node, and one weight. A sensitivity layer added after a convolutional layer with nodes can be regarded as a set of convolutional layers with one input node, one output node, and a single one-by-one filter. Hence, the sensitivity layer can be implemented using layer definitions and functions already available in deep learning packages [23, 24, 25].

Moreover training a network that includes sensitivity layers can be accomplished with various training methods already available in deep learning packages. The weights in the dense or convolutional layers are updated by

(10) |

and the parameters in the sensitivity layers are updated by

(11) |

These approaches can be implemented as the training for either dense or convolutional layers under regularization. Hence, by regarding the sensitivity layers as simply special cases of dense or convolutional layers, we can implement and train a network with the sensitivity layers using standard deep learning packages. Our approach does not require any special optimization routines to solve the constrained optimization problem.

### Ii-E Comparison with Pruning Methods

Previous studies have investigated how to design compact and efficient networks to allow deep networks to be deployed on devices with restricted computational capabilities. A survey of efficient deep network design methods can be found in [7, 8]. Many approaches can prune nodes with high computational complexity and memory requirements to obtain a more efficient network. In these pruning approaches, a network is first trained, and then the importance of each node is evaluated with various measures. Finally, the less important nodes are pruned from the trained network. The issue of how the cost function used for the training changes with small weight perturbations was analyzed In [9, 10, 11, 12]. For example, the Hessian of a cost function provides information on how small weight changes affect the cost. Connections in a trained network that induce insignificant changes in the cost function were removed from the network. In [13, 14, 15, 16, 17], the importance of weights in a trained network was evaluated using the , , and norms of the node weights or distances between the weights [41]. Then, the less important connections between nodes were removed from the trained network based on the evaluated measures. To encourage a network to have node weights that result in smaller measures, regularization by the , , and norms of the node weights is used during training.

Many pruning approaches use regularization as a function of node weights. As a results some connections in dense layers and some filter coefficients in convolutional layers have small values. Removing a node from a network entirely is not straightforward for dense layers and is difficult for convolutional layers. Examples of pruning with removed connections and filter coefficients are shown in Fig. 2 (a), where prunned connection and prunned filter cofficients are denoted as red lines and blocks, respectively. The network is trained to perform a task utilizing all the available nodes. Because nodes in a network share the workload [6], removing a node—even one with a smaller measure of importance—from a trained network will degrade the network’s performance. Consequently, pruning approaches typically retrain the pruned network to recover the performance loss from pruning.

The proposed method uses regularization as a function of the sensitivity. As a result, removing zero-sensitivity nodes is straightforward because they are already disconnected by the end of the training. Examples of disconnected nodes for dense and convolutional layers are shown in Fig. 2 (b), where the nodes with zero sensitivity, denoted with red lines, can be removed from a trained network. The network is trained to perform a task utilizing only the sensitive nodes; therefore, removing zero-sensitivity nodes has no effect on the network’s performance because the network has already been trained to perform the task without them.

In [18], networks with activation functions with nodewise variant slopes were introduced. Using this approach, the nodes with steeper slopes learn more important features, and vice versa. After training, the nodes with lower slopes are pruned from the trained network. The assignment of nodewise variant slopes to activation functions plays a role similar to that of the sensitivity layers presented in this paper; however, that study used a predefined set of values for the slopes regardless of the data. Because a predefined set of slopes does not reflect the actual data statistics, workload sharing still exists; hence, a performance loss occurs after pruning. Our proposed method can be viewed as an improvement of the work in [18] in which the slopes of the activation functions are learned from the data statistics by solving an optimization problem during the training.

In [34], a layer similar to the sensitivity layer in our proposed network was introduced to a trained network. The variables in the added layer were then used for pruning. An optimization problem was constructed to determine which nodes could be removed from the trained network while still ensuring the network’s performance. Again, however, because nodes in a trained network share the workload, node pruning—even when done through an optimization approach, degrades the network’s performance. In contrast, the variables in the sensitivity layers in our approach are found during network training, thus avoiding the need for further pruning.

In [35], a group lasso of node weights is used as a regularization factor. The group lasso enforces groupwise sparsity. By defining all the coefficients in a filter as a group, a node can be effectively removed from a convolutional layer. By defining only a part of the filter coefficients as a group, filters with different support levels can be used in a convolutional layer. Consequently, different network architectures can be designed by defining different groups. Such a design requires multiple regularization parameters; however, the study did not address how to choose the regularization parameters to obtain efficient architecture. In contrast, our approach uses regularization as a function of node sensitivity, which allows us to simply disconnect a node in both dense and convolutional layers. The regularization parameter is chosen using an L-curve to help find efficient architecture.

## Iii Experiments and Discussions

We first analyze a network with heterogeneous sensitivity using a simple autoencoder with Gaussian data and the MNIST dataset [26] in Section III-A and III-B, respectively. The regularization parameter selection via the L-curve is discussed in Section III-C using the autoencoder with the MNIST dataset. Then, we find efficient network architecture of deep networks with heterogeneous sensitivity using a CNN with the CIFAR-10 dataset [27], using VGG [3] and ResNet [4] with the CK+ dataset [28], and using YOLO [5] with the VOC dataset [29] in Section III-D to III-F. We compare the performance and complexity of the proposed deep networks to those of pruned networks reported in literatures for LeNet [1] with the MNIST dataset, VGG and ResNet with the CIFAR-10 dataset, and ResNet with the ImageNet dataset [36] in Section III-G to III-I.

### Iii-a Autoencoder with Gaussian Data

To understand how a network with sparse sensitivity variables is trained to perform a given task, consider a simple network in an autoregression setting. As an example, we use a network with two dense layers and linear activation. The sensitivity layer is implemented in the first layer. Then, network operation can be written as follows:

(12) | |||||

(13) | |||||

(14) |

where and are the weight matrices. The matrix is a diagonal matrix whose diagonal elements are the sensitivity variables in . The vectors and are the th column and row of and , respectively. The network operation is written as a linear combination of . The weights for the linear combination are given by the sensitivity variable . The contribution of with small values to the operation of the network is small, and vice versa.

We find the columns of the matrices , and the diagonal matrix through the optimization problem in (8). The sensitivity variable obtained by the optimization will have many zero elements because sparsity is enforced. Without loss of generality, let the elements of be sorted such that the th to th elements are zero. The contribution of with is zero. Hence, we can remove those terms from the linear combination in (14). Then, we approximate the network’s operation by

(15) |

Experiments are performed with 16, 12, and 8 inputs following zero mean Gaussian distribution. We consider cases where some inputs are correlated with large variances and the rest of the inputs are independent with small variances. The large and small variances are 1.0 and 0.0001, and the correlation coefficient is 0.9. The number of hidden nodes, , are set to 16, 12, and 8. The autoencoders are trained by (8) for 50 times. Table I shows the average numbers of nodes with nonzero and zero sensitivity. The network is trained using the regularization parameter corresponding to the corner point of the L-curves. Examples of the L-curves are shown in Fig. 3. The average number of sensitive nodes, with nonzero sensitivity, is close to the numbers of nodes with large variances. The proposed network with heterogeneous sensitivity trained via the optimization problem in (7) operates similarly to the principal component analysis [37]—it represents the inputs through the small number of sensitive, or principal, nodes.

# of inputs | # of inputs | # of hidden | # of nodes | # of nodes |

with | with | nodes | with | with |

=1.0 | ||||

8 | 8 | 16 | 8.3 | 7.7 |

8 | 4 | 12 | 8.0 | 4.0 |

8 | 0 | 8 | 7.5 | 0.5 |

4 | 12 | 16 | 4.0 | 12.0 |

4 | 8 | 12 | 4.1 | 7.9 |

4 | 4 | 8 | 4.1 | 3.9 |

### Iii-B Autoencoder with MNIST Dataset

We analyze a simple network with heterogeneous sensitivity trained with a dataset. A large number of hidden nodes are used in the network and the number of required hidden nodes is determined through training. We prepared a network with 784 hidden nodes in an auto-associative setting to reconstruct the inputs. The rectified linear unit (ReLU) function is used as the activation function for all the nodes. The sensitivity layer is added after the activation functions and implemented as a collection of 784 individual dense layers, each of which has one input, one output, and one weight. As explained in Section II-D, by implementing the sensitivity layer as a special type of dense layer, we can implement and train the network using standard functions in deep learning packages. Here, we used the Keras Python deep learning library for implementation and training. The sensitivity variables are initialized to one. We adopted the regularization in the sensitivity layer as a training option and trained the network using the MNIST dataset [26].

Optimizing the proposed networks requires the regularization parameter that weights the deviation and sparsity penalties. We found the appropriate value using the L-curve. Fig. 4 shows the L-curve for the network using the MNIST dataset, plotted using the deviation penalty vs. the sparsity at different values. The linear function is used as the function in (9), as the L shape is clearly observed with the choice. For small values of , for example , the deviation penalty dominates the cost function of the unconstrained optimization problem in (8). Then, the solution to the optimization problem provides only a small deviation penalty but a large sparsity penalty. In contrast, for large values of , for example , the sparsity penalty dominates the cost function, providing only a small sparsity penalty but a large deviation penalty. The balance of the two penalties can be achieved using the value from the corner of the L-curve. We used a value of for the optimization, which corresponds to the corner of the L-curve.

Fig. 5 shows examples of node sensitivity in networks trained with different values of the regularization parameter . The sensitivity variables, , are shown, in the decreasing order, for , and in Fig. 5 (a), (b), (c), and (d), respectively. As the value increases, there are more nodes with small sensitivity. When , many nodes can be removed from the network. However, the trained network fails to provide acceptable performance at this value. In contrast, a network trained with shown in (c) corresponds to the value at the corner of the L-curve. At this setting, the network provides an acceptable deviation penalty yet has as many zero sensitivity nodes as possible. In effect, the nodes with zero sensitivity are disconnected. The efficient network architecture of the autoencoder with one hidden layer for the MNIST dataset is to have 75 hidden nodes.

Fig. 6 shows the result of PCA on the images in the MNIST dataset. The average mean square error (MSE) values between the inputs and their reconstructions using the principal components are shown in red line. The average MSE values between the inputs and their reconstructions using the most sensitive nodes are shown in blue line for the network trained with . This network has 75 nodes. When all the 75 nodes are used to reconstruct the images, the MSE is lower than one would achieve by reconstructing the images using the 75 principal components. However, when fewer than 75 nodes are used, the MSE values degrade faster than the PCA results. The average MSE values between the inputs and their reconstructions for the network trained with are shown in green line. This network has 46 nodes. When all the 46 nodes are used to reconstruct the images, the MSE is lower than one would achieve by reconstructing the images using the 46 principal components. This observation suggests that a network with a fewer number of nodes should be designed by training a network using a higher regularization parameter value rather than removing nodes from a trained network.

### Iii-C Regularzation Parameter Selection

In Section II-C, an algorithm to determine the regularization parameter simultaneously with the training of a network is proposed. In this section, we train a network using Algorithm 1, and compare the networks performance and complexity to a network trained using the regularization parameter at the corner of the L-curve.

The same network used in the previous section, the autoencoder with a hidden layer, is trained using the Algorithm 1. Fig. 7 shows the deviation and sparsity penalties at different values of the regularization parameter used during the training by the Algorithm 1. The algorithm increases the regularization parameters until the deviation penalty during the training increases considerable. Then, the algorithm trains the network using the selected regularization parameter until the termination condition is met. The L-curve constructed by training the same network multiple times at different regularization parameters is also shown. It can be seen that the deviation and sparsity penalty of the trained network is close to the corner point of the L-curve.

The regularization parameter simultaneously selected during the training by the Algorithm 1 is , while the regularization parameter that corresponds to the corner of the L-curve is . The numbers of hidden nodes are 89 and 75 and the training loss of the network is 0.0018 and 0.0009 for the network trained by the Algorithm 1 and the one trained with the L-curve corner value. The results obtained by determining the regularization parameter via the Algorithm 1 were the same as one would get by hand-selecting the parameter corresponding to the corner of the L-curve.

We used the Algorithm 1 using four epochs for each updated values of , and the algorithm updated seven values. After the values is found, the network is trained for 268 epochs before the termination of the training. For comparison, the network with a fixed values of is trained for 279 epochs. The simultaneous training and selection of by the Algorithm 1 requires 6.1% more epochs than the training for a single values of .

### Iii-D Deep CNN with CIFAR-10 Dataset

In this experiment, we consider a deep CNN with heterogeneous sensitivity for object classification using the CIFAR-10 dataset [27]. We prepared a network with four convolutional layers and two dense layers, adding sensitivity layers to all the convolutional layers and the first dense layers. The second dense layer is designed to perform object classification. The sensitivity layers for the convolutional layers are implemented as a collection of convolutional layers, each of which has one input node and one output node with a one-by-one filter. The sensitivity layers for the dense layers are implemented as a collection of dense layers, each of which has one input node, one output node, and one weight. We applied regularization in the sensitivity layers for training. For comparison, we trained a baseline CNN with the same number of nodes and layers and with the ReLU activation function using the same training set. The batch normalization is applied after the convolutional layers and the dropout is applied after the first dense layer on both the asymmetric and the baseline symmetric networks.

Fig. 8 shows the L-curve for the CNN. The regularization parameter simultaneously selected during the training by the Algorithm 1 is , while the regularization parameter that corresponds to the corner of the L-curve is . Fig. 9 shows the sensitivity of the nodes, in decreasing order, in each layer of the network trained with the find the regularization parameter. The sensitivity variables are sparse in all the layers and have many zero elements. Only the nodes with non-zero sensitivity need to be included in the efficient architecture. We used a thresholding approach to remove the nodes with sensitivity values numerically close to zero to find the efficient architecture.

We used the Algorithm 1 for the simultaneous regularization parameter selection using four epochs for each updated values of , and the algorithm updated five values. After the values is found, the network is trained for 215 epochs before the termination of the training. For comparison, the network with a fixed values of is trained for 221 epochs. The simultaneous training and selection of by the Algorithm 1 requires 6.3% more epochs than the training for a single values of .

Table II summarizes the complexity and performance of the proposed efficient CNN compared to the baseline CNN. The proposed network includes only of the nodes and of the weights, and requires of the FLOPs compared to the baseline CNN. The accuracy of the efficient and baseline CNN are and , respectively. By using nodes with heterogeneous sensitivity, the CNN learns to classify objects with the same accuracy as the baseline but uses only an optimal number of nodes. We included the layer-wise number of nodes, weights, and FLOPs data in the supporting materials.

baseline | proposed | ratio | |
---|---|---|---|

# of nodes | 1290 | 507 | 39.30% |

# of weights | 3407498 | 1284942 | 37.71% |

# of FLOPs | 1.93E+08 | 6.43E+07 | 33.21% |

accuracy | 83.20% | 83.12% | 99.90% |

### Iii-E VGG and ResNet with CK+ Dataset

A trained network can be transferred to form a basis for the design of a network intended for another task. In this section, we added the sensitivity layers to transferred networks to find efficient architectures for a different task. We tested transferred VGG [3] and ResNet [4] for facial expression recognition using the CK+ dataset [28] to classify input facial images into seven emotions:

We selected 325 sequences of 118 subjects that are classified as displaying one of the seven emotions. The so-called “apex frames” that occur at the peak of the expression were collected as labeled facial images. The network was trained and tested using the ten-fold cross validation protocol.

The VGG-16 and ResNet-56 networks with heterogeneous sensitivity were prepared by adding the sensitivity layers after all the convolutional and dense layers. The batch normalization and the dropout are used for the networks. The networks were trained using the CK+ facial recognition dataset. We determined the regularization parameter using the L-curve as described earlier. After the training, we included only the nodes with non-zero sensitivity in the efficient architecture. For comparison, the baseline VGG-16 and ResNet-56 are trained using the same training set.

Table III summarizes the complexity and performance of the proposed efficient VGG-16 compared to the baseline VGG-16. The efficient network includes only of the nodes and of the weights, and requires of the FLOPs compared to the baseline VGG-16. The accuracy of the efficient and baseline VGG-16 are and , respectively. Table IV summarizes the complexity and performance of the efficient ResNet-56 compared to the baseline ResNet-56. The proposed efficient network includes only of the nodes and of the weights, and requires of the FLOPs compared to the baseline ResNet-56. The accuracy of the efficient and baseline ResNet are and , respectively. By using nodes with heterogeneous sensitivity, the transferred VGG and ResNet learns to classify facial expressions with the same accuracy as the baseline but uses only a small number of nodes. We included the node-wise sensitivity variables and the number of nodes, weights, and FLOPs data in the supporting materials.

baseline | proposed | ratio | |
---|---|---|---|

# of nodes | 4743 | 589 | 12.41% |

# of weights | 15767367 | 174327 | 1.11% |

# of FLOPs | 1.25E+09 | 3.85E+08 | 3.07% |

accuracy | 97.89% | 97.85% | 100.00% |

baseline | proposed | ratio | |
---|---|---|---|

# of nodes | 27207 | 3441 | 12.64% |

# of weights | 31872135 | 619369 | 1.94% |

# of FLOPs | 1.33E+09 | 2.86E+08 | 17.53% |

accuracy | 96.77% | 96.03% | 99.2% |

### Iii-F YOLO with VOC Dataset

We prepared a YOLO network with heterogeneous sensitivity by adding sensitivity layers after all the convolutional layers. We simplified the object detection task by considering only four object classes: car, motorbike, pedestrian, and people. The network was trained using the VOC dataset. The regularization parameter was found using the L-curve as described previously.

Table V summarizes the complexity and performance of the proposed efficient YOLO compared to the baseline YOLO. The efficient network includes only of the nodes and of the weights, and requires of the FLOPs compared to the baseline YOLO. The accuracy of the efficient and baseline YOLO in terms of the mean average precision (mAP) are 70.9 and 69.2, respectively. By using nodes with heterogeneous sensitivity, the YOLO learns to detect the specified objects with the same accuracy as the baseline but uses only a small number of nodes. We included the node-wise sensitivity variables and the number of nodes, weights, and FLOPs data in the supporting materials.

baseline | proposed | ratio | |
---|---|---|---|

# of nodes | 10381 | 5885 | 56.69% |

# of weights | 50594061 | 13244927 | 26.18% |

# of FLOPs | 1.54E+10 | 6.66E+09 | 43.12% |

mAP | 70.9 | 69.2 | 97.60% |

### Iii-G LeNet with MNIST Dataset

We compared the complexity and performance of an proposed efficient network found by the proposed method to the pruning results reported in [13, 17, 38, 39, 40, 18]. The LeNet-5 [1] network with heterogeneous sensitivity was prepared and trained using the MNIST dataset. The ratios of the weights remaining after the optimization and the classification errors are reported in Table VI. The efficient network designed by the proposed method provides the highest performance with the least computational complexity.

# of FLOPs | # of weights | error | ||
---|---|---|---|---|

[13] | baseline | 0.80% | ||

pruned | 16.0% | 8.24% | 0.77% | |

[17] | baseline | 0.73% | ||

pruned | N/A | 10.25% | 0.76% | |

[38] | baseline | 0.87% | ||

pruned | 12.1% | 9.01% | 0.71% | |

[39] | baseline | N/A | ||

pruned | N/A | 8.33% | 1.70% | |

[40] | baseline | 0.94% | ||

pruned | 16.5% | 16.00% | 1.65% | |

[18] | baseline | 0.81% | ||

pruned | 78.6% | 6.73% | 0.71% | |

proposed | baseline | 0.80% | ||

proposed | 16.0% | 6.40% | 0.69% |

### Iii-H VGG and ResNet with CIFAR-10 Dataset

We compared the complexity and performance of the proposed efficient networks with the pruning results reported in [16, 35, 18, 41]. The VGG-16, ResNet-56, ResNet-20 networks with heterogeneous sensitivity were prepared using the CIFAR-10 dataset. The batch normalization and the dropout are used for the networks. The ratios of the weights remaining after the optimization and the classification errors are reported in Table VII. The efficient networks designed by the proposed method provide the same or higher performance but with less computational complexity.

# of FLOPs | # of weights | error | |||
---|---|---|---|---|---|

[16] | VGG-16 | baseline | 6.75% | ||

pruned | 65.6% | 36.0% | 6.60% | ||

[18] | VGG-16 | baseline | 6.67% | ||

pruned | 67.8% | 29.6% | 6.17% | ||

[41] | VGG-16 | baseline | |||

pruned | 59.4% | 6.33% | |||

proposed | VGG-16 | baseline | 6.67% | ||

proposed | 52.9% | 16.1% | 6.52% | ||

[16] | ResNet-56 | baseline | 6.96% | ||

pruned | 72.6% | 86.3% | 6.94% | ||

[34] | ResNet-56 | baseline | 7.20% | ||

pruned | 50.0% | N/A | 8.20% | ||

[18] | ResNet-56 | baseline | 6.82% | ||

pruned | 18.4% | 26.2% | 6.75% | ||

[41] | ResNet-56 | baseline | |||

pruned | 72.6% | 76.4% | 6.88% | ||

proposed | ResNet-56 | baseline | 6.82% | ||

proposed | 45.4% | 40.2% | 6.70% | ||

[35] | ResNet-20 | baseline | 8.82% | ||

pruned | N/A | N/A | 7.51% | ||

Proposed | ResNet-20 | baseline | 8.21% | ||

proposed | 66.2% | 72.3% | 6.76% |

### Iii-I ResNet with the ImageNet Dataset

The ResNet-50 network with heterogeneous sensitivity were prepared using the ImageNet dataset. The batch normalization and the dropout are used for the network. With the ImageNet dataset, the network converges very slowly with inconsistent improvement of the penalty function during the training. The regularization parameter is selected empirically and trained with the selected parameter. The ratios of the weights remaining after the optimization and the classification errors are reported in Table VIII where comparisons to the pruning results reported in [42, 43, 44, 45, 34] are also given. The efficient networks designed by the proposed method provide the same or higher performance but with less computational complexity.

# of FLOPs | # of weights | accuracy | ||

[42] | baseline | 72.88% | ||

pruned (ThiNet-70) | 63.2% | 63.3% | 72.04% | |

pruned (ThiNet-50) | 44.2% | 48.4% | 71.01% | |

pruned (ThiNet-30) | 28.4% | 33.9% | 68.42% | |

[43] | baseline | 72.88% | ||

pruned (Pruned-90) | 92.7% | 93.5% | 73.56% | |

pruned (Pruned-75) | 82.6% | 84.9% | 72.89% | |

pruned (Pruned-50) | 65.2% | 68.0% | 70.84% | |

[44] | baseline | 76.01% | ||

pruned (DCP) | 44.4% | 48.5% | 73.20% | |

pruned (WM+) | 44.4% | 48.5% | 72.89% | |

pruned (WM) | 44.4% | 48.5% | 70.84% | |

[45] | baseline | 76.01% | ||

pruned | N/A | 67.3% | 74.87% | |

[34] | baseline | 75.30% | ||

pruned | N/A | 64.0% | 72.30% | |

Proposed | baseline | 75.06% | ||

proposed | 68.6% | 56.3% | 75.03% |

## Iv Conclusion

In this study, we trained networks consisting of nodes with heterogeneous sensitivity to perform a given task using only a small number of sensitive nodes. The training is formulated as a constrained optimization problem whose parameter is found simultaneously during the training based on the L-curve. By introducing sensitivity layers that assign sensitivity variables to nodes, we were able to implement and train a network without using a complicated optimization tool. The networks trained in this manner possess a small and computationally efficient network architecture and simultaneously meet the performance criteria. In our experiments, the efficient networks designed by the proposed method provide the same or higher performance but with far less computational complexity. The proposed method can be used to determine the efficient network architectures of deep networks.

## References

- [1] A. Krizhevsky, I. Sutskever, and G. E. Hinton, “Imagenet classification with deep convolutional neural networks,” in Advances in neural information processing systems, 2012, pp. 1097–1105.
- [2] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus, “Intriguing properties of neural networks,” arXiv preprint arXiv:1312.6199, 2013.
- [3] K. Simonyan and A. Zisserman, “Very deep convolutional networks for large-scale image recognition,” arXiv preprint arXiv:1409.1556, 2014.
- [4] K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2016, pp. 770–778.
- [5] J. Redmon, S. Divvala, R. Girshick, and A. Farhadi, “You only look once: Unified, real-time object detection,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2016, pp. 779–788.
- [6] P. Baldi and K. Hornik, “Neural networks and principal component analysis: Learning from examples without local minima,” Neural networks, vol. 2, no. 1, pp. 53–58, 1989.
- [7] R. Reed, “Pruning algorithms-a survey,” IEEE transactions on Neural Networks, vol. 4, no. 5, pp. 740–747, 1993.
- [8] Y. Cheng, D. Wang, P. Zhou, and T. Zhang, “A survey of model compression and acceleration for deep neural networks,” arXiv preprint arXiv:1710.09282, 2017.
- [9] M. C. Mozer and P. Smolensky, “Skeletonization: A technique for trimming the fat from a network via relevance assessment,” in Advances in neural information processing systems, 1989, pp. 107–115.
- [10] Y. LeCun, J. S. Denker, and S. A. Solla, “Optimal brain damage,” in Advances in neural information processing systems, 1990, pp. 598–605.
- [11] E. Karmin, “A simple procedure for pruning back-propagation trained networks,” IEEE Transactions on Neural Networks, vol. 1, pp. 239–242, 1990.
- [12] B. Hassibi and D. G. Stork, “Second order derivatives for network pruning: Optimal brain surgeon,” in Advances in neural information processing systems, 1993, pp. 164–171.
- [13] S. Han, J. Pool, J. Tran, and W. Dally, “Learning both weights and connections for efficient neural network,” in Advances in neural information processing systems, 2015, pp. 1135–1143.
- [14] M. Ishikawa, “Structural learning with forgetting,” Neural networks, vol. 9, no. 3, pp. 509–521, 1996.
- [15] M. D. Collins and P. Kohli, “Memory bounded deep convolutional networks,” arXiv preprint arXiv:1412.1442, 2014.
- [16] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf, “Pruning filters for efficient convnets,” arXiv preprint arXiv:1608.08710, 2016.
- [17] H. Zhou, J. M. Alvarez, and F. Porikli, “Less is more: Towards compact cnns,” in European Conference on Computer Vision. Springer, 2016, pp. 662–677.
- [18] J. Jang, H. Cho, J. Kim, J. Lee, and S. Yang, “Deep asymmetric networks with a set of node-wise variant activation functions,” arXiv preprint arXiv:1809.03721, 2018.
- [19] P. C. Hansen and D. P. OÕLeary, “The use of the l-curve in the regularization of discrete ill-posed problems,” SIAM Journal on Scientific Computing, vol. 14, no. 6, pp. 1487–1503, 1993.
- [20] P. C. Hansen, “The l-curve and its use in the numerical treatment of inverse problems,” 1999.
- [21] ——, Rank-deficient and discrete ill-posed problems: numerical aspects of linear inversion. Siam, 2005, vol. 4.
- [22] P. C. Hansen, J. G. Nagy, and D. P. O’leary, Deblurring images: matrices, spectra, and filtering. Siam, 2006, vol. 3.
- [23] Y. Jia, E. Shelhamer, J. Donahue, S. Karayev, J. Long, R. Girshick, S. Guadarrama, and T. Darrell, “Caffe: Convolutional architecture for fast feature embedding,” arXiv preprint arXiv:1408.5093, 2014.
- [24] F. Chollet et al., “Keras,” 2015.
- [25] M. Abadi, P. Barham, J. Chen, Z. Chen, A. Davis, J. Dean, M. Devin, S. Ghemawat, G. Irving, M. Isard et al., “Tensorflow: A system for large-scale machine learning,” in 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI 16), 2016, pp. 265–283.
- [26] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” Proceedings of the IEEE, vol. 86, no. 11, pp. 2278–2324, 1998.
- [27] A. Krizhevsky and G. Hinton, “Learning multiple layers of features from tiny images,” 2009.
- [28] P. Lucey, J. F. Cohn, T. Kanade, J. Saragih, Z. Ambadar, and I. Matthews, “The extended cohn-kanade dataset (ck+): A complete dataset for action unit and emotion-specified expression,” in Computer Vision and Pattern Recognition Workshops (CVPRW), 2010 IEEE Computer Society Conference on. IEEE, 2010, pp. 94–101.
- [29] M. Everingham, S. M. A. Eslami, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman, “The pascal visual object classes challenge: A retrospective,” International Journal of Computer Vision, vol. 111, no. 1, pp. 98–136, Jan. 2015.
- [30] D. E. Rumelhart, G. E. Hinton, and R. J. Williams, “Learning representations by back-propagating errors,” nature, vol. 323, no. 6088, p. 533, 1986.
- [31] S. Haykin, “Neural networks, a comprehensive foundation,” Macmilan, Tech. Rep., 1994.
- [32] D. Calvetti, S. Morigi, L. Reichel, and F. Sgallari, “Tikhonov regularization and the l-curve for large discrete ill-posed problems,” Journal of computational and applied mathematics, vol. 123, no. 1-2, pp. 423–446, 2000.
- [33] K. Xie and L. Lu, “Lanczos algorithm based l-curve and curvature in image resolution enhancement,” in 2009 9th International Conference on Electronic Measurement & Instruments. IEEE, 2009, pp. 4–373.
- [34] Y. He, X. Zhang, and J. Sun, “Channel pruning for accelerating very deep neural networks,” in Proceedings of the IEEE International Conference on Computer Vision, 2017, pp. 1389–1397.
- [35] W. Wen, C. Wu, Y. Wang, Y. Chen, and H. Li, “Learning structured sparsity in deep neural networks,” in Advances in Neural Information Processing Systems, 2016, pp. 2074–2082.
- [36] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei, “Imagenet: A large-scale hierarchical image database,” in 2009 IEEE conference on computer vision and pattern recognition. Ieee, 2009, pp. 248–255.
- [37] I. Jolliffe, “Principal component analysis,” in International encyclopedia of statistical science. Springer, 2011, pp. 1094–1096.
- [38] Z. Yang, M. Moczulski, M. Denil, N. de Freitas, A. Smola, L. Song, and Z. Wang, “Deep fried convnets,” in Proceedings of the IEEE International Conference on Computer Vision, 2015, pp. 1476–1483.
- [39] V. Lebedev and V. Lempitsky, “Fast convnets using group-wise brain damage,” in Computer Vision and Pattern Recognition (CVPR), 2016 IEEE Conference on. IEEE, 2016, pp. 2554–2564.
- [40] S. Srinivas and R. V. Babu, “Data-free parameter pruning for deep neural networks,” arXiv preprint arXiv:1507.06149, 2015.
- [41] B. O. Ayinde and J. M. Zurada, “Building efficient convnets using redundant feature pruning,” arXiv preprint arXiv:1802.07653, 2018.
- [42] J.-H. Luo, J. Wu, and W. Lin, “Thinet: A filter level pruning method for deep neural network compression,” in Proceedings of the IEEE international conference on computer vision, 2017, pp. 5058–5066.
- [43] J.-H. Luo and J. Wu, “An entropy-based pruning method for cnn compression,” arXiv preprint arXiv:1706.05791, 2017.
- [44] Z. Zhuang, M. Tan, B. Zhuang, J. Liu, Y. Guo, Q. Wu, J. Huang, and J. Zhu, “Discrimination-aware channel pruning for deep neural networks,” in Advances in Neural Information Processing Systems, 2018, pp. 875–886.
- [45] X. Xu, M. S. Park, and C. Brick, “Hybrid pruning: Thinner sparse networks for fast inference on edge devices,” arXiv preprint arXiv:1811.00482, 2018.

Hyunjoong Cho received a B. S. degree in 2015 and an M.S. degree in 2017 from the Ulsan National Institute of Science and Technology, Ulsan, South Korea, where he is currently pursuing a doctor’s degree in electrical and computer engineering. His research interests include image processing, human perception, and human recognition. |

Jinhyeok Jang received a B.S. degree in 2014 and an M.S. degree in 2016 from the School of Electrical and Computer Engineering of the Ulsan National Institute of Science and Technology, Ulsan, South Korea. He currently works at the Electronics and Telecommunications Research Institute (ETRI), Daejeon, South Korea. His research interests include image processing, blur estimation, human facial recognition, and human action recognition. |

Chanhyeok Lee received a B.S. degree from the Ulsan National Institute of Science and Technology, Ulsan, South Korea, where he is currently pursuing a master’s degree in electrical and computer engineering. His research interests include image processing, image classification, and object detection. |

Seungjoon Yang (S’99-M’00) received a B.S. degree from Seoul National University, Seoul, Korea in 1990 and M.S. and Ph.D. degrees from the University of Wisconsin-Madison in 1993 and 2000, respectively, all in electrical engineering. He worked at the Digital Media R&D Center at Samsung Electronics Co., Ltd. from September 2000 to August 2008 and is currently with the School of Electrical and Computer Engineering at the Ulsan National Institute of Science and Technology in Ulsan, Korea. His research interests include image processing, estimation theory, and multi-rate systems. Professor Yang received the Samsung Award for the Best Technology Achievement of the Year in 2008 for his work on the premium digital television platform project. |