Towards Efficient Model Compression via Learned Global Ranking

TL;DR

This paper introduces LeGR, a method for efficiently generating multiple ConvNet models with various accuracy and latency trade-offs by learning a global filter ranking, simplifying the model compression process.

Contribution

LeGR is a novel algorithm that learns a global filter ranking to produce diverse compressed models, reducing the time and effort compared to traditional target-specific pruning methods.

Findings

LeGR is 2-3x faster than prior filter pruning methods.

LeGR achieves comparable or better accuracy-FLOPs trade-offs on CIFAR-100.

Effective on ImageNet and Bird-200 datasets with ResNet-50 and MobileNetV2.

Abstract

Pruning convolutional filters has demonstrated its effectiveness in compressing ConvNets. Prior art in filter pruning requires users to specify a target model complexity (e.g., model size or FLOP count) for the resulting architecture. However, determining a target model complexity can be difficult for optimizing various embodied AI applications such as autonomous robots, drones, and user-facing applications. First, both the accuracy and the speed of ConvNets can affect the performance of the application. Second, the performance of the application can be hard to assess without evaluating ConvNets during inference. As a consequence, finding a sweet-spot between the accuracy and speed via filter pruning, which needs to be done in a trial-and-error fashion, can be time-consuming. This work takes a first step toward making this process more efficient by altering the goal of model compression to producing a set of ConvNets with various accuracy and latency trade-offs instead of producing one ConvNet targeting some pre-defined latency constraint. To this end, we propose to learn a global ranking of the filters across different layers of the ConvNet, which is used to obtain a set of ConvNet architectures that have different accuracy/latency trade-offs by pruning the bottom-ranked filters. Our proposed algorithm, LeGR, is shown to be 2x to 3x faster than prior work while having comparable or better performance when targeting seven pruned ResNet-56 with different accuracy/FLOPs profiles on the CIFAR-100 dataset. Additionally, we have evaluated LeGR on ImageNet and Bird-200 with ResNet-50 and MobileNetV2 to demonstrate its effectiveness. Code available at https://github.com/cmu-enyac/LeGR.

Equations

$$I_i={\alpha }_{l(i)}{\Vert {\mathbf{\Theta }}_{\mathbf{i}}\Vert }_2^2+{\kappa }_{l(i)},$$

$$\text{arg}\underset{\mathbf{\alpha },\mathbf{\kappa }}{\max }Ac{c}_{val}(\widehat{{\mathbf{\Theta }}_{\mathbf{l}}})$$

$$\widehat{{\mathbf{\Theta }}_{\mathbf{l}}}=\text{LeGR-Pruning}(\mathbf{\alpha },\mathbf{\kappa },{\hat{\zeta }}_l).$$

$$\begin{array}{r}\underset{\mathbf{z}}{\min }\mathbb{L}(\mathbf{\Theta }\odot \mathbf{z}-\eta \sum _{j=1}^{\tau }\Delta {\mathbf{w}}^{(j)}\odot \mathbf{z})-\mathbb{L}(\mathbf{\Theta })\\ \text{s.t.}C(\mathbf{z})\le \zeta ,\end{array}$$

$$\begin{array}{rl}& \mathbb{L}(\mathbf{\Theta }\odot \mathbf{z}-\eta \sum _{j=1}^{\tau }\Delta {\mathbf{w}}^{(j)}\odot \mathbf{z})-\mathbb{L}(\mathbf{\Theta })\\ \le & \mathbb{L}(\mathbf{\Theta }\odot \mathbf{z})+\sum _{i=1}^K{\Omega }_{l(i)}\eta \Vert \sum _{j=1}^{\tau }\Delta {\mathbf{w}}_i^{(j)}\odot {\mathbf{z}}_i\Vert -\mathbb{L}(\mathbf{\Theta })\\ \le & \sum _{i=1}^K{\Omega }_{l(i)}\Vert {\mathbf{\Theta }}_i\Vert {\mathbf{h}}_i+\sum _{i=1}^K{\Omega }_{l(i)}^2\eta \tau {\mathbf{z}}_i\\ =& \sum _{i=1}^K({\Omega }_{l(i)}\Vert {\mathbf{\Theta }}_i\Vert -{\Omega }_{l(i)}^2\eta \tau ){\mathbf{h}}_i+{\Omega }_{l(i)}^2\eta \tau ,\end{array}$$

