How Compact?: Assessing Compactness of Representations through Layer-Wise Pruning

TL;DR

This paper introduces a layer-wise pruning method that automatically determines the importance of each layer to optimize compression without performance loss, revealing the most compact representations in deep neural networks.

Contribution

A novel importance-based layer-wise sparsity determination method for DNN pruning that adapts compression levels per layer based on their importance.

Findings

Achieved up to 75% better top-5 accuracy with the same sparsity on VGG-16.

Validated the method across different architectures and datasets.

Identified the most compact network representations through layer-wise analysis.

Abstract

Various forms of representations may arise in the many layers embedded in deep neural networks (DNNs). Of these, where can we find the most compact representation? We propose to use a pruning framework to answer this question: How compact can each layer be compressed, without losing performance? Most of the existing DNN compression methods do not consider the relative compressibility of the individual layers. They uniformly apply a single target sparsity to all layers or adapt layer sparsity using heuristics and additional training. We propose a principled method that automatically determines the sparsity of individual layers derived from the importance of each layer. To do this, we consider a metric to measure the importance of each layer based on the layer-wise capacity. Given the trained model and the total target sparsity, we first evaluate the importance of each layer from the model. From the evaluated importance, we compute the layer-wise sparsity of each layer. The proposed method can be applied to any DNN architecture and can be combined with any pruning method that takes the total target sparsity as a parameter. To validate the proposed method, we carried out an image classification task with two types of DNN architectures on two benchmark datasets and used three pruning methods for compression. In case of VGG-16 model with weight pruning on the ImageNet dataset, we achieved up to 75% (17.5% on average) better top-5 accuracy than the baseline under the same total target sparsity. Furthermore, we analyzed where the maximum compression can occur in the network. This kind of analysis can help us identify the most compact representation within a deep neural network.

Figures

Tables

Table 1. Table 1: Simple DNN model architecture. Conv and FC mean convolutional and fully connected layer, respectively.

Layer	Filter size	Output size	Activation
Conv1	$(3,3,3,32)$	$(32,32,32)$	ReLU
Conv2	$(3,3,32,32)$	$(32,32,32)$	ReLU
Maxpool	$(2,2)$	$(16,16,32)$
Conv3	$(3,3,32,64)$	$(16,16,64)$	ReLU
Conv4	$(3,3,64,64)$	$(16,16,64)$	ReLU
Maxpool	$(2,2)$	$(8,8,32)$
FC1	$(2048,512)$	$(1,512)$	ReLU
FC2	$(512,10)$	$(1,10)$	Softmax

Table 2. Table 2: Performance evaluation for the baseline, other state-of-the-art methods and the proposed method using a VGG-16 model on the CIFAR-10 dataset. We pruned Conv layers only for fair comparison. ratio(param) and ratio(FLOP) mean pruned ratio in number of parameters and FLOPs, respectively. To compute Δ e ​ r ​ r subscript Δ 𝑒 𝑟 𝑟 \Delta_{err} , ratio(param) and ratio(FLOP) of other methods, we referred the test error, # params and # FLOPs written in their papers.

Method	Error (%)	${\Delta }_{err}$	# params.	ratio(param)	# FLOPs	ratio(FLOP)
Original	6.41		15.0M		$3.13\times {10}^8$
Baseline	7.42	+1.01	5.4M	64.0%	$1.13\times {10}^8$	64.0%
(?)	6.60	-0.15	5.4M	64.0%	$2.06\times {10}^8$	34.2%
Proposed	6.25	-0.16	5.4M	64.0%	$2.46\times {10}^8$	21.6%
(?)-A	6.33	+0.13	3.23M	78.1%	$1.86\times {10}^8$	40.5%
(?)-B	6.70	+0.50	3.23M	78.1%	$1.86\times {10}^8$	40.5%
Proposed	6.53	+0.12	3.23M	78.5%	$2.13\times {10}^8$	32.1%

Equations

$$\sum _{l=1}^L{s}_l{N}_l=sN,$$

