Progressive Gradient Pruning for Classification, Detection and DomainAdaptation

TL;DR

This paper introduces Progressive Gradient Pruning, a novel iterative filter pruning method during training that improves neural network efficiency while maintaining accuracy, applicable to classification, detection, and domain adaptation tasks.

Contribution

The paper presents a new pruning technique with a novel filter selection criterion and adaptive momentum strategies, outperforming existing methods in efficiency and accuracy trade-offs.

Findings

Achieves better accuracy-complexity trade-off than existing methods

Effective for classification, detection, and domain adaptation

Reduces network size and energy consumption during training

Abstract

Although deep neural networks (NNs) have achievedstate-of-the-art accuracy in many visual recognition tasks,the growing computational complexity and energy con-sumption of networks remains an issue, especially for ap-plications on platforms with limited resources and requir-ing real-time processing. Filter pruning techniques haverecently shown promising results for the compression andacceleration of convolutional NNs (CNNs). However, thesetechniques involve numerous steps and complex optimisa-tions because some only prune after training CNNs, whileothers prune from scratch during training by integratingsparsity constraints or modifying the loss function.In this paper we propose a new Progressive GradientPruning (PGP) technique for iterative filter pruning dur-ing training. In contrast to previous progressive pruningtechniques, it relies on a novel filter selection criterion thatmeasures the change in filter weights, uses a new hard andsoft pruning strategy and effectively adapts momentum ten-sors during the backward propagation pass. Experimentalresults obtained after training various CNNs on image datafor classification, object detection and domain adaptationbenchmarks indicate that the PGP technique can achievea better trade-off between classification accuracy and net-work (time and memory) complexity than PSFP and otherstate-of-the-art filter pruning techniques.

Figures

Tables

Table 1. Table 1: Performance of pruning methods for training LeNet5 on the MNIST classification dataset.

Methods	$t_{\text{pruned}}$	Params	FLOPS	Error % ($\pm$ gap)
Baseline LeNet5	0%	61K	446k	0.84          (  0)
L1 [23]	30%	34.1K	304K	0.9   ( +0.06)
	50%	18K	152K	1.05    ( +0.21)
	70%	84K	82K	2.22   ( +1.38)
Taylor [32]	30%	38K	286K	0.9   ( +0.06)
	50%	24K	76K	1.05   ( +0.21)
	70%	13K	34K	1.22    ( +0.38)
DCP [46]	30%	42.7K	325K	2.75   ( +1.91)
	50%	30.5K	232K	4.18   ( +3.34)
	70%111Since DCP’s code, provided by the authors, did not handle non-residual architecture, we had to modified the original code. Pruning rate above 50% are struck on LeNet and VGG19	30.5K	232K	6.28   ( +5.44)
PSFP [12]	30%	34.1K	304K	1.32   ( +0.48)
	50%	18K	152K	2.27   ( +1.43)
	70%	84K	82K	2.99    ( +2.15)
PGP_GNG (ours)	30%	34.1K	304K	0.87   ( +0.03)
	50%	18K	152K	1.08    ( +0.24)
	70%	84K	82K	1.74     ( +0.9)
RPGP_GNS (ours)	30%	34.1K	304K	0.9    ( +0.06)
	50%	18K	152K	1.25   ( +0.41)
	70%	84K	82K	1.75    ( +0.91)

Table 2. Table 2: Performance of pruning methods for training ResNet20 on the MNIST classification dataset.

Methods	$t_{\text{pruned}}$	Params	FLOPS	Error % ($\pm$ gap)
Baseline Resnet20	0%	272K	41M	0.74         (  0)
L1 [23]	30%	137K	22M	0.75    ( +0.01)
	50%	68K	10M	1.09   ( +0.35)
	70%	27K	4.2M	2.02   ( +1.28)
Taylor [32]	30%	149K	17.7M	0.87   ( +0.13)
	50%	87K	7.8M	0.95   ( +0.21)
	70%	36K	2.6M	1.04    ( +0.30)
DCP [46]	30%	193K	30.3M	1.11    (+0.37)
	50%	138K	21.1M	0.62   ( -0.12)
	70%	87.7K	13.5M	1.19    ( +0.45)
PSFP [12]	30%	137K	22M	0.5     ( -0.24)
	50%	68K	10M	0.61    ( -0.13)
	70%	27K	4.2M	0.72    ( -0.02)
PGP_GNG (ours)	30%	137K	22M	0.4     ( -0.34)
	50%	68K	10M	0.51    ( -0.23)
	70%	27K	4.2M	0.57    ( -0.17)
RPGP_GNS (ours)	30%	137K	22M	0.4   ( -0.34)
	50%	68K	10M	0.48   ( -0.29)
	70%	27K	4.2M	0.5   ( -0.24)

Table 3. Table 3: Performance of pruning methods for training VGG19 on the CIFAR10 classification dataset.

Methods	$t_{\text{pruned}}$	Params	FLOPS	Error % ($\pm$ gap)
Baseline VGG19	0%	20M	400M	6.23          (0)
Li [23]	30%	9M	198M	16.94   (  +8.41)
	50%	5M	100M	16.51   (  +7.98)
	70%	1M	37M	16.17   (  +7.64)
Taylor [32]	30%	10M	156M	9.82    (  +2.29)
	50%	5M	72M	11.94   (  +3.41)
	70%	1.9M	24M	16.85   (  +8.32)
DCP [46]	30%	10M	221M	5.8   (  -0.65)
	50%	6M	158M	7.76   (  +1.53)
	70%††footnotemark:	6M	158M	7.86   (  +1.63)