$$R_{l(i)}=u_{l(i)}{\Vert \{\mathbf{z}:{\mathbf{z}}_j\forall j\in P(l(i)\}\Vert }_0,u_{l(i)}\ge 0,$$

$$C(1-\mathbf{h})=\sum _i^K{R}_{l(i)}(1-{\mathbf{h}}_i)\le \sum _i^K{\hat{R}}_{l(i)}(1-{\mathbf{h}}_i).$$

$$\begin{array}{r}\underset{\mathbf{h}}{\min }\sum _{i=1}^K\left({\alpha }_{l(i)}\Vert {\mathbf{\Theta }}_i\Vert +{\kappa }_{l(i)}\right){\mathbf{h}}_i,\end{array}$$

Full text

1 Introduction

Building on top of the success of visual perception [49, 17, 18], natural language processing [10, 11], and speech recognition [6, 45] with deep learning, researchers have started to explore the possibility of embodied AI applications. In embodied AI, the goal is to enable agents to take actions based on perceptions in some environments [51]. We envision that next generation embodied AI systems will run on mobile devices such as autonomous robots and drones, where compute resources are limited and thus, will require model compression techniques for bringing such intelligent agents into our lives.

In particular, pruning the convolutional filters in ConvNets, also known as filter pruning, has shown to be an effective technique [63, 36, 60, 32] for trading accuracy for inference speed improvements. The core idea of filter pruning is to find the least important filters to prune by minimizing the accuracy degradation and maximizing the speed improvement. State-of-the-art filter pruning methods [16, 20, 36, 70, 46, 8] require a target model complexity of the whole ConvNet (e.g., total filter count, FLOP count111The number of floating-point operations to be computed for a ConvNet to carry out an inference., model size, inference latency, etc.) to obtain a pruned network. However, deciding a target model complexity for optimizing embodied AI applications can be hard. For example, considering delivery with autonomous drones, both inference speed and precision of object detectors can affect the drone velocity [3], which in turn affects the inference speed and precision222Higher velocity requires faster computation and might cause accuracy degradation due to the blurring effect of the input video stream.. For an user-facing autonomous robot that has to perform complicated tasks such as MovieQA [56], VQA [2], and room-to-room navigation [1], both speed and accuracy of the visual perception module can affect the user experience. These aforementioned applications require many iterations of trial-and-error to find the optimal trade-off point between speed and accuracy of the ConvNets.

More concretely, in these scenarios, practitioners would have to determine the sweet-spot for model complexity and accuracy in a trial-and-error fashion. Using an existing filter pruning algorithm many times to explore the impact of the different accuracy-vs.-speed trade-offs can be time-consuming. Figure 1 demonstrates the usage of filter pruning for optimizing ConvNets in aforementioned scenarios. With prior approaches, one has to go through the process of finding constraint-satisfying pruned-ConvNets via a pruning algorithm for every model complexity considered until practitioners are satisfied with the accuracy-vs.-speedup trade-off. Our work takes a first step toward alleviating the inefficiency in the aforementioned paradigm. We propose to alter the objective of pruning from outputting a single ConvNet with pre-defined model complexity to producing a set of ConvNets that have different accuracy/speed trade-offs, while achieving comparable accuracy with state-of-the-art methods (as shown in Figure 4). In this fashion, the model compression overhead can be greatly reduced, which results in a more practical usage of filter pruning.

To this end, we propose learned global ranking (or LeGR), an algorithm that learns to rank convolutional filters across layers such that the ConvNet architectures of different speed/accuracy trade-offs can be obtained easily by dropping the bottom-ranked filters. The obtained architectures are then fine-tuned to generate the final models. In such a formulation, one can obtain a set of architectures by learning the ranking once. We demonstrate the effectiveness of the proposed method with extensive empirical analyses using ResNet and MobileNetV2 on CIFAR-10/100, Bird-200, and ImageNet datasets. The main contributions of this work are as follows:

• •

We propose learned global ranking (LeGR), which produces a set of pruned ConvNets with different accuracy/speed trade-offs. LeGR is shown to be faster than prior art in ConvNet pruning, while achieving comparable accuracy with state-of-the-art methods on three datasets and two types of ConvNets.

• •

Our formulation towards pruning is the first work that considers learning to rank filters across different layers globally, which addresses the limitation of prior art in magnitude-based filter pruning.

2 Related Work

Various methods have been developed to compress and/or accelerate ConvNets including weight quantization [47, 71, 29, 30, 65, 24, 12, 7], efficient convolution operators [25, 22, 61, 26, 67], neural architecture search [69, 9, 4, 15, 54, 53, 52], adjusting image resolution [55, 5], and filter pruning, considered in this paper. Prior art on filter pruning can be grouped into two classes, depending on whether the architecture of the pruned-ConvNet is assumed to be given.

Pre-defined architecture

In this category, various work proposes different metrics to evaluate the importance of filters locally within each layer. For example, some prior work [32, 19] proposes to use $\ell_{2}$-norm of filter weights as the importance measure. On the other hand, other work has also investigated using the output discrepancy between the pruned and unpruned network as an importance measure [23, 40]. However, the key drawback for methods that rank filters locally within a layer is that it is often hard to decide the overall target pruned architectures [20]. To cope with this difficulty, uniformly pruning the same portion of filters across all the layers is often adopted [19].

Learned architecture

In this category, pruning algorithms learn the resulting structure automatically given a controllable parameter to determine the complexity of the pruned-ConvNet. To encourage weights with small magnitudes, Wen et al. [60] propose to add group-Lasso regularization to the filter norm to encourage filter weights to be zeros. Later, Liu et al. [36] propose to add Lasso regularization on the batch normalization layer to achieve pruning during training. Gordon et al. [16] propose to add compute-weighted Lasso regularization on the filter norm. Huang et al. [27] propose to add Lasso regularization on the output neurons instead of weights. While the regularization pushes unimportant filters to have smaller weights, the final thresholding applied globally assumes different layers to be equally important. Later, Louizos et al. [39] have proposed $L_{0}$ regularization with stochastic relaxation. From a Bayesian perspective, Louizos et al. [38] formulate pruning in a probabilistic fashion with a sparsity-induced prior. Similarly, Zhou et al. [70] propose to model inter-layer dependency. From a different perspective, He et al. propose an automated model compression framework (AMC) [20], which uses reinforcement learning to search for a ConvNet that satisfies user-specified complexity constraints.

While these prior approaches provide competitive pruned-ConvNets under a given target model complexity, it is often hard for one to specify the complexity parameter when compressing a ConvNet in embodied AI applications. To cope with this, our work proposes to generate a set of pruned-ConvNets across different complexity values rather than a single pruned-ConvNet under a target model complexity.

We note that some prior work gradually prunes the ConvNet by alternating between pruning out a filter and fine-tuning, and thus, can also obtain a set of pruned-ConvNets with different complexities. For example, Molchanov et al. [43] propose to use the normalized Taylor approximation of the loss as a measure to prune filters. Specifically, they greedily prune one filter at a time and fine-tune the network for a few gradient steps before the pruning proceeds. Following this paradigm, Theis et al. [57] propose to switch from first-order Taylor to Fisher information. However, our experiment results show that the pruned-ConvNet obtained by these methods have inferior accuracy compared to the methods that generate a single pruned ConvNet.

To obtain a set of ConvNets across different complexities with competitive performance, we propose to learn a global ranking of filters across different layers in a data-driven fashion such that architectures with different complexities can be obtained by pruning out the bottom-ranked filters.

3 Learned Global Ranking

The core idea of the proposed method is to learn a ranking for filters across different layers such that a ConvNet of a given complexity can be obtained easily by pruning out the bottom rank filters. In this section, we discuss our assumptions and formulation toward achieving this goal.

As mentioned earlier in Section 1, often both accuracy and latency of a ConvNet affect the performance of the overall application. The goal for model compression in these settings is to explore the accuracy-vs.-speed trade-off for finding a sweet-spot for a particular application using model compression. Thus, in this work, we use FLOP count for the model complexity to sample ConvNets. As we will show in Section 5.3, we find FLOP count to be predictive for latency.

3.1 Global Ranking

To obtain pruned-ConvNets with different FLOP counts, we propose to learn the filter ranking globally across layers. In such a formulation, the global ranking for a given ConvNet just needs to be learned once and can be used to obtain ConvNets with different FLOP counts. However, there are two challenges for such a formulation. First, the global ranking formulation enforces an assumption that the top-performing smaller ConvNets are a proper subset of the top-performing larger ConvNets. The assumption might be strong because there are many ways to set the filter counts across different layers to achieve a given FLOP count, which implies that there are opportunities where the top-performing smaller network can have more filter counts in some layers but fewer filter counts in some other layers compared to a top-performing larger ConvNet. Nonetheless, this assumption enables the idea of global filter ranking, which can generate pruned ConvNets with different FLOP counts efficiently. In addition, the experiment results in Section 5.1 show that the pruned ConvNets under this assumption are competitive in terms of performance with the pruned ConvNets obtained without this assumption. We state the subset assumption more formally below.

Assumption 1** (Subset Assumption)**

For an optimal pruned ConvNet with FLOP count $f$, let $\mathcal{F}(f)_{l}$ be the filter count for layer $l$. The subset assumption states that $\mathcal{F}(f)_{l}~{}\leq~{}\mathcal{F}(f^{\prime})_{l}~{}\forall~{}l$ if $f~{}\leq~{}f^{\prime}$.

Another challenge for learning a global ranking is the hardness of the problem. Obtaining an optimal global ranking can be expensive, i.e., it requires $O(K\times K!)$ rounds of network fine-tuning, where $K$ is the number of filters. Thus, to make it tractable, we assume the filter norm is able to rank filters locally (intra-layer-wise) but not globally (inter-layer-wise).

Assumption 2** (Norm Assumption)**

$\ell_{2}$* norm can be used to compare the importance of a filter within each layer, but not across layers.*

We note that the norm assumption is adopted and empirically verified by prior art [32, 62, 20]. For filter norms to be compared across layers, we propose to learn layer-wise affine transformations over filter norms. Specifically, the importance of filter $i$ is defined as follows:

[TABLE]

where $l(i)$ is the layer index for the $i^{th}$ filter, $\left\lVert\cdot\right\rVert_{2}$ denotes $\ell_{2}$ norms, $\bm{\Theta_{i}}$ denotes the weights for the $i^{th}$ filter, and $\bm{\alpha}\in\mathbb{R}^{L}$, $\bm{\kappa}\in\mathbb{R}^{L}$ are learnable parameters that represent layer-wise scale and shift values, and $L$ denotes the number of layers. We will detail in Section 3.2 how $\bm{\alpha}$-$\bm{\kappa}$ pairs are learned so as to maximize overall accuracy.

Based on these learned affine transformations from Eq. (1) (i.e., the $\bm{\alpha}$-$\bm{\kappa}$ pair), the LeGR-based pruning proceeds by ranking filters globally using $\bm{I}$ and prunes away bottom-ranked filters, i.e., smaller in $\bm{I}$, such that the FLOP count of interest is met, as shown in Figure 2. This process can be done efficiently without the need of training data (since the knowledge of pruning is encoded in the $\bm{\alpha}$-$\bm{\kappa}$ pair).

3.2 Learning Global Ranking

To learn $\bm{\alpha}$ and $\bm{\kappa}$, one can consider constructing a ranking with $\bm{\alpha}$ and $\bm{\kappa}$ and then uniformly sampling ConvNets across different FLOP counts to evaluate the ranking. However, ConvNets obtained with different FLOP counts have drastically different validation accuracy, and one has to know the Pareto curve333A Pareto curve describes the optimal trade-off curve between two metrics of interest. Specifically, one cannot obtain improvement in one metric without degrading the other metric. The two metrics we considered in this work are accuracy and FLOP count. of pruning to normalize the validation accuracy across ConvNets obtained with different FLOP counts. To address this difficulty, we propose to evaluate the validation accuracy of the ConvNet obtained from the lowest considered FLOP count as the objective for the ranking induced by the $\bm{\alpha}$-$\bm{\kappa}$ pair. Concretely, to learn $\bm{\alpha}$ and $\bm{\kappa}$, we treat LeGR as an optimization problem:

[TABLE]

where

[TABLE]

LeGR-Pruning prunes away the bottom-ranked filters until the desired FLOP count is met as shown in Figure 2. $\hat{\zeta}_{l}$ denotes the lowest FLOP count considered. As we will discuss later in Section 5.1, we have also studied how $\hat{\zeta}$ affects the performance of the learned ranking, i.e., how the learned ranking affects the accuracy of the pruned networks.

Specifically, to learn the $\bm{\alpha}$-$\bm{\kappa}$ pair, we rely on approaches from hyper-parameter optimization literature. While there are several options for the optimization algorithm, we adopt the regularized evolutionary algorithm (EA) proposed in [48] for its effectiveness in the neural architecture search space. The pseudo-code for our EA is outlined in Algorithm 1. We have also investigated policy gradients for solving for the $\bm{\alpha}$-$\bm{\kappa}$ pair, which is shown in Appendix B. We can equate each $\bm{\alpha}$-$\bm{\kappa}$ pair to a network architecture obtained by LeGR-Pruning. Once a pruned architecture is obtained, we fine-tune the resulting architecture by $\hat{\tau}$ gradient steps and use its accuracy on the validation set444We split 10% of the original training set to be used as validation set. as the fitness (i.e., validation accuracy) for the corresponding $\bm{\alpha}$-$\bm{\kappa}$ pair. We note that we use $\hat{\tau}$ to approximate $\tau$ (fully fine-tuned steps) and we empirically find that $\hat{\tau}=200$ gradient updates work well under the pruning settings across the datasets and networks we study. More concretely, we first generate a pool of candidates ($\bm{\alpha}$ and $\bm{\kappa}$ values) and record the fitness for each candidate, and then repeat the following steps: (i) sample a subset from the candidates, (ii) identify the fittest candidate, (iii) generate a new candidate by mutating the fittest candidate and measure its fitness accordingly, and (iv) replace the oldest candidate in the pool with the generated one. To mutate the fittest candidate, we randomly select a subset of the layers $Layer$ and conduct one step of random-walk from their current values, i.e., $\alpha_{l},\kappa_{l}~{}\forall~{}l\in Layer$.

We note that our layer-wise affine transformation formulation (Eq. 1) can be interpreted from an optimization perspective. That is, one can upper-bound the loss difference between a pre-trained ConvNet and its pruned-and-fine-tuned counterpart by assuming Lipschitz continuity on the loss function, as detailed in Appendix A.

4 Evaluations

4.1 Datasets and Training Setting

Our work is evaluated on various image classification benchmarks including CIFAR-10/100 [31], ImageNet [50], and Birds-200 [58]. CIFAR-10/100 consists of 50k training images and 10k testing images with a total of 10/100 classes to be classified. ImageNet is a large scale image classification dataset that includes 1.2 million training images and 50k testing images with 1k classes to be classified. Also, we benchmark the proposed algorithm in a transfer learning setting since in practice, we want a small and fast model on some target datasets. Specifically, we use the Birds-200 dataset that consists of 6k training images and 5.7k testing images covering 200 bird species.

For Bird-200, we use 10% of the training data as the validation set used for early stopping and to avoid over-fitting. The training scheme for CIFAR-10/100 follows [19], which uses stochastic gradient descent with nesterov [44], weight decay $5e^{-4}$, batch size 128, $1e^{-1}$ initial learning rate with decrease by 5$\times$ at epochs 60, 120, and 160, and train for 200 epochs in total. For control experiments with CIFAR-100 and Bird-200, the fine-tuning after pruning is done as follows: we keep all training hyper-parameters the same but change the initial learning rate to $1e^{-2}$ and train for 60 epochs (i.e., $\tau\approx 21$k). We drop the learning rate by $10\times$ at 30%, 60%, and 80% of the total epochs, i.e., epochs 18, 36, and 48. To compare numbers with prior art on CIFAR-10 and ImageNet, we follow the number of iterations in [72]. Specifically, for CIFAR-10 we fine-tuned for 400 epochs with initial learning rate $1e^{-2}$, drop by $5\times$ at epochs 120, 240, and 320. For ImageNet, we use pre-trained models and we fine-tuned the pruned models for 60 epochs with initial learning rate $1e^{-2}$, drop by $10\times$ at epochs 30 and 45.

For the hyper-parameters of LeGR, we select $\hat{\tau}=200$, i.e., fine-tune for 200 gradient steps before measuring the validation accuracy when searching for the $\bm{\alpha}$-$\bm{\kappa}$ pair. We note that we do the same for AMC [20] for a fair comparison. Moreover, we set the number of architectures explored to be the same with AMC, i.e., 400. We set mutation rate $u=10$ and the hyper-parameter of the regularized evolutionary algorithm by following prior art [48]. In the following experiments, we use the smallest $\zeta$ considered as $\hat{\zeta}_{l}$ to search for the learnable variables $\bm{\alpha}$ and $\bm{\kappa}$. The found $\bm{\alpha}$-$\bm{\kappa}$ pair is used to obtain the pruned networks at various FLOP counts. For example, for ResNet-56 with CIFAR-100 (Figure 3(a)), we use $\hat{\zeta}_{l}=20\%$ to obtain the $\bm{\alpha}$-$\bm{\kappa}$ pair and use the same $\bm{\alpha}$-$\bm{\kappa}$ pair to obtain the seven networks ($\zeta=20\%,...,80\%$) with the flow described in Figure 2. The ablation of $\hat{\zeta}_{l}$ and $\hat{\tau}$ are detailed in Sec. 5.2.

We prune filters across all the convolutional layers. We group dependent channels by summing up their importance measure and prune them jointly. The importance measure refers to the measure after learned affine transformations. Specifically, we group a channel in depth-wise convolution with its corresponding channel in the preceding layer. We also group channels that are summed together through residual connections.

4.2 CIFAR-100 Results

In this section, we consider ResNet-56 and MobileNetV2 and we compare LeGR mainly with four filter pruning methods, i.e., MorphNet [16], AMC [20], FisherPruning [57], and a baseline that prunes filters uniformly across layers. Specifically, the baselines are determined such that one dominant approach is selected from different groups of prior art. We select one approach [16] from pruning-while-learning approaches, one approach [20] from pruning-by-searching methods, one approach [57] from continuous pruning methods, and a baseline extending magnitude-based pruning to various FLOP counts. We note that FisherPruning is a continuous pruning method where we use 0.0025 learning rate and perform 500 gradient steps after each filter pruned following [57].

As shown in Figure 3(a), we first observe that FisherPruning does not work as well as other methods and we hypothesize the reason for it is that the small fixed learning rate in the fine-tuning phase makes it hard for the optimizer to get out of local optima. Additionally, we find that FisherPruning prunes away almost all the filters for some layers. On the other hand, we find that all other approaches outperform the uniform baseline in a high-FLOP-count regime. However, both AMC and MorphNet have higher variances when pruned more aggressively. In both cases, LeGR outperforms prior art, especially in the low-FLOP-count regime.

More importantly, our proposed method aims to alleviate the cost of pruning when the goal is to explore the trade-off curve between accuracy and inference latency. From this perspective, our approach outperforms prior art by a significant margin. More specifically, we measure the average time of each algorithm to obtain the seven pruned ResNet-56 across the FLOP counts in Figure 3(a) using our hardware (i.e., NVIDIA GTX 1080 Ti). Figure 3(b) shows the efficiency of AMC, MorphNet, FisherPruning, and the proposed LeGR. The cost can be broken down into two parts: (1) pruning: the time it takes to search for a network that has some pre-defined FLOP count and (2) fine-tuning: the time it takes for fine-tuning the weights of a pruned network. For MorphNet, we consider three trials for each FLOP count to find an appropriate hyper-parameter $\lambda$ to meet the FLOP count of interest. The numbers are normalized to the cost of LeGR. In terms of pruning time, LeGR is $7\times$ and $5\times$ faster than AMC and MorphNet, respectively. The efficiency comes from the fact that LeGR only searches the $\bm{\alpha}$-$\bm{\kappa}$ pair once and re-uses it across FLOP counts. In contrast, both AMC and MorphNet have to search for networks for every FLOP count considered. FisherPruning always prune one filter at a time, and therefore the lowest FLOP count level considered determines the pruning time, regardless of how many FLOP count levels we are interested in.

4.3 Comparison with Prior Art

Although the goal of this work is to develop a model compression method that produces a set of ConvNets across different FLOP counts, we also compare our method with prior art that focuses on generating a ConvNet for a specified FLOP count.

CIFAR-10

In Table 1, we compare LeGR with prior art that reports results on CIFAR-10. First, for ResNet-56, we find that LeGR outperforms most of the prior art in both FLOP count and accuracy dimensions and performs similarly to [19, 72]. For VGG-13, LeGR achieves significantly better results compared to prior art.

ImageNet Results

For ImageNet, we prune ResNet-50 and MobileNetV2 with LeGR to compare with prior art. For LeGR, we learn the ranking using 47% FLOP count for ResNet-50 and 50% FLOP count for MobileNetV2, and use the learned ranking to obtain ConvNets for other FLOP counts of interest. We have compared to 17 prior methods that report pruning performance for ResNet-50 and/or MobileNetV2 on the ImageNet dataset. While our focus is on the fast exploration of the speed and accuracy trade-off curve for filter pruning, our proposed method is better or comparable compared to the state-of-the-art methods as shown in Figure 4. The detailed numerical results are in Appendix C. We would like to emphasize that to obtain a pruned-ConvNet with prior methods, one has to run the pruning algorithm for every FLOP count considered. In contrast, our proposed method learns the ranking once and uses it to obtain ConvNets across different FLOP counts.

4.4 Transfer Learning: Bird-200

We analyze how LeGR performs in a transfer learning setting where we have a model pre-trained on a large dataset, i.e., ImageNet, and we want to transfer its knowledge to adapt to a smaller dataset, i.e., Bird-200. We prune the fine-tuned network on the target dataset directly following the practice in prior art [68, 40]. We first obtain fine-tuned MobileNetV2 and ResNet-50 on the Bird-200 dataset with top-1 accuracy 80.2% and 79.5%, respectively. These are comparable to the reported values in prior art [33, 41]. As shown in Figure 5, we find that LeGR outperforms Uniform and AMC, which is consistent with previous analyses in Section 4.2.

5 Ablation Study

5.1 Ranking Performance and $\hat{\zeta}_{l}$

To learn the global ranking with LeGR without knowing the Pareto curve in advance, we use the minimum considered FLOP count ($\hat{\zeta}_{l}$) during learning to evaluate the performance of a ranking. We are interested in understanding how this design choice affects the performance of LeGR. Specifically, we try LeGR targeting ResNet-56 for CIFAR-100 with $\hat{\zeta}_{l}~{}\in\{20\%,40\%,60\%,80\%\}$. As shown in Figure 6, we first observe that rankings learned using different FLOP counts have similar performances, which empirically supports Assumption 1. More concretely, consider the network pruned to $40\%$ FLOP count by using the ranking learned at $40\%$ FLOP count. This case does not take advantage of the subset assumption because the entire learning process for learning $\bm{\alpha}$-$\bm{\kappa}$ is done only by looking at the performance of the $40\%$ FLOP count network. On the other hand, rankings learned using other FLOP counts but employed to obtain pruned-networks at $40\%$ FLOP count have exploited the subset assumption (e.g., the ranking learned for $80\%$ FLOP count can produce a competitive network for $40\%$ FLOP count). We find that LeGR with or without employing Assumption 1 results in similar performance for the pruned networks.

5.2 Fine-tuned Iterations

Since we use $\hat{\tau}$ to approximate $\tau$ when learning the $\bm{\alpha}$-$\bm{\kappa}$ pair, it is expected that the closer $\hat{\tau}$ to $\tau$, the better the $\bm{\alpha}$-$\bm{\kappa}$ pair LeGR can find. We use LeGR to prune ResNet-56 for CIFAR-100 and learn $\bm{\alpha}$-$\bm{\kappa}$ at three FLOP counts $\hat{\zeta}_{l}\in\{10\%,30\%,50\%\}$. We consider $\zeta$ to be exactly $\hat{\zeta}_{l}$ in this case. For $\hat{\tau}$, we experiment with $\{0,50,200,500\}$. We note that once the $\bm{\alpha}$-$\bm{\kappa}$ pair is learned, we use LeGR-Pruning to obtain the pruned ConvNet, fine-tune it for $\tau$ steps, and plot the resulting test accuracy. In this experiment, $\tau$ is set to 21120 gradient steps (60 epochs). As shown in Figure 7, the results align with our intuition in that there are diminishing returns in increasing $\hat{\tau}$. We observe that $\hat{\tau}$ affects the accuracy of the pruned ConvNets more when learning the ranking at a lower FLOP count level, which means in low-FLOP-count regimes, the validation accuracy after fine-tuning a few steps might not be representative. This makes sense since when pruning away a lot of filters, the network can be thought of as moving far away from the local optimal, where the gradient steps early in the fine-tuning phase are noisy. Thus, more gradient steps are needed before considering the accuracy to be representative of the fully-fine-tuned accuracy.

5.3 FLOP count and Runtime

We demonstrate the effectiveness of filter pruning in wall-clock time speedup using ResNet-50 and MobileNetV2 on PyTorch 0.4 using two types of CPUs. Specifically, we consider both a desktop level CPU, i.e., Intel i7, and an embedded CPU, i.e., ARM A57, and use LeGR as the pruning methodology. The input is a single RGB image of size 224x224 and the program (Python with PyTorch) is run using a single thread. As shown in Figure 8, filter pruning can produce near-linear acceleration (with a slope of approximately 0.6) without specialized software or hardware support.

6 Conclusion

To alleviate the bottleneck of using model compression in optimizing the ConvNets in a large system, we propose LeGR, a novel formulation for practitioners to explore the accuracy-vs-speed trade-off efficiently via filter pruning. More specifically, we propose to learn layer-wise affine transformations over filter norms to construct a global ranking of filters. This formulation addresses the limitation that filter norms cannot be compared across layers in a learnable fashion and provides an efficient way for practitioners to obtain ConvNet architectures with different FLOP counts. Additionally, we provide a theoretical interpretation of the proposed affine transformation formulation. We conduct extensive empirical analyses using ResNet and MobileNetV2 on datasets including CIFAR, Bird-200, and ImageNet and show that LeGR has less training cost to generate the pruned ConvNets across different FLOP counts compared to prior art while achieving comparable performance to state-of-the-art pruning methods.

Acknowledgement

This research was supported in part by NSF CCF Grant No. 1815899, NSF CSR Grant No. 1815780, and NSF ACI Grant No. 1445606 at the Pittsburgh Supercomputing Center (PSC).

Appendix A Optimization Interpretation of LeGR

LeGR can be interpreted as minimizing a surrogate of a derived upper bound for the loss difference between (1) the pruned-and-fine-tuned CNN and (2) the pre-trained CNN. Concretely, we would like to solve for the filter masking binary variables $\mathbf{z}\in\{0,1\}^{K}$, with $K$ being the number of filters. If a filter $k$ is pruned, the corresponding mask will be zero ($z_{k}=0$), otherwise it will be one ($z_{k}=1)$. Thus, we have the following optimization problem:

[TABLE]

where $\mathbf{\Theta}$ denotes all the filters of the CNN, $\mathbb{L}(\mathbf{\Theta})=\frac{1}{|D|}\sum_{(x,y)\in D}~{}L(f(x|\mathbf{\Theta}),y)$ denotes the loss function of filters where $x$ and $y$ are the input and label, respectively. $D$ denotes the training data, $f$ is the CNN model and $L$ is the loss function for prediction (e.g., cross entropy loss). $\eta$ denotes the learning rate, $\tau$ denotes the number of gradient steps, $\Delta\bm{w}^{(j)}$ denotes the gradient with respect to the filter weights computed at step $j$, and $\odot$ denotes element-wise multiplication. On the constraint side, $C(\cdot)$ is the modeling function for FLOP count and $\zeta$ is the desired FLOP count constraint. By fine-tuning, we mean updating the filter weights with stochastic gradient descent (SGD) for $\tau$ steps.

Let us assume the loss function $\mathbb{L}$ is $\Omega_{l}$-Lipschitz continuous for the $l$-th layer of the CNN, then the following holds:

[TABLE]

where $l(i)$ is the layer index for the $i$-th filter, $\mathbf{h}=\mathbf{1}-\mathbf{z}$, and $\left\lVert\cdot\right\rVert$ denotes $\ell_{2}$ norms.

On the constraint side of equation (4), let $R_{l(i)}$ be the FLOP count of layer $l(i)$ where filter $i$ resides. Analytically, the FLOP count of a layer depends linearly on the number of filters in its preceding layer:

[TABLE]

where $P(l(i))$ returns a set of filter indices for the layer that precedes layer $l(i)$ and $u_{l(i)}$ is a layer-dependent positive constant. Let $\hat{R}_{l(i)}$ denote the FLOP count for layer $l(i)$ for the pre-trained network ($\mathbf{z}=\mathbf{1}$), one can see from equation (6) that $R_{l(i)}\leq\hat{R}_{l(i)}~{}\forall i,\mathbf{z}$. Thus, the following holds:

[TABLE]

Based on equations (5) and (7), instead of minimizing equation (4), we minimize its upper bound in a Lagrangian form. That is,

[TABLE]

where $\alpha_{l(i)}=\Omega_{l(i)}$ and $\kappa_{l(i)}=\eta\tau\Omega_{l(i)}^{2}-\lambda\hat{R}_{l(i)}$. To guarantee the solution will satisfy the constraint, we rank all filters by their scores $s_{i}=\alpha_{l(i)}\left\lVert\mathbf{\Theta}_{i}\right\rVert+\kappa_{l(i)}~{}\forall~{}i$ and threshold out the bottom ranked (small in scores) filters such that the constraint $C(\mathbf{1}-\mathbf{h})\leq\zeta$ is satisfied and $\left\lVert\mathbf{h}\right\rVert_{0}$ is maximized. That is, LeGR can be viewed as learning to estimate $\bm{\alpha}$ and $\bm{\kappa}$ by assuming that better estimates of $\bm{\alpha}$-$\bm{\kappa}$ produce a better solution for the original objective (4) by solving the surrogate of the upper bound (8).

Appendix B LeGR-DDPG

We have also tried learning the layer-wise affine transformations with actor-critic policy gradient (DDPG), which is adopted in prior art [20]. We use DDPG in a sequential fashion that follows [20]. LeGR requires two continuous actions (i.e., $\alpha_{l}$ and $\kappa_{l}$) for layer $l$ while AMC needs only one action (i.e., percentage). We conduct the comparison of pruning ResNet-56 to 50% of its original FLOP count targeting CIFAR-100 with $\hat{\tau}=0$ and hyper-parameters following [20]. As shown in Fig. 9(a), while both LeGR and AMC outperform random search (iterations before the vertical black-dotted line), LeGR converges faster to a better solution. Beyond comparing the progress of searching, we also compare the performance of the final pruned networks. As shown in Fig. 9(b), searching layer-wise affine transformations is more efficient and effective compared to searching the layer-wise filter percentages. Comparing LeGR using the two policy improvement methods, we empirically find that DDPG incurs larger variance on the final network than evolutionary algorithm.

Appendix C ImageNet Result Detail

The comparison of LeGR with prior art on ImageNet is detailed in Table 2.