$$(1-s_l)N_l=\alpha {\omega }_l,$$

$$\sum _{l=1}^L(1-s_l)N_l$$

$$\sum _{l=1}^L\alpha {\omega }_l$$

$$\alpha =\frac{(1-s)N}{\Omega }.$$

$$s_l$$

$$=1-(1-s)\frac{N}{N_l}\frac{{\omega }_l}{\Omega }.$$

$${\mu }_l:=\underset{x^l\in S_l}{\max }\frac{||W^l{x}^l||}{||W^l|{|}_F||x^l||},$$

$$e_l\propto \frac{\beta }{{\mu }_l^2},$$

$$s_l$$

$$=1-(1-s)\frac{N}{N_l}\frac{M}{{\mu }_l^2},$$

$$\underset{ϵ}{\min }$$

$${\xi }_l\le \alpha (1+{\epsilon }_l){\omega }_l\le N_l\text{ for all l=1,⋯,L},$$

$$\sum _l\alpha (1+{\epsilon }_l){\omega }_l=(1-s)N,$$

$$\mathcal{D}:=\{ϵ\in {\mathbb{R}}^L:{\xi }_l\le \alpha (1+{\epsilon }_l){\omega }_l\le N_l\text{ for l=1,⋯,L}\}.$$

$$f({ϵ}_{max})=\sum _{l=1}^L{N}_l=N\ge (1-s)N.$$

$$f({ϵ}_{min})=\sum _{l=1}^L{\xi }_l\le (1-s)N.$$

$$C(\hat{s})=(1-s)N.$$

Full text

INTRODUCTION

In recent years, DNN models have been used for a variety of artificial intelligence (AI) tasks such as image classification (?; ?; ?), semantic segmentation (?), and object detection (?). The need for integrating such models into devices with limited on-board computing power have been growing consistently. However, to extend the usage of large and accurate DNN models to resource-constrained devices such as mobile phones, home appliances, or IoT devices, compressing DNN models while maintaining their performance is an imperative.

A recent study (?) demonstrates that making large DNN models sparse by pruning can consistently outperform directly trained small-dense DNN models. In pruning DNN models, we would like to address the following problem: “How can we determine the target sparsity of individual layers?”. Most existing methods set the layer-wise sparsity to be uniformly fixed to a single target sparsity (?) or adopt layer-wise sparsity manually (?; ?).

Starting from the assumption that not all layers in a DNN model have equal importance, we propose a new method that automatically computes the sparsity of individual layers according to layer-wise importance.

The contributions of the proposed method are as follows:

• •

The proposed method can analytically compute the layer-wise sparsity of DNN models. The computed layer-wise sparsity value enables us to prune the DNN model more efficiently than pruning with uniform sparsity for all layers. In our experiments, we validate that the proposed layer-wise sparsity scheme can compress DNN models more than the uniform-layer sparsity scheme while retaining the same classification accuracy.

• •

The proposed method can be combined with any pruning method that takes total target sparsity as an input parameter. Such a condition is general in compression tasks because users usually want to control the trade-off between compression ratio and performance. In our experiments, we utilized three different pruning approaches (weight pruning by ? ?, random channel pruning, and channel pruning by ? ?) for compression. Other pruning approaches are also applicable.

• •

The proposed method can be applied to any DNN architecture because it does not require any constraint on the DNN architectures (e.g., ? ?; ? ? requires batch normalization layer to prune DNN model).

• •

To compute the layer-wise sparsity, we do not require additional training or evaluation steps which take a long time.

RELATED WORKS

Pruning is a simple but efficient method for DNN model compression. ? (?) showed that making large DNN models sparse by pruning can outperform small-dense DNN models trained from scratch. There are many pruning methods according to the granularity of pruning from weight pruning (?; ?) to channel pruning (?; ?; ?; ?; ?). These approaches mainly focused on how to select the redundant weights/filters in the model, rather than considering how many weights/filters need to be pruned in each layer.

However, considering the role of each layer is critical for efficient compression. ? (?) measured the noise sensitivity of each layer and tried to use it to compute the most effective number of parameters for each layer.