PSFP [12]	30%	9M	198M	8.98    (  +2.75)
	50%	5M	100M	11.2    (  +4.97)
	70%	1M	37M	12.06   (  +5.83)
PGP_GNG (ours)	30%	9M	198M	7.37    (  +1.14)
	50%	5M	100M	8.38   (  +2.15)
	70%	1M	37M	9.7   (  +3.47)
RPGP_GNS (ours)	30%	9M	198M	7.65   (  +1.42)
	50%	5M	100M	8.79  (  +2.56)
	70%	1M	37M	10.56   (  +4.33)

Table 4. Table 4: Performance of pruning methods for training ResNet56 on the CIFAR10 classification dataset.

Methods	$t_{\text{pruned}}$	Params	FLOPS	Error % ($\pm$ gap)
Baseline Resnet56	0%	855K	128M	6.02        ( 0)
L1 [23]	30%	431K	67M	13.34   ( +7.32)
	50%	215K	32M	15.57   ( +9.55)
	70%	84K	13M	17.89 ( +11.87)
Taylor [32]	40%	491K	51M	13.9      ( +7.88)
	50%	268K	23M	15.34   ( +9.32)
	70%	100k	8M	22.1   ( +16.08)
DCP [46]	30%	600K	90M	5.67     ( -0.35)
	50%	430K	65M	6.43     ( +0.41)
	70%	270K	41M	7.18    ( +1.16)
PSFP [12]	30%	431K	67M	8.94    ( +2.92)
	50%	215K	32M	10.93    ( +4.91)
	70%	84K	13M	14.18   ( +8.16)
PGP_GNG (ours)	30%	431K	67M	8.95     ( +2.93)
	50%	215K	32M	10.59   ( +4.57)
	70%	84K	13M	13.02      ( +7)
RPGP_GNS (ours))	30%	431K	67M	9.37   ( +3.35)
	50%	215K	32M	10.46   ( +4.44)
	70%	84K	13M	14.16   ( +8.14)

Table 5. Table 5: Training and pruning time for pruning techniques with t prune = 0.5 subscript 𝑡 prune 0.5 t_{\text{prune}}=0.5 and 0.9 0.9 0.9 .

Methods	VGG19		Resnet56
$t_{\text{pruned}}$	0.5	0.9	0.5	0.9
Baseline	219m	219m	307m	307m
L1 [23]	(219)   + 32m	(219)   + 32m	(307)    + 48m	(307)    + 48m
Taylor [32]	(219)    + 254m	(219)   + 457m	(307)   + 488m	(307)   + 878m
DCP [46]	-	-	(307) + 489m	(307) + 443m
PSFP [12]	219m	219m	307m	307m
PGP (ours)	329m	329m	441m	441m
RPGP (ours)	211m	168m	263m	241m

Table 6. Table 6: Error rate for RPGP with different pruning criteria.

Networks	L2	Taylor	TW	GN_G	GN_S
VGG19	8.47%	9.27%	8.78%	8.47%	8.79%
ResNet56	10.30%	10.97%	10.46%	10.24%	10.28%

Table 7. Table 7: Error rates for RPGP and PSFP with L2.

Method	VGG19	ResNet56
PSFP	11.20%	10.93%
RPGP	8.47%	10.09%

Table 8. Table 8: Error rates of PSFP and RPGP with different pruning rates, when downsampling and last layers of residual connection are not pruned.

	$t_{\text{prune}}\times 100$%
Methods	30%	50%	70%	90%
PSFP	8.94	10.93	14.18	28.09
RPGP(GN_S)	8.87	10.09	11.02	13.94

Table 9. Table 9: Performance of pruning methods for training Faster R-CNN with VGG16 backbone on the Pascal VOC detection dataset with t pruned = 50 % subscript 𝑡 pruned percent 50 t_{\text{pruned}}=50\% .

Methods	Params	FLOPS	mAP	Training Time
Baseline VGG16	137M	250G	69.6%	428m
L1 [23]	125M	174G	62.3%	(428) + 31m
PSFP [12]	125M	174G	63.5%	428m
PGP_GNG (ours)	125M	174G	65.5%	769m
RPGP_GNS (ours)	125M	174G	66.0%	281m

Table 10. Table 10: Performance of our methods for training DAN with VGG16 backbone on Office-31 with t pruned = 20 % subscript 𝑡 pruned percent 20 t_{\text{pruned}}=20\% .

	Source-only	Baseline VGG	TCP	RPGP_GNS(ours)
FLOPS Reduction %	0%	0%	26%	35%
$A\to W$	68.5	74.0	76.1	78.2
$A\to D$	61.1	72.3	76.2	77.7
$W\to A$	41.6	55.2	51.2	51.6
$W\to D$	94.3	97.5	99.8	99.4
$D\to W$	94.5	94.0	96.1	96.5
$D\to A$	50.3	54.1	47.9	48.0
Average	68.3	74.5	74.5	75.2

Table 11. Table 11: Error rate for RPGP when trained from scratch compared to a trained model.

Training Scenario	VGG19	ResNet56
Scratch	8.79 %	10.46 %
Pre-trained	8.23 %	9.51 %

Table 12. Table 12: Error rate for RPGP for different removal rates r 𝑟 r .

Networks	$r=0.3$	$r=0.5$	$r=0.7$	$r=1.0$
VGG19	8.74%	8.79%	8.99%	8.92%
ResNet56	10.57%	10.46%	11.03%	10.78%

Equations

$$p_t=\exp \left(\frac{\log (1-t_{\text{prune}})}{T}t\right),$$

$$n_{\text{wc}}=n_c(1-p_t),$$

$${\text{W}}_{t+1}={\text{W}}_t-\alpha {\text{M}}_t$$