Recently, ? (?) proposed Automated Deep Compression (ADC). They aimed to automatically find the sparsity ratio of each layer which is similar to our goal. However, they used reinforcement learning to find the sparsity ratio and characterized the state space as a layout of layer, i.e., kernel dimension, input size, and FLOPs of a layer, etc.

In this paper, we focus on directly measuring the importance of each layer for the given task and the model. We used the value of the weight matrix itself rather than the layout of the layer. We will show considering layer-wise importance in DNN compression is effective.

PROBLEM FORMULATION

Our goal is to compute the sparsity of each layer in the model given the total target sparsity of the model. In this section we derive the relation between the total target sparsity $s$ of a model and the sparsity of each layer while considering the importance of each layer.

Let $s_{l}\in[0,1)$, $l=1,\cdots L$, be the layer sparsity of the $l$-th layer where $L$ is the total number of layers in the model. Then, the layer sparsity $s_{l}$ should satisfy the following condition:

[TABLE]

where $N_{l}$ is the number of parameters in the $l$-th layer and $N$ is the total number of parameters in the model.

A DNN model is usually overparameterized and it contains many redundant parameters. Pruning aims at removing such parameters from every layer and leaving only the important ones. So, if a large proportion of parameters in a layer is important for the given task, the layer should not be pruned too much while otherwise the layer should be pruned aggressively. Hence, it is natural to consider the importance of a layer when we determine the layer sparsity.

We assume that the number of remaining parameters in the $l$-th layer after pruning is proportional to the importance of the $l$-th layer, $\omega_{l}$. Because the number of remaining parameters for the $l$-th layer is equal to $(1-s_{l})N_{l}$, we have,

[TABLE]

where $\alpha>0$ is a constant. Because we want all layers to equally share the number of pruned parameters with respect to the importance of each layer, $\alpha$ is set to be independent of the layer index.

By summing both sides over all the layers, we obtain

[TABLE]

where $\Omega$ is the sum of importance of all layers. From (Eq. 3) and (Eq. 4), we can easily compute $\alpha$, i.e.,

[TABLE]

The above equation can be seen as the ratio of the total number of remained parameters and the sum of importance of all layers which is proportional to the total number of effective parameters.

When $\alpha=1$, the number of remaining parameters determined by $s$ is the same as the number of effective parameters. In that case, we can readily prune parameters in each layer. When $\alpha<1$, then the number of remaining parameters becomes smaller than the number of effective parameters. Therefore, we need to prune some effective parameters. In this case, $\alpha$ acts as a distributor that equally allocates the number of pruning effective parameters to all layers. Thanks to the $\alpha$, the compression is prevented from pruning a specific layer too much. In the case of $\alpha>1$, it acts similar to the case of $\alpha<1$ but allocates the number of pruning redundant parameters instead.

Because all factors consisting $\alpha$ are automatically determined by the given model, we can control the above pruning cases by controlling $s$ only, which we desired.

By combining (Eq. 2) and (Eq. 5), we obtain the layer-wise sparsity as

[TABLE]

The remaining problem is: How can we compute the layer-wise importance $\omega_{l}$? We propose metric to measure the importance of each layer based on the layer-wise capacity. In the subsection below, we will explain the metric in detail.

Layer-wise Capacity

We measure the importance of a layer using the layer capacity induced by noise sensitivity (?). Based on the definition (?), the authors proved that a matrix having low noise sensitivity has large singular values (i.e., low rank). They identified the effective number of parameters of a DNN model by measuring the capacity of mapping operations (e.g., convolution or multiplication with a matrix) which is inverse proportional to the noise sensitivity. The layer capacity has an advantage of directly counting the effective number of parameters in a layer. However, they only consider a linear network having fully connected layers or convolutional layers.

Motivated by the work, we use the concept of capacity to compute layer-wise sparsity. The layer capacity $\mu_{l}$ of the $l$-th layer is defined as

[TABLE]