$${\text{M}}_t=\beta {\text{M}}_{t-1}+(1-\beta )\frac{\partial \mathcal{L}}{\partial {\text{W}}_t}$$

$${\text{M}}_t$$

$$\displaystyle\big{|}\Delta\mathcal{L}(\textbf{H}_{i})\big{|}=\scalebox{1.0}{$\big{|}\mathcal{L}(\mathcal{D}|\textbf{H}_{i}=0)-\mathcal{L}(\mathcal{D}|\textbf{H}_{i})\big{|}$}\approx\scalebox{1.0}{$\big{|}\frac{\partial\mathcal{L}}{\partial\textbf{H}_{i}}\textbf{H}_{i}\big{|}$}$$

$$\displaystyle\text{TW}=\scalebox{1.0}{$\big{|}\mathcal{L}(\mathcal{D}|\textbf{W}_{i}=0)-\mathcal{L}(\mathcal{D}|\textbf{W}_{i})\big{|}$}\approx\scalebox{1.0}{$\big{|}\frac{\partial\mathcal{L}}{\partial\textbf{W}_{i}}\textbf{W}_{i}\big{|}$}$$

$$\displaystyle\mbox{$\big{|}\frac{\partial\mathcal{L}}{\partial\textbf{W}_{i}}\textbf{W}_{i}\big{|}$}=\scalebox{1.0}{$\big{|}\frac{\partial\mathcal{L}}{\partial\textbf{W}_{i}}\big{|}\big{|}\textbf{W}_{i}\big{|}$}$$

$$\displaystyle\text{GN}_{i}=\scalebox{1.0}{$\big{|}\frac{\partial\mathcal{L}}{\partial\textbf{W}_{i}}\big{|}$}$$

$$\displaystyle\text{$GN_{G}$}^{i}=\scalebox{1.0}{$\big{|}\big{|}\sum_{j}^{N}{\textbf{G}_{ij}}\big{|}\big{|}_{1}$}$$

$$\displaystyle\text{$GN_{S}$}^{i}=\scalebox{1.0}{$\sum_{j}^{N}{||\textbf{G}_{ij}}||_{1}$}$$

$$||{\text{W}}_i^j|{|}_2$$

$$\displaystyle=\scalebox{1.0}{$||\textbf{W}_{i}^{j-2}-\alpha\frac{\partial\mathcal{L}^{j-2}}{\partial\textbf{W}_{i}^{j-2}}-\alpha\frac{\partial\mathcal{L}^{j-1}}{\partial\textbf{W}_{i}^{j-1}}||_{2}$}$$

$$\displaystyle=\scalebox{1.0}{$||\textbf{W}_{i}^{0}-\alpha\sum_{k=0}^{j}\frac{\partial\mathcal{L}^{k}}{\partial\textbf{W}_{i}^{k}}||_{2}$}$$

Full text

In this paper we propose a new Progressive Gradient Pruning (PGP) technique for iterative filter pruning during training. In contrast to previous progressive pruning techniques, it relies on a novel filter selection criterion that measures the change in filter weights, uses a new hard and soft pruning strategy and effectively adapts momentum tensors during the backward propagation pass. Experimental results obtained after training various CNNs on image data for classification, object detection and domain adaptation benchmarks indicate that the PGP technique can achieve a better trade-off between classification accuracy and network (time and memory) complexity than PSFP and other state-of-the-art filter pruning techniques.

1 Introduction

Convolutional neural networks (CNNs) learn discriminant feature representations from labeled training data, and have achieved state-of-the-art accuracy across a wide range of visual recognition tasks, e.g., image classification, object detection, and assisted medical diagnosis. Since the breakthrough results achieved with AlexNet for the 2012 ImageNet Challenge [20], CNN’s accuracy has been continually improved with architectures like VGG [39], ResNet [11] and DenseNet [17], at the expense of growing complexity (deeper and wider networks) that require more training samples and computational resources [18]. In particular, the speed of the CNNs can significantly degrade with such increased complexity.

In order to deploy these powerful CNN architectures on compact platforms with limited resources (e.g., embedded systems, mobile phones, portable devices) and for real-time processing (e.g., video surveillance and monitoring, virtual reality), the time and memory complexity and energy consumption of CNNs should be reduced. This is particularly true when the model also has to adapt to a new environment/domain. For instance, the application of CNN-based architectures to real-time face detection in video surveillance remains a challenging task [33], because of the complexity of real-time detection and the handling of different scenes, environments and camera angles. Currently, the more accurate detectors such as region proposal networks are too slow for real-time applications [38, 6], faster detectors such as single-shot detectors are less accurate [26, 36] and none of these are universal detector that can work on any new environment without domain adaptation. Consequently, effective methods to accelerate and compress deep networks, especially during training/domain adaptation are required to provide a reasonable trade-off between accuracy, efficiency and deployment time.

This paper focuses on filter-level pruning techniques. While it does not provide the compression level of unstructured pruning, the reduction of parameters can be converted in a real speed up while preserving network accuracy [23, 32]. These techniques attempt to remove the filters and input channels at each convolution layer using various criteria based on, e.g., L1 norm [23], or the product of feature maps and gradients[32]. Pruning techniques can be applied under two different scenarios: either (1) from a pre-trained network, or (2) from scratch. In the first scenario, pruning is applied as a post-processing procedure, once the network has already been trained, through an one-time pruning (followed by fine-tuning) [23] or complex iterative process [32] using a validation dataset [23, 29], or by minimizing the reconstruction error [30]. In the second scenario, pruning is applied from scratch by introducing sparsity constraints and/or modifying the loss function to train the network [27, 42, 46]. The later scenario can have more difficulty converging to accurate network solutions (due to the modified loss function), and thereby increase the computational complexity required for the optimisation process. For greater training efficiency, the progressive soft filter pruning (PSFP) method was recently introduced [12], allowing for iterative pruning from scratch, where filters are set to zero (instead of removing them) so that the network can preserve a greater learning capacity. This method, however, does not account for the optimization of soft pruned weights which can have an negative impact on accuracy, because pruned weights are still being optimized with old momentum values accumulated from previous epochs.

In this paper, a new Progressive Gradient-based Pruning (PGP) technique is proposed for iterative filter pruning to provide a better trade-off between accuracy and complexity. To this end, the filters are efficiently pruned in a progressive fashion while training a network from scratch, and accuracy is maintained without requiring validation data and additional optimisation constraints. In particular, PGP improves on PSFP by integrating hard and soft pruning strategies to effectively adapt the momentum tensor during the backward propagation pass. It also integrates an improved version of the Taylor selection criterion [32] that relies on the gradient w.r.t weights (instead of output feature maps), and is more suitable for progressive filter-based pruning. For performance evaluation, the accuracy and complexity of proposed and state-of-the-art filter pruning techniques are compared using Resnet, LeNet and VGG networks trained to address benchmark image classification (MNIST and CIFAR10 datasets), object detection (PASCAL VOC dataset) and domain adaptation (Office-31) problems. From our experiments we show that the proposed approach performs comparably or better than most of the previous techniques on image classification as well as object detection. Additionally, we also found that by performing pruning and domain adaptation jointly our method outperforms other approaches based on two separate steps.

2 Compression and Acceleration of CNNs

In general, time complexity of a CNN depends more on the convolutional layers, while the fully connected layers contain the most of the number of parameters. Therefore, the CNN acceleration methods typically target lowering the complexity of the convolutional layers, while the compression methods usually target reduced complexity of the fully connected layers[9, 10]. This section provides an overview of the recent acceleration and compression approaches for CNNs, namely, quantization, low-rank approximation, and network pruning. Finally, a brief survey on the filter pruning methods and challenges is presented.

2.1 Overview of methods:

Quantization:

A deep neural network can be accelerated by reducing the precision of its parameters. Such techniques are often used on general embedded systems, where low-precision, e.g., 8-bit integer, provides faster processing than the higher-precision representation, e.g., 32-bit floating point. There are two main approaches to quantizing a neural network – the first focuses on quantizing using weights[9, 45], and the second uses both weights and activations for quantization [7, 4]. These techniques can be either scalable [9, 45] or non-scalable [3, 7, 4, 35], where scalable techniques means that an already quantized network can be further compressed.

Low-rank decomposition:

Low-rank approximation (LRA) can accelerate CNNs by decomposing a tensor in lower rank approximations as vector products. [19, 40, 21].There are different ways of decomposing convolution tensor. Techniques like [19, 40] focus on approximating tensor by low rank tesnor that can be obtained either in a layer by layer fashion [19] or by scanning the whole network [40]. [43] proposes to force filers to coordinate more information into a lower rank space during training and then decompose it once the model is trained. Another technique employed the CP-Decomposition (Canonical Polyadic Decomposition), where a good trade-off between accuracy and efficiency is achieved [21].

Pruning:

Pruning is a family of techniques that removes non-useful parameters from a neural network. There are several approaches of pruning for deep neural networks. The first is weight pruning, where individual weights are pruned. This approach has proven to significantly compress and accelerates deep neural networks [9, 44, 10]. Weight pruning techniques usually employ sparse convolution algorithms [24, 37].The other approach is output channel or filter pruning, where complete output channel or filters are pruned [23, 30, 12, 46]. Since this paper proposes a method for filter pruning, we provide more details on this approach in the next section.

2.2 Filter pruning:

Following the work of Optical Brain Damage [5], one of the first papers that showed the efficiency of filter-level pruning was [23], where the weight norm is used to identify and prune weak filters, filters that do not contribute much to network. Afterwards, several works proposed pruning procedures and filter importance metrics. These methods can be organized in five pruning approaches: 1) Pruning as one time post processing and then fine tune– this approach is simple and easy to apply [23], 2) Pruning in an iterative way once the model was trained– the iterative pruning and fine-tune increase the chance of recovering accuracy loss directly after a filter is pruned [32, 31], 3) Pruning by minimizing the reconstruction error– minimizing the reconstruction error at each layer allows the model to approximate the original performance [30, 15, 46], 4) Pruning by using sparse constraints with a modified objective function– to let the network consider pruning during optimization [27, 2, 1, 22], 5) Pruning progressively while training from scratch or pre-trained model – soft pruning [13, 14] was applied where filters are set to zero instead of actually removing them (hard manner), which leaves the network with more capacity to learn [12].

While first three approaches are capable of reducing the complexity of a model, they are only applied when the model is already trained, it would certainly be more beneficial to be able to start pruning from scratch during training. While, the fourth approach can start the pruning from scratch by adding sparse constraints and by modifying the optimization objective, this makes the loss harder and more sensitive to optimize. This can be potentially complicated when the original loss function is hard to optimize since this type of approach modifies the original loss function therefore making it potentially harder for the model to converge to a good solution. The fifth approach eases this process by not removing filters and uses the original loss function. However, we think that this approach can be improved since, currently, this approach does not handle pruning in the backward pass and only set the weak filters to zero. Also, the current approach calculates the L2 criterion separately from when the parameters are updated, i.e. not when we are iterating inside an epoch. For our approach we want to directly compute the criterion during update, i.e. when we are iterating in an epoch and updating parameters.