where $W^{l}$ is a mapping (e.g., convolution filter or multiplication with a weight matrix) of the $l$-th layer and $x^{l}$ is the input of the $l$-th layer. $||\cdot||$ and $||\cdot||_{F}$ are $l^{2}$ norm and the Frobenius norm of the operator, respectively. $S_{l}$ is a set of inputs of the $l$-th layer. In other words, $\mu_{l}$ is the largest number that satisfies $\mu_{l}||W^{l}||_{F}||x^{l}||=||W^{l}x^{l}||$.

According to the work (?) and (Eq. 7), the mapping having large capacity has low rank and hence small number of effective parameters. Therefore, we let the effective number of parameters to be inverse proportional to the layer-wise capacity. More specifically, the effective number of parameters $e_{l}$ of the $l$-th layer can be written as,

[TABLE]

where $\beta$ is a constant.

In fact, $\beta$ might be different across layers because other attributes such as the depth of layers (distance from the input layer) would affect the number of effective parameters. In this paper, however, we set $\beta$ to be constant for simplicity and focus on the layer-wise capacity.

We assume that the layer having a large number of effective parameters (in other words, having small capacity) should not be pruned too much. Therefore, we can set the importance of the $l$-th layer $\omega_{l}$ to be the number of effective parameters $e_{l}$, i.e, $\omega_{l}=e_{l}$. Then, (Eq. PROBLEM FORMULATION) becomes,

[TABLE]

where $E$ and $M$ are the sum of $e_{l}$ and $1/{\mu_{l}^{2}}$ for all layers, respectively. Because the value of $s_{l}$ is independent of the value of $\beta$, $s_{l}$ can be obtained without any knowledge of the value of $\beta$.

PRUNING WITH LAYER-WISE SPARSITY

In this section, we explain our proposed DNN model compression process with layer-wise sparsity. Given the total target sparsity, we first compute the layer-wise importance of each layer from the two proposed metrics (layer-wise performance gain and layer-wise capacity). According to (Eq. Layer-wise Capacity), we can compute layer-wise sparsity easily.

However, there are some issues in computing the actual layer-wise sparsity. First, the user might want to control the minimum number of remaining parameters. In the worst case, the required number of pruned parameters for a layer might be equal or larger than the total number of parameters in the layer. Second, the exact number of pruned parameters would be different from the computed sparsity from (Eq. PROBLEM FORMULATION). For example, in channel pruning, the number of pruned parameters in the $(l-1)$th layer also affects the $l$-th layer.

To handle those problems, we re-formulate (Eq. PROBLEM FORMULATION) as an optimization problem. The objective function is defined as,

[TABLE]

where $\xi_{l}$ is the minimum number of remaining parameters after pruning. $\epsilon=(\varepsilon_{1},\cdots,\varepsilon_{L})$ is the vector of layer-wise perturbations on the constant $\alpha$. That is, though we set the number of pruned parameters of each layer equally proportional to the importance of the layer, we perturb the degree of pruning of each layer by adding $\varepsilon_{l}$ to $\alpha$ in unavoidable cases.

Proposition 1

If $\sum_{l=1}^{L}\xi_{l}\leq(1-s)N$, then a solution of the optimization problem (10) exists and it is unique.

**Proof. **Since $\left\|\epsilon\right\|^{2}$ is strictly convex in $\epsilon$, the optimization problem (10) has a unique solution if the problem is feasible. So it is enough to show that the constraint set of the problem is not empty. Denote the constraint set of the inequalities by

[TABLE]

Consider a continuous function $f\colon\mathcal{D}\to\mathbb{R}$ such that $f(\epsilon):=\sum_{l=1}^{L}\alpha(1+\varepsilon_{l})w_{l}$. If we take $\epsilon_{max}=(N_{1}/\alpha w_{1}-1,\cdots,N_{L}/\alpha w_{L}-1)$, then $\epsilon_{max}\in\mathcal{D}$ and

[TABLE]