Another important part of pruning filters is the capacity to evaluate the importance of a filter. In literature, there has been a lot of criteria that has been used to evaluate the importance of filters, e.g. L1 [23], APoz [16], Entropy [29], L2 [12] and Taylor [32]. Among these, the Taylor criterion [32] has the most potential for pruning during training since the criterion is the result of trying to minimize the impact of having a filter pruned.

3 Progressive Gradient Pruning

3.1 Pruning strategy with momentum:

In a regular CNN, the weight tensor of a convolutional layer $l$ can be defined as $\textbf{W}\in\mathbb{R}^{n_{\text{out}}\times n_{\text{in}}\times k\times k}$, where $n_{\text{in}}$ and $n_{\text{out}}$ are the number of input and output channels (filters), respectively. A weight tensor of filter $i$ can be then defined as $\textbf{W}_{i}\in\mathbb{R}^{n_{\text{in}}\times k\times k}$. In order to select the weak filters of a layer, we evaluate the importance of an filter using a criterion function $c$, is usually defined as $c(\textbf{W}_{i}):\mathbb{R}^{n_{\text{in}}\times k\times k}\xrightarrow{}\mathbb{R}$. Given an filter, it yields a scalar that represents the rank, e.g. L1 [23] or gradient norm in our case.

In order to prune convolution layer progressively, an exponential decay function is defined such that there is always a solution in $\mathbb{R}$. (It is slightly different than in [12], where the decay function can have solutions in $\mathbb{C}$.) This decay function allows to select the number of weak filters at each epoch. The decay function is defined as the ratio of filters remaining after the training on epoch $t$:

[TABLE]

where $t_{\text{prune}}$ is a hyper-parameter that defines the ratio of filters to be pruned, and $t\in\{1,2,\ldots,T\}$ is the epoch. Since we progressively prune layer by layer and epoch by epoch, we calculate the the number of weak filters or the number of remaining filters at each layer, $n_{\text{wc}}$. Given ratio $p_{t}$ at epoch $t$, the number of weak filters for any layer is defined as:

[TABLE]

where $n_{c}$ can be the original number of filters of any layers. Using the the number of weak filters $n_{\text{wc}}$ and a pruing criterion function $c$, we end up having a subset of filters $\textbf{W}_{\text{weak}}\in\mathbb{R}^{n_{\text{wc}}\times n_{\text{in}}\times k\times k}$ with the smallest value. This subset is further divided into two subsets, using a hyper-parameter $r$ that decides the ratio of hard-to-remove filters. The subset $\textbf{W}_{\text{rh}}\in\mathbb{R}^{(n_{\text{wc}}\cdot r)\times n_{\text{in}}\times k\times k}$ is removed completely, while the subset $\textbf{W}_{\text{rs}}\in\mathbb{R}^{n_{\text{wc}}\cdot(1-r)\times n_{\text{in}}\times k\times k}$ will be reset to zero while keeping $R_{h}$ and $R_{s}$ as indexes for the backward pass. Additionally, hard pruning is performed on the input channels of the next layer using $R_{h}$.

Figure 1 illustrates the hard and soft pruning strategy of the PGP technique, with the momentum tensor defined as $\textbf{M}\in\mathbb{R}^{n_{\text{out}}\times n_{\text{in}}\times k\times k}$, same dimension as a weight tensor. Using the indexes of $R_{s}$, we set to zero the subset $\textbf{M}_{\text{rs}}\in\mathbb{R}^{\dim(R_{s})\times n_{\text{in}}\times k\times k}$ and hard prune the subset $\textbf{M}_{\text{rh}}\in\mathbb{R}^{\dim(R_{h})\times n_{\text{in}}\times k\times k}$ using indexes $R_{h}$. Currently, progressive pruning techniques like [12], only the weights set to zero during training, without handling the previously-accumulated momentum accumulated which is critical for the optimization. As illustrated in Figure 2, momentum pruning is important for the optimization process.

Let us take a closer look at the typical equations for update of weight and momentum:

[TABLE]

[TABLE]

where $\textbf{W}_{t}$ and $\textbf{M}_{t}$ are respectively the weight and momentum tensors at iteration $t$, and $\alpha$ and $\beta$ are the learning rate and momentum hyper-parameters, respectively. By expanding $M_{t-1}$ in Equ. 4:

[TABLE]

The tensor $\textbf{M}_{t-1}$ depends on the previous gradient of weight at time $t-1$. Using a soft pruning technique (like PSFP), the momentum tensor $\textbf{M}_{t-1}$ using $\frac{\partial\mathcal{L}}{\partial\textbf{W}_{t-1}}$ is meaningless if W is soft pruned at $t$, since the weight is reset, meaning the optimization point is no longer the same. It is therefore important to adapt the momentum tensor during soft pruning. Our solution is to perform soft prune the momentum such that the weight tensor is correctly optimized.

3.2 Selection criteria:

Molchanov at al. [32] proposed the following criterion $|\Delta\mathcal{L}(\textbf{H}_{i})|$ to measure the importance of a feature map $\textbf{H}_{i}$ from a filter $\textbf{W}_{i}$, computed at each layer, and for each filter:

[TABLE]

The term $\mathcal{L}(\mathcal{D}|\textbf{H}_{i}=0)$ refers to the loss of a model when a labeled dataset $D$ is given with a pruned feature map $\textbf{H}_{i}=0$. $\mathcal{L}(\mathcal{D}|\textbf{H}_{i})$ is the original loss before the model has been pruned. In summary, the criterion of Equ. 6 is the difference between the loss of a pruned model and the original model. The criterion grows with the impact the feature map. This criterion has been shown to work well on some trained network. However, in the scenario where the network is pruned from scratch, we argue that information measured from feature map $\bf{H_{i}}$ is not informative since the model is not trained. Empirical results in Section 4 also support that the criterion of Equ. 6 is not effective at other criteria for progressive pruning.

Instead of using $\textbf{H}_{i}=0$ to prune a feature map [25] or filter, we can replace $\textbf{H}_{i}$ with $\textbf{W}_{i}$ since setting an filter to zero is the same as pruning it [12]. The same Taylor expansion from [32] then can applied with $\textbf{W}_{i}$, resulting in:

[TABLE]

Equ. 7 can be further simplified when taking in account the soft pruning nature. We can decomposed this equation because $|\frac{\partial\mathcal{L}}{\partial\textbf{W}_{i}}\textbf{W}_{i}|$ is an element-wise multiplication:

[TABLE]

where $|\textbf{W}_{i}|$ is the absolute value of the weight of filter $i$. This meant that $|\textbf{W}_{i}|$ can be or very close to zero if $\textbf{W}_{i}$ was one of the filter that was soft-pruned. In this case, $\textbf{W}_{i}$ has little chance to recover, since it will likely be pruned. In order to encourage more recovery on soft prune filters, we propose to remove the $|\textbf{W}_{i}|$ term:

[TABLE]

where $\text{GN}_{i}$ is the criterion for our approach for $i$ filter. There are two ways of calculating our criterion:

• •

PGP: performs a training epoch without updating the model, and compute the pruning criterion. This amounts to a batch gradient descent without updating the parameters at then end, and can provide better performance since the optimization is less noisy than SGD.

• •

RPGP: computes the pruning criterion directly during a forward-backward pass of training (while updating). This approach uses a SGD optimizer and calculates the criterion directly during the optimization and update of the model.

In either case, the criterion is applied over several iterations, so there are two ways of interpreting Equ. 9. One natural way of interpreting is by accumulating gradients, where the gradients are summed up to the total gradient of an filter. Since PGP goes thought the entire epoch without updates. We can use an L1 norm in order to sum up the variation inside an filter using criterion:

[TABLE]

where $\textbf{G}_{ij}$ is the gradient tensor of an filter $i$ at iteration $j$ inside an epoch. Equ. 10 measures the amount of global changes for an filter at the end of an epoch, which makes it most suitable for PGP. The second way of interpreting is by accumulating the actual changes of an filter at each updates, using criterion:

[TABLE]

Equ. 11 calculates the L1 norm of a gradient tensor of an filter at each iteration during an epoch. Thus, instead of measuring the global change only at the end like Equation 10, this measure the gradual changes during an epoch. This criteria is most suitable for RPGP since the weight is updated at the same time as we accumulate our gradient. PGP is summarized in Algo. 1. The algorithm for RPGP is similar but the criterion is calculated directly at the train step.

4 Experiments

Our experiments consider three different visual recognition tasks: (1) image classification (2) object detection and (3) domain adaptation. For image classification we evaluate our approach on MNIST and CIFAR10 datasets with several commonly used network architectures. Additionally, we conduct an ablation study to better understand which parts of our approach are important for good performance. For object detection we progressively prune the VGG16 backbone of Faster R-CNN and show a good trade-off between detection performance and computation. Finally, for domain adaptation, we evaluate our method on the Office-31 datasets. As our method is progressive, we can prune and adapt to the target domain simultaneously, which is beneficial. The source code for our paper will be available at https://github.com/Anon6627/Pruning-PGP.

4.1 Classification

In this section, we compare the experimental results obtained using the proposed PGP and RPGP techniques against state-of-the-art filter pruning techniques that are representative of each family described in Section 2.2: L1-norm Pruning (prunes once), Taylor Pruning (prunes iteratively), DCP (specialised loss function and minimize reconstruction error) and PSFP (progressive pruning). Performance is measured in terms of accuracy, and in terms of memory and time complexity (number of parameters and number of FLOPS). For techniques like our PGP, and PSFP, DCP and L1, it is possible to set a target pruning rate $t_{\text{prune}}$ hyper parameter. For a fixed pruning rate, the complexity (number of FLOPS and parameters) is identical for these techniques, so we can compare them in terms of accuracy for a given complexity. In contrast, techniques like Taylor prunes some filters at each iteration and can be stopped at a certain condition like number of FLOPs or until 99% of the filters are pruned. Due to the skip connections, pruning ResNet needs a special strategy. We decided to follow the popular pruning strategy proposed in [23] – pruning the down-sampling layer and then using the same indexes to prune the last convolution of the residual. Techniques are compared using Resnet, LeNet and VGG networks trained to address benchmark problems.

MNIST:

On this dataset, we use the same hyper-parameters as in the original papers. The same settings were used for LeNet5 and ResNet20. With PGP and RPGP, we use a learning rate 0.01, momentum 0.9, 40 epochs with a remove rate of 50%. For PSFP, we used these same settings except for removal rate of 50%. For Taylor [32], we iteratively remove 5 filters each time, and then fine-tune for 5 epochs. This varies slightly from the original procedure because this configuration does not collapse and return the best result. For L1 pruning, we use a 20 epochs fine-tuning after pruning. For DCP, we ran the author’s code for MNIST over 40 epochs, with 20 epochs for the filter pruning and 20 epochs for fine-tuning.

Results in Tab. 1 show that our PGP methods compare favorably against State-of the-art techniques like L1,Taylor and PSFP. Similar tendencies are seen in Tab. 2. We also see that PGP performs slightly better than DCP in some case. Finally, since both PGP_GNG and RPGP_GNS have the same criterion, results show that their procedure that differs. The slight better performance of PGP_GNG can be explained by the fact that the pruning criterion is calculated using Batch Gradient Descent instead of Stochastic Gradient Descent.