Similarly, by taking $\epsilon_{min}=(\xi_{1}/\alpha w_{1}-1,\cdots,\xi_{L}/\alpha w_{L}-1)$, we have $\epsilon_{min}\in\mathcal{D}$ and

[TABLE]

By the provided condition, we know $\sum_{l=1}^{L}\xi_{l}\leq(1-s)N\leq N$. Then the continuity of $f$ yields that there exists a point $\tilde{\epsilon}\in\mathcal{D}$ such that $f(\tilde{\epsilon})=(1-s)N$, which completes our proof.

Intuitively, Proposition 1 says that the total target sparsity $s$ of pruning should not violate the constraint of the minimum number of remaining parameters. Let us assume $\sum_{l=1}^{L}\xi_{l}\leq(1-s)N$ to guarantee the feasibility of the optimization problem. We then can apply vairous convex optimization algorithms to obtain the optimal solution $\epsilon^{*}$ (?).

Remark that our proposed method does not require model training or evaluation to find the values of layer sparsities. We obtain analytically the layer sparsity without additional training or evaluation. Many existing works (?; ?) use a trial and error approach for searching for the best combination of hyperparameters such as the layer sparsity $s_{l}$. Evaluating each combination through additional training or evaluation is necessary which makes these approaches not feasible on large datasets.

Our method requires convex optimization in a small dimensional space that has negligible computing time in general. The total calculation time mainly depends on the time spent by calculating the layer capacity $\mu_{l}$ by (Eq. 7). Although it is required to compute the norm of each input vectors induced by the whole dataset, it has approximately similar computing costs as inferencing. Our approach has an advantage in terms of computation time.

With our implementation computing (Eq. 7) took less than 3 hours for VGG16 model with the ImageNet dataset in a single GPU machine. For VGG-16 model with the CIFAR-10 dataset, the total computation time of (Eq. 7) was less than 1 minute on the same hardware setup. The most time consuming part of our implementation was calculating the Frobenius norm of each layer. There could be more speed up if we use an approximate value of norms or use a subset of the data set instead of the whole data set. However, these are out of the scope of this paper so we will not discuss it any further.

Note that although here we assume that all layers in the model are compressed, selecting and compressing the subset of $1,\cdots,L$ can easily be handled. Moreover, the process described below can also be applied to any pruning methods such as channel pruning or weight pruning.

Selection of Target Sparsity for Channel Pruning

In the experiments, we applied the proposed layer-wise sparsity method to both weight pruning and channel pruning.

However, in case of channel pruning, a pruned layer affects the input dimension of the next layer. So the actual number of pruned parameters may differ from our expectation. As a consequence, our proposed method does not achieve the exact total target sparsity $s$ (over-pruned in usual) by channel pruning. In fact, the exact number of remaining parameters by channel pruning depends on the topology of a neural network and properties of each layer, e.g. the kernel size of a convolution layer. So an exact formulation of the number of remaining parameters is not mathematically tractable.

To overcome such a limitation we need to consider a method to achieve the total target sparsity. Because the value of $s$ in our proposed method can be considered as the compression strength in pruning, we can find the exact sparsity $\hat{s}$ from the $s$. Let $C(s)$ be the actual number of remaining parameters in a model after applying channel pruning with sparsity $s$, i.e., the $l$-th layer is pruned by the sparsity $s_{l}$ induced by (10). Then the total target sparsity is achievable if we use the value $\hat{s}$ instead of the total target sparsity $s$. Finally, the problem becomes finding proper $\hat{s}$ that satisfies,

[TABLE]

Because both solving (10) and counting the number of parameters require low computational costs, the value of $\hat{s}$ can be obtained in reasonable time. We therefore can control the achieved sparsity of the model by using $\hat{s}$ in case of channel pruning.

EXPERIMENTAL RESULTS

In this section, we investigate how much our proposed scheme affects the performance of a pruned model. To do this, we carried out an image classification task with the simple DNN and VGG-16 (?) model on the CIFAR-10 (?) and ImageNet (?) dataset.