CIFAR10:

In this case, we use a VGG19 for CIFAR10, with learning rate 0.1, momentum 0.9, 400 epochs and we decrease the learning rate by a factor of 10 at 160 and 240 epochs. We also use Resnet56 adapted to CIFAR10 with the same settings, except with 500 epochs. As of PGP and RPGP, we set the remove rate hyper-parameter $r$ to 0.5 (50%), fine-tune them for 100 epochs after pruned, and store the best score. We use the same settings for PSFP except the removal rate $r$. For Taylor, 5 filters are iteratively iteratively each time and fine-tune on 5 epochs after that. We slightly changed the procedure compared to the original paper because the original procedure pruned one feature map each iteration which is inefficient on a large model. Empirically, we found that 5 feature maps has the best accuracy. For L1 pruning, 100 epochs of fine-tuning are used after pruned to find the best score. With DCP, the settings are provided by the original authors are found to have the best performance.

From Tabs. 3 and 4, our techniques consistently perform better than state of the art techniques L1, Taylor and PSFP on VGGNet. For ResNet, PSFP has a different pruning strategy on ResNet, and does not prune the down-sample layer, and therefore does not prune the last convolutional layer of the residual. This translates into a slight better accuracy on some settings. Our ablation study also provides a comparison of techniques using the same pruning strategy on ResNet, and shows the importance of momentum pruning. DCP performs better than ours on this dataset, mainly because of the additional losses that help selecting discriminate filters. However, it is difficult to compare directly since they do not yield the same number of FLOPS and parameters, and DCP starts from a trained model and requires more computation power.

4.2 Ablation study

The training and pruning time of a model are important factors of a technique, for instance for deploying or adapting a model in an operational environment. One of advantage of progressive pruning techniques is the reduction of processing time at each epoch since filters are removed while training, at each epoch. Tab. 5 presents the training and pruning time pruning for the evaluated techniques. For progressive pruning technique, values represent both pruning and training times, while for DCP, L1 and Iterative pruning, values represent (training time) + pruning and retrain times. Experiments are conducted on the CIFAR10 dataset with the same settings as above.

From Tab. 5, the fastest pruning method (without considering training time) is currently the L1. However, it should be noted that the original training of the model takes around 219 mins for VGG and 307 mins for Resnet56. So, taking into account also training time L1 is slower than our approach. Other techniques likes Taylor prune in a iterative way composed of multiple feature maps and fine-tuning, this method can be very slow, depending on the number of filters pruned at each iteration. DCP is particulary slow since it needs to start from an already trained model and then the pruning process need to do the filter pruning optimization process and the fine-tuning after pruning. For PSFP, this algorithm has similar time to the original training since it does not technically change the size of the model during training. Between PGP and RPGP, the difference is the use of an entire epoch to compute the pruning criterion with PGP, and the direct computation of the criterion during a training epoch with RPGP. Also, since we hard-prune filters at each epoch, the epoch time will become faster as the model is pruned/trained. Overall, the progressive pruning methods train and prune in considerably less time than other methods.

To compare the selection criterion, we use the same configuration as the general comparison for RPGP on CIFAR10, except we vary the criterion and set a pruning rate of 50%.

In Tab. 6, we can see that our criterion performs better than others in the context of progressive pruning, and similar to the L2 Norm. The comparison between Taylor Weight (TW), and Gradient Norm (GN) shows that a small gradient norm during training may be a good indicator about the importance of a filter. From the table we can also see that Taylor Weights performs better than the original Taylor criterion. Overall $GN_{G}$, which uses batch gradient to capture changes, seems to work the best with progressive pruning. As for the similarity between L2 and $GN$, it is explained in the Supplemental Material.

In this experiment of momentum pruning, the same strategy, hyper-parameters and L2 criterion are used for both RPGP and PSFP. The only difference is that RPGP performs momentum pruning.

From the Tab. 7, in both of the case (VGG19 and ResNet56), our proposed methods performs better than the state of the art PSFP method. Since, everything is the same in this setting except the momentum pruning, this clearly shows the advantage of pruning momentum during progressive pruning.

As described, PSFP does not prune the downsampling layer of ResNet56, thus, it does not prune the last layer of the residual connection. The performance of PSFP and RPGP is compared using the same strategy on ResNet56, i.e., the downsampling layer and last layer of residual connection are not pruned, on with CIFAR10 dataset and the same hyper-parameters as in previous experiments. The results in Tab. 8 indicate that the RPGP approach typically performs better than PSFP. Interestingly, when no pruning is performed on the downsampling layer and last layer of the residual connection, our method performs much better. The residual connection is sensitive to pruning, and may require a different pruning strategy.

4.3 Detection

PASCAL VOC:

In this case, PGP, RPGP and PSFP techniques are adapted for an object detection problem. We progressively prune a Faster R-CNN with a VGG16 backbone using a learning rate of 0.001, momentum of 0.9 using a 10 epochs progressive pruning, and early stopping for fine-tuning over a few epochs. For the L1 pruning, a trained model is prune 50% from the network, and then we fine-tune on Pascal VOC. For this experiment, we set the pruning rate hyper-parameter $r$ to 0.5 (50%), and show mean average precision (MAP) measure for comparison. In this experiment we skip the pruning of the last layer since it would mean pruning the input of the RPN layer, which we empirically found that it results in significant performance reduction. In Tab.9, PGP and RPGP perform better than PSFP, the current state-of-the-art progressive pruning. However, the PGP needs more time to prune due to the calculation of the criterion in a separate epoch. RPGP provides a slightly better performance (possibly due to stochasticity), and with much less pruning time. The difference in accuracy between RPGP and PSFP highlights the importance of momentum pruning with these approaches. The significant difference in the training time between RPGP and PSFP also suggests that by adding hard pruning to existing soft pruning during training can reduce training time.