In all experiments, we compared our layer-wise sparsity method with the uniform sparsity method which we use as the baseline. To investigate how much robust our proposed scheme is to different pruning methods, we applied three pruning methods (magnitude-based weight pruning by ? ?, random channel pruning, and magnitude-based channel pruning by ? ?) to DNN architectures.

We set $\xi_{l}$ as $3\times w_{l}\times h_{l}\times c_{l-1}$ where $c_{l-1}$ is the number of input channels for the $l$-th layer and $w_{l}$ and $h_{l}$ is the spatial filter size of the $l$-th layer. In other words, we wanted to remain at least 3 channels for performance.

We implemented the proposed method using Keras (?). For the VGG-16 model on the ImageNet dataset, we used pre-trained weights in Keras, and for the VGG-16 model on the CIFAR-10 dataset, we used pre-trained weights from (?). The simple DNN model was designed and trained by ourselves.

Simple DNN Model on CIFAR-10 Dataset

Table 1 shows the architecture of the simple DNN model used in this experiment. To compress the model, we applied pruning to Conv2-4 and FC1 layers. After pruning is done, we can additionally apply (optional) fine-tuning to improve performance. Therefore we checked the accuracy of both pruned and fine-tuned models to investigate the resilience of the proposed method. For fine-tuning, we ran 3 epochs with learning rate = 0.0001.

Because the computation of layer-wise sparsity is not affected by the choice of pruning method, we need to compute layer-wise sparsity for the model only once. In the subsections below, therefore, we shared the computed layer-wise sparsity with all three pruning methods.

Weight Pruning

To prune weights, we used magnitude-based pruning (?). In other words, we pruned weights that have small absolute values because we can consider that they do not contribute much to the output.

Figure 1 shows the performance after compression. As we can see in the figure, the proposed method outperforms under all total target sparsities in pruning only case, and achieves similar or better results after fine-tuning. At large total target sparsity, the effect of the proposed method becomes apparent. For example, at total target sparsity 0.9, the accuracy of the proposed method drops by 0.179 after pruning only, while the baseline drops by 0.656.

Random Channel Pruning

To eliminate the effect of the details of a pruning algorithm, we also applied random pruning in channel. Given the total target sparsity, we computed the layer-wise sparsities and the number of required parameters to be pruned in order. Then the number of pruned channels is determined by applying floor operation to the number of pruned parameters. According to the computed number of pruned channels, we randomly selected which channels are pruned and repeated the selection 10 times.

We compared the classification accuracy of the proposed layer-wise sparsity scheme against the baseline. Figure 2 shows the results. Similar with weight pruning, the proposed layer-wise sparsity scheme also outperforms the baseline under all total target sparsities. As we can see in figure 2, the proposed method conducts compression reliably compared with the baseline method (smaller height of min-max bar than the baseline). Interestingly, the result of the proposed method after pruning outperforms the baseline method after fine-tuning.

Channel Pruning

We used channel pruning (?) to compress the model. The authors used the sum of absolute weights in a channel as the criteria for pruning. In other words, channels that have small magnitude weights are pruned. Figure 3 shows the results.

Numerically, the proposed method achieved up to 58.9% better classification accuracy than the baseline using the same total target sparsity. Please refer to the accuracy of the Baseline (p) and Proposed (p) at total target sparsity 0.6 in figure 3. In terms of compression ratio, the proposed method can prune up to 5 times more parameters than the baseline while retaining the same accuracy. Please compare the accuracy of the Baseline (p) at total target sparsity 0.1 and Proposed (p) at total target sparsity 0.5 in figure 3.

VGG-16 on CIFAR-10 Dataset

In this experiment, we applied pruning to all Conv and FC layers except the first and the last layers (Conv1 and FC2) in the VGG-16 model. For fine-tuning, we ran 3 epochs with learning rate = 0.0001 in all pruning cases.

Figure 4 shows the computed layer-wise sparsities under different total target sparsities, $s$. The computed sparsities confirm our assumption that all layers have different importance for the given task.

Random Channel Pruning

Similar to the simple DNN model, we repeated the random channel pruning 10 times and the result of pruning is shown in figure 5. Surprisingly, the proposed method achieves almost 90% maximum accuracy when total target sparsity is 0.8. Although the VGG-16 model is considered already quite overparameterized, we can still say that the proposed method efficiently compresses DNN models. The proposed method conduct compression reliably compared with the baseline method (smaller height of min-max bar than the baseline) as we can see in figure 5. Though the performance after pruning is the same with the random guessing or worse than the baseline when $s>0.2$, the performance is almost recovered (except the case $s=0.9$) after fine-tuning. This demonstrates that considering layer-wise sparsity helps not only pruning but also performance improvement with fine-tuning.

Channel Pruning

Figure 6 shows the results. Though the accuracy values after pruning only are worse than the baseline, the degree of performance improvement after fine-tuning is better than the baseline when $s>0.2$ except $s=0.9$.

Similar to the results of random channel pruning, the proposed method maintains the performance within 3% of the original model until the total target sparsity becomes 0.7.

Table 2 shows the performance comparison with other channel pruning methods. For fair comparison, we pruned Conv layers only. For fine-tuning, we ran 100 epochs with a constant learning rate 0.001 and select the best accuracy. As we can see in the Table, the proposed method won first place when the compressed model has 5.4M parameters and is in second place when the compressed model has 3.23M parameters. However, in performance drop ($\Delta_{err}$), the proposed method outperforms other methods in both cases. Our proposed method prunes more filters from the later layers than those from the former layers. It performs better in reducing the number of parameters, while it does not in reducing FLOPs as we can see in Table 2. However, reducing FLOPs can be easily achievable by reformulating (Eq. 1).

VGG-16 on ImageNet Dataset

In this experiment, we applied pruning to all Conv and FC layers except the first and the last layers (Conv1 and FC3) in the VGG-16 model on the ImageNet dataset.

Figure 7 shows the computed layer-wise sparsities under different total target sparsities. As we can see in the figure, the difference of layer-wise sparsity between layers. Surprisingly, the figure says that we only need prune two fully connected layers (FC1 and FC2) until the total target sparsity $s$ becomes 0.8. Such results are reasonable because more than 85% of total parameters in VGG are concentrated in the FC1 and FC2 layers. Therefore we can consider that there would be many redundant parameters in those layers. However, we can also see that the proposed method computes layer-wise sparsities not considering the number of parameters only, from the figure. For example, the number of parameters in FC1 layer is far lager than the FC2 layer but the sparsity of FC2 layer is larger than the FC1 layer. Conv11, Conv12, and Conv13 also represents similar results (all three layers have the same number of parameters).

Weight Pruning

Figure 8 shows the performance after compression. The proposed method outperforms the baseline under all target sparsities both top-1 and top-5 accuracy. Both methods maintain the performance until $s=0.4$. But when $s$ becomes larger than 0.4, the proposed method shows consistently better performance.

Channel Pruning

Figure 8 shows the compression results using channel pruning (?). Because the channel pruning removes bunch of parameters, distributing the number of reqired parameters to be pruned to all layers according to the layer-wise sparsity is harder than weight pruning. Therefore the performance is worse than the weight pruning but still outperforms the baseline method in both top-1 and top-5 accuracy cases.

From the above results, the proposed layer-wise sparsity scheme outperforms the baseline method except for few cases. We can validate our claim that not all layers have the same importance for the given task and the proposed layer-wise sparsity scheme is highly effective in various DNN models for compression by pruning.

CONCLUSION

In this paper, we proposed a new method that automatically computes the layer-wise sparsity from the layer-wise capacity for DNN model compression, especially pruning. Our proposed method does not require additional training or evaluation steps to compute the layer-wise sparsity, which has an advantage in terms of computation time. Experimental results validated the efficiency of the proposed layer-wise sparsity calculation in DNN model compression. Furthermore, the estimated layer-wise sparsity varied greatly across layers, suggesting that the information can be used to find where the most compact representation resides in the deep neural network.