4.4 Domain Adaptation

Office-31:

We adapted our pruning technique for domain adaptation. Among unsupervised domain adaptations techniques[8, 28, 41], we chose Deep Adaptation Network(DAN)[28] with a VGG16 backbone since it is a popular technique. However, we could adapt our pruning technique to other unsupervised domain adaptation such as ADDA[41] or DANN[8]. For this experiment, we train our model for 400 epochs for joint domain-adaptation and pruning, with an exponential decay learning rate starting at 0.001, we set a pruning rate of 20% with a remove rate of 0.3. In Tab.10 we see that our method performs better than TCP in the majority of the cases while having a higher FLOPs Reduction. We can explain the improvement over TCP mainly due to two factors. First, the use of our pruning criterion. As shown in our ablation study, a Taylor criterion based on weight is better than its feature map counterpart. Second, we think that progressive pruning is more suited for domain adaptation than the commonly used scheme in which first the model is adapted to the target domain, then pruned, and finally fine-tuned. In our approach we perform pruning and domain adaptation simultaneously in a single training. In this way, instead of trying to adapt all filters of the model, we might expect to directly remove those filters that are specific of a certain domain and do not help in bridging domain discrepancy. This would ease the learning of transferable features in the case of DAN[28] or domain confusion in the case of ADDA[41].

5 Conclusion

In this paper, we show that it is possible to efficiently prune a deep learning model from scratch with the PGP technique while improving the trade-off between compression, accuracy and training time. PGP is a new progressive pruning technique that relies on change in filter weights to apply hard and soft pruning strategies that allows for pruning along the back-propagation path. The filter selection criterion is well adapted for progressive pruning from scratch when the norm of the gradient is considered. Results obtained from pruning various CNNs on image data for classification and object detection problems show that the proposed PGP allows maintaining a high level of accuracy with compact networks. Results show that PGP can achieve better CNN optimisations than PSFP, often translating to a higher level of accuracy for a same pruning rate as PSFP and other state-of-art techniques. In domain adaptation problems, our technique outperforms current state of the art technique while pruning more. Future research will involve analyzing the performance of different CNNs pruned using the proposed method on larger datasets from real-world visual recognition problems (e.g., tracking and recognition of persons in video surveillance) and on different domain adaptation architetures.

Appendix A Additional Experimental Results

A.1 Implementation Details

One of the problem of pruning during training is how to handle the shape of the gradient tensor and momentum tensor during backward pass. In the case of PyTorch [34], the shape of the gradient tensor and momentum tensor is usually handled by the optimizer, which does not necessary update the shape during forward pass. Also, redefining a new optimizer with the new pruned model in a trivial way would result in losing all values accumulated in the momentum buffer. One of the way to overcome this, is to prune also the gradient and momentum tensors using indexes that we used to prune the weight tensor, and then transfer them to a newly defined optimizer.

A.2 Graphical comparison on CIFAR10 with VGG:

The results presented in this section are similar to the ones shown in Tabs. 1 to 4 of our paper. In the main paper, we could only compare the performance of methods with 4 pruning rates due to space constraints. In this section, we compare the performance of methods using the same experimental settings (as in our paper), but with 10 data points ($t_{\mbox{pruned}}=0.1,0.2,...,1.0$) on L1 [23], Taylor [32], PSFP [12] and our approach. Since the number of remaining parameters can differ slightly from one algorithm to the other, some of the value on X-axis are rounded up for a better visualization.

Results in Figure 3 show the proposed PGP and RPGP pruning methods consistently outperforming the other methods. Note that the proposed methods allow to maintain a low lever of error event with an important increase in the pruning rate.

A.3 L2 vs Gradient Norm:

From the ablation study, we noticed that the performance of L2 and Gradient norm is very similar in the case of soft pruning. This can be understood considering the following:

[TABLE]

Where $\textbf{W}^{j}_{i}$ represents the weight of an filter $i$ at iteration $j$ in an epoch, $\alpha$ is the learning rate, and $\mathcal{L}^{k}$ denotes here the loss function at iteration $k$. From the Equ.12 we can observe the difference between L2 and Gradient Norm is the initial values of $\textbf{W}^{0}_{i}$. Taking in account the partial soft pruning nature of our approach, $\textbf{W}^{0}_{i}$ can be zero when it is soft pruned. Therefore the two approaches tends to have similar values (since $\alpha$ is a scalar, it is not important in this context).

A.4 Progressive pruning from scratch vs trained:

Tab. 11 shows that the performance obtained by a model that was randomly initialized (scratch) versus one that was pre-trained on CIFAR10 using the same settings as before ($t_{pruned}=50\%$, $r=0.5$).

From Tab. 11 the difference in terms of accuracy between a network pruned starting from scratch and a network pruned after training is quite reduced and can vary depending on the architectures. Overall, instead of starting from a trained model and prune, the proposed techniques can attain similar performance starting from a randomly initialized model, thus, with a reduced training and pruning time, therefore more suitable for fast deployment.

A.5 Hard vs soft pruning:

RPGP is used with our gradient criterion and a target prune rate at 50% and using the same hyper-parameters. The removal rate $r$ is varied in order to see the impact of having more or less recovery.

The results in Tab. 12 show that a remove rate of 0.3(30%)or 0.5(50%) has the best balance between the amount of hard pruning soft pruning. It is also interesting to see that, without any soft pruning ($r$=1.0), the performance of the approach is still close to others removal rate.