R ETHINKING THE S MALLER -N ORM -L ESSI NFORMATIVE A SSUMPTION IN C HANNEL P RUNING OF C ONVOLUTION L AYERS
A BSTRACT
Model pruning has become a useful technique that improves the computational efﬁciency of deep learning, making it possible to deploy solutions in resourcelimited scenarios.
A widely-used practice in relevant work assumes that a smallernorm parameter or feature plays a less informative role at the inference time.
In this paper, we propose a channel pruning technique for accelerating the computations of deep convolutional neural networks (CNNs) that does not critically rely on this assumption.
Instead, it focuses on direct simpliﬁcation of the channel-tochannel computation graph of a CNN without the need of performing a computationally difﬁcult and not-always-useful task of making high-dimensional tensors of CNN structured sparse.
Our approach takes two stages: ﬁrst to adopt an end-toend stochastic training method that eventually forces the outputs of some channels to be constant, and then to prune those constant channels from the original neural network by adjusting the biases of their impacting layers such that the resulting compact model can be quickly ﬁne-tuned.
Our approach is mathematically appealing from an optimization perspective and easy to reproduce.
We experimented our approach through several image learning benchmarks and demonstrate its interesting aspects and competitive performance.
I NTRODUCTION
Not all computations in a deep neural network are of equal importance.
In a typical deep learning pipeline, an expert crafts a neural architecture, which is trained using a prepared dataset.
The success of training a deep model often requires trial and error, and such loop usually has little control on prioritizing the computations happening in the neural network.
Recently researchers started to develop model-simpliﬁcation methods for convolutional neural networks (CNNs), bearing in mind that some computations are indeed non-critical or redundant and hence can be safely removed from a trained model without substantially degrading the model’s performance.
Such methods not only accelerate computational efﬁciency but also possibly alleviate the model’s overﬁtting effects.
Discovering which subsets of the computations of a trained CNN are more reasonable to prune, however, is nontrivial.
Existing methods can be categorized from either the learning perspective or from the computational perspective .
From the learning perspective, some methods use a dataindependent approach where the training data does not assist in determining which part of a trained CNN should be pruned, e.g. He et al.
(2017) and Zhang et al.
(2016), while others use a datadependent approach through typically a joint optimization in generating pruning decisions, e.g. , Han et al.
and Anwar et al.
From the computational perspective, while most approaches focus on setting the dense weights of convolutions or linear maps to be structured sparse, we propose here a method adopting a new conception to achieve in effect the same goal.
Instead of regarding the computations of a CNN as a collection of separate computations sitting at different layers, we view it as a network ﬂow that delivers information from the input to the output through different channels across different layers.
We believe saving computations of a CNN is not only about reducing what are calculated in an individual layer, but perhaps more importantly also about understanding how each channel is contributing to the entire information ﬂow in the underlying passing graph as well as removing channels that are less responsible to such process.
Inspired by this new conception, we propose to design a “gate” at each channel of a CNN, controlling whether its received information is actually sent out to other channels after processing.
If a channel “gate” closes, its output will always be a constant.
In fact, each designed “gate” will have a prior intention to close, unless it has a “strong” duty in sending some of its received information from the input to subsequent layers.
We ﬁnd that implementing this idea in pruning CNNs is unsophisticated, as will be detailed in Sec 4.
Our method neither introduces any extra parameters to the existing CNN, nor changes its computation graph.
In fact, it only introduces marginal overheads to existing gradient training of CNNs.
It also possess an attractive feature that one can successively build multiple compact models with different inference performances in a single round of resource-intensive training (as in our experiments).
This eases the process to choose a balanced model to deploy in production.
Probably, the only applicability constraint of our method is that all convolutional layers and fully-connected layer (except the last layer) in the CNN should be batch normalized (Ioffe & Szegedy, 2015).
Given batch normalization has becomes a widely adopted ingredient in designing state-of-the-art deep learning models, and many successful CNN models are using it, we believe our approach has a wide scope of potential impacts.
In this paper, we start from rethinking a basic assumption widely explored in existing channel pruning work.
We point out several issues and gaps in realizing this assumption successfully.
Then, we propose our alternative approach, which works around several numerical difﬁculties.
Finally, we experiment our method across different benchmarks and validate its usefulness and strengths.
R ELATED W ORK
Reducing the size of neural network for speeding up its computational performance at inference time has been a long-studied topic in the communities of neural network and deep learning.
Pioneer works include Optimal Brain Damage (LeCun et al., 1990) and Optimal Brain Surgeon (Hassibi & Stork, 1993).
More recent developments focused on either reducing the structural complexity of a provided network or training a compact or simpliﬁed network from scratch.
Our work can be categorized into the former, thus the literature review below revolves around reducing the structural complexity.
To reduce the structural complexity of deep learning models, previous work have largely focused on sparsifying the weights of convolutional kernels or the feature maps across multiple layers in a network (Anwar et al., 2017; Han et al., 2015).
Some recent efforts proposed to impose structured sparsity on those vector components motivated from the implementation perspective on specialized hardware (Wen et al., 2016; Zhou et al., 2016; Alvarez & Salzmann, 2016; Lebedev & Lempitsky, 2016).
Yet as argued by Molchanov et al. (2017), regularization-based pruning techniques require per layer sensitivity analysis which adds extra computations.
Their method relies on global rescaling of criteria for all layers and does not require sensitivity estimation, a beneﬁcial feature that our approach also has.
To our knowledge, it is also unclear how widely useful those works are in deep learning.
In Section 3, we discuss in details the potential issues in regularization-based pruning techniques potentially hurting them being widely applicable, especially for those that regularize high-dimensional tensor parameters or use magnitude-based pruning methods.
Our approach works around the mentioned issues by constraining the anticipated pruning operations only to batchnormalized convolutional layers.
Instead of posing structured sparsity on kernels or feature maps, are estimated outputs we enforce sparsity on the scaling parameter γ in batch normalization operator.
This blocks the sample-wise information passing through part of the channels in convolution layer, and in effect implies one can safely remove those channels.
A recent work by Huang & Wang (2017) used a similar technique as ours to remove unimportant residual modules in ResNet by introducing extra scaling factors to the original network. However, some optimization subtleties as to be pointed out in our paper were not well explained.
Another recent work called Network-Slimming (Liu et al., 2017) also aims to sparsify the scaling parameters of batch normalization.
But instead of using off-the-shelf gradient learning like theirs, we propose a new algorithmic approach based on ISTA and rescaling trick, improving robustness and speed of the undergoing optimization.
In particular, the work of Liu et al.
(2017) was able to prune VGG-A model on ImageNet.
It is unclear how their work would deal with the γ - W rescaling effect and whether their approach can be adopted to large pre-trained models, such as ResNets and Inceptions.
We experimented with the pre-trained ResNet-101 and compared to most recent work that were shown to work well with large CNNs.
We also experimented with an image segmentation model which has an inception-like module (pre-trained on ImageNet) to locate foreground objects.
R ETHINKING THE S MALLER -N ORM -L ESS -I NFORMATIVE A SSUMPTION
In most regularized linear regressions, a large-norm coefﬁcient is often a strong indicator of a highly informative feature.
This has been widely perceived in statistics and machine learning communities. Removing features which have a small coefﬁcient does not substantially affect the regression errors.
Therefore, it has been an established practice to use tractable norm to regularize the parameters in optimizing a model and pick the important ones by comparing their norms after training.
However, this assumption is not unconditional.
By using Lasso or ridge regression to select important predictors in linear models, one always has to ﬁrst normalize each predictor variable.
Otherwise, the result might not be explanatory.
For example, ridge regression penalizes more the predictors which has low variance, and Lasso regression enforces sparsity of coefﬁcients which are already small in OLS.
Such normalization condition for the right use of regularization is often unsatisﬁed for nonconvex learning.
For example, one has to carefully consider two issues outlined below.
We provides these two cases to exemplify how regularization could fail or be of limited usage.
There deﬁnitely exist ways to avoid the described failures.
Model Reparameterization .
In the ﬁrst case, we show that it is not easy to have ﬁne-grained control of the weights’ norms across different layers.
One has to either choose a uniform penalty in all layers or struggle with the reparameterization patterns.
Consider to ﬁnd a deep linear (convolutional) network subject to a least square with Lasso: for λ > 0 ,
[Equation]
The above formulation is not a well-deﬁned problem because for any parameter set { W i } 2 ni =1 , one can always ﬁnd another parameter set { W (cid:48) i } 2 ni =1 such that it achieves a smaller total loss while keeping the corresponding l 0 norm unchanged by actually setting
[Equation]
where α > 1 .
In another word, for any (cid:15) > 0 , one can always ﬁnd a parameter set { W i } 2 ni =1 (which is usually non-sparse) that minimizes the ﬁrst least square loss while having its second Lasso term less than (cid:15) .
We note that gradient-based learning is highly inefﬁcient in exploring such model reparameterization patterns.
In fact, there are some recent discussions around this (Dinh et al., 2017).
If one adopts a pre-trained model, and augments its original objective with a new norm-based parameter regularization, the new gradient updates may just increase rapidly or it may take a very long time for the variables traveling along the model’s reparameterization trajectory.
This highlights a theoretical gap questioning existing sparsity-inducing formulation and actual computational algorithms whether they can achieve widely satisfactory parameter sparsiﬁcation for deep learning models.
Transform Invariance .
In the second case, we show that batch normalization is not compatible with weight regularization.
The example is penalizing l 1 - or l 2 -norms of ﬁlters in convolution layer which is then followed by a batch normalization: at the l -th layer, we let
[Equation]
where γ and β are vectors whose length is the number of channels.
Likewise, one can clearly see that any uniform scaling of W l which changes its l 1 - and l 2 -norms would have no effects on the output x l +1 .
Alternatively speaking, if one is interested in minimizing the weight norms of multiple layers together, it becomes unclear how to choose proper penalty for each layer.
Theoretically, there always exists an optimizer that can change the weight to one with inﬁnitesimal magnitude without hurting any inference performance.
As pointed by one of the reviewers, one can tentatively avoid this issue by projecting the weights to the surface of unit ball.
Then one has to deal with a non-convex feasible set of parameters, causing extra difﬁculties in developing optimization for data-dependent pruning methods.
It is also worth noting that some existing work used such strategy in a layer-by-layer greedy way (He et al., 2017; Zhang et al., 2016).
Based on this discussion, many existing works which claim to use Lasso, group Lasso (e.g. Wen et al.
; Anwar et al.
(2017)), or thresholding (e.g. Molchanov et al.
(2017)) to enforce parameter sparsity have some theoretical gaps to bridge.
In fact, many heuristic algorithms in neural net pruning actually do not naturally generate a sparse parameterized solution.
More often, thresholding is used to directly set certain subset of the parameters in the network to zeros, which can be problematic.
The reason is in essence around two questions.
First, by setting parameters less than a threshold to zeros, will the functionality of neural net be preserved approximately with certain guarantees?
If yes, then under what conditions?
Second, how should one set those thresholds for weights across different layers?
Not every layer contributes equally in a neural net.
It is expected that some layers act critically for the performance but only use a small computation and memory budget, while some other layers help marginally for the performance but consume a lot resources.
It is naturally more desirable to prune calculations in the latter kind of layers than the former.
In contrast with these existing approaches, we focus on enforcing sparsity of a tiny set of parameters in CNN — scale parameter γ s in all batch normalization.
Not only placing sparse constraints on γ is simpler and easier to monitor, but more importantly, we have two strong reasons:
Every γ always multiplies a normalized random variable, thus the channel importance becomes comparable across different layers by measuring the magnitude values of γ ; 2.
The reparameterization effect across different layers is avoided if its subsequent convolution layer is also batch-normalized.
In other words, the impacts from the scale changes of γ parameter are independent across different layers.
Nevertheless, our current work still falls short of a strong theoretical guarantee.
We believe by working with normalized feature inputs and their regularized coefﬁcients together, one is closer to a more robust and meaningful approach.
Sparsity is not the goal, but to ﬁnd less important channels using sparsity inducing formulation is.
C HANNEL P RUNING OF B ATCH -N ORMALIZED CNN
We describe the basic principle and algorithm of our channel pruning technique.
4. P RELIMINARIES
Pruning constant channels .
Consider convolution with batch normalization:
[Equation]
For the ease of notation, we let γ = γ l .
Note that if some element in γ is set to zero, say, γ [ k ] = 0 , its output image x l +1: , : , : ,k becomes a constant β k , and a convolution of a constant image channel is almost everywhere constant (except for padding regions, an issue to be discussed later).
Therefore, we show those constant image channels can be pruned while the same functionality of network is approximately kept:
• If the subsequent convolution layer does not have batch normalization,
[Equation]
its values (a.k.a.
elements in β ) is absorbed into the bias term by the following equation
[Equation]
such that
[Equation]
where ∗ γ denotes the convolution operator which is only calculated along channels indexed by non-zeros of γ .
Remark that W ∗ = sum reduced ( W : , : , · , · ) if W ∗ a,b = (cid:80) i [Equation] j W
i
[Equation]
• If the subsequent convolution layer has batch normalization,
[Equation]
instead its moving average is updated as
[Equation]
such that
[Equation]
Remark that the approximation ( ≈ ) is strictly equivalence ( = ) if no padding is used in the convolution operator ∗ , a feature that the parallel work Liu et al.
(2017) does not possess.
When the original model uses padding in computing convolution layers, the network function is not strictly preserved after pruning.
In our practice, we ﬁne-tune the pruned network to ﬁx such performance degradation at last.
In short, we formulate the network pruning problem as simple as to set more elements in γ to zero.
It is also much easier to deploy the pruned model, because no extra parameters or layers are introduced into the original model.
To better understand how it works in an entire CNN, imagine a channel-to-channel computation graph formed by the connections between layers.
In this graph, each channel is a node, their inference dependencies are represented by directed edges.
The γ parameter serves as a “dam” at each node, deciding whether let the received information “ﬂood” through to other nodes following the graph.
An end-to-end training of channel pruning is essentially like a ﬂood control system.
There suppose to be rich information of the input distribution, and in two ways, much of the original input information is lost along the way of CNN inference, and the useful part — that is supposed to be preserved by the network inference — should be label sensitive.
Conventional CNN has one way to reduce information: transforming feature maps (non-invertible) via forward propagation.
Our approach introduces the other way: block information at each channel by forcing its output being constant using ISTA.
ISTA .
Despite the gap between Lasso and sparsity in the non-convex settings, we found that
ISTA (Beck & Teboulle, 2009) is still a useful sparse promoting method.
But we just need to use it more carefully.
Speciﬁcally, we adopt ISTA in the updates of γ s. The basic idea is to project the parameter at every step of gradient descent to a potentially more sparse one subject to a proxy problem: let l denote the training loss of interest, at the ( t + 1) -th step, we set
[Equation]
(1) where ∇ γ l t is the derivative with respect to γ computed at step t , µ t is the learning rate, λ is the penalty.
In the stochastic learning, ∇ γ l t is estimated from a mini-batch at each step.
Eq.
(1) has closed form solution as
[Equation]
where prox η ( x ) = max {| x |− η, 0 }· sgn ( x ) .
The ISTA method essentially serves as a “ﬂood control system” in our end-to-end learning, where the functionality of each γ is like that of a dam.
When γ is zero, the information ﬂood is totally blocked, while γ (cid:54) = 0 , the same amount of information is passed through in form of geometric quantities whose magnitudes are proportional to γ .
Scaling effect .
One can also see that if γ is scaled by α meanwhile W l +1 is scaled by 1 /α , that is,
[Equation]
the output x l +2 is unchanged for the same input x l .
Despite not changing the output, scaling of γ and
W l +1 also scales the gradients ∇ γ l and ∇ W l +1 l by 1 /α and α , respectively.
As we observed, the parameter dynamics of gradient learning with ISTA depends on the scaling factor α if one decides to choose it other than 1 . 0 .
Intuitively, if α is large, the optimization of W l +1 is progressed much slower than that of γ .
4. T HE A LGORITHM
We describe our algorithm below.
The following method applies to both training from scratch or re-training from a pre-trained model.
Given a training loss l , a convolutional neural net N , and hyper-parameters ρ, α, µ 0 , our method proceeds as follows:
Computation of sparse penalty for each layer.
Compute the memory cost per channel for each layer denoted by λ l and set the ISTA penalty for layer l to ρλ l .
Here
[Equation]
where
• I iw · I ih is the size of input image of the neural network.
• k lw · k lh is the kernel size of the convolution at layer l .
Likewise, k l (cid:48) w · k l (cid:48) h is the kernel size of subsequent convolution at layer l (cid:48) .
• T ( l ) represents the set of the subsequent convolutional layers of layer l • c l − 1 denotes the channel size of the previous layer, which the l -th convolution operates over; and c l (cid:48) denotes the channel size of one subsequent layer l (cid:48) .
• I lw · I lh is the image size of the feature map at layer l . 2.
γ - W rescaling trick.
For layers whose channels are going to get reduced, scale all γ l s in batch normalizations by α meanwhile scale weights in their subsequent convolutions by 1 /α .
End-to-End training with ISTA on γ .
Train N by the regular SGD, with the exception that γ l s are updated by ISTA, where the initial learning rate is µ 0 .
Train N until the loss l plateaus, the total sparsity of γ l s converges, and Lasso ρ (cid:80) l λ l (cid:107) γ l (cid:107) 1 converges.
Post-process to remove constant channels.
Prune channels in layer l whose elements in γ l are zero and output the pruned model (cid:101) N by absorbing all constant channels into subsequent layers (as described in the earlier section.).
γ - W rescaling trick.
For γ l s and weights in (cid:101) N which were scaled in Step 2 before training, scale them by 1 /α and α respectively (scaling back).
Fine-tune (cid:101) N using regular stochastic gradient learning.
Remark that choosing a proper α as used in Steps 2 and 5 is necessary for using a large µ t · ρ in
ISTA, which makes the sparsiﬁcation progress of γ l s faster.
4. G UIDELINES FOR T UNING H YPER - PARAMETERS
We summarize the sensitivity of hyper-parameters and their impacts for optimization below:
• µ (learning rate): larger µ leads to fewer iterations for convergence and faster progress of sparsity.
But if if µ too large, the SGD approach wouldn’t converge.
• ρ (sparse penalty): larger ρ leads to more sparse model at convergence.
If trained with a very large ρ , all channels will be eventually pruned.
• α (rescaling): we use α other than 1. only for pretrained models, we typically choose α from { 0.001, 0.01, 0.1, 1 } and smaller α warms up the progress of sparsity.
We recommend the following parameter tuning strategy.
First, check the cross-entropy loss and the regularization loss, select ρ such that these two quantities are comparable at the beginning.
Second, choose a reasonable learning rate.
Third, if the model is pretrained, check the average magnitude of γ s in the network, choose α such that the magnitude of rescaled γ l is around 100 µλ l ρ .
We found as long as one choose those parameters in the right range of magnitudes, the optimization progress is enough robust.
Again one can monitor the mentioned three quantities during the training and terminate the iterations when all three quantities plateaus.
There are several patterns we found during experiments that may suggest the parameter tuning has not been successful.
If during the ﬁrst few epochs the Lasso-based regularization loss keeps decreasing linearly while the sparsity of γ s stays near zero, one may decrease α and restart.
If during the ﬁrst few epochs the sparsity of γ s quickly raise up to 100%, one may decrease ρ and restart.
If during the ﬁrst few epochs the cross-entropy loss keeps at or increases dramatically to a non-informative level, one may decrease µ or ρ and restart.
E XPERIMENTS 5. CIFAR-10 E XPERIMENT
We experiment with the standard image classiﬁcation benchmark CIFAR-10 with two different network architectures: ConvNet and ResNet-20 (He et al., 2016).
We resize images to 32 × 32 and zero-pad them to 40 × 40 .
We pre-process the padded images by randomly cropping with size 32 × 32 , randomly ﬂipping, randomly adjusting brightness and contrast, and standardizing them such that their pixel values have zero mean and one variance.
ConvNet For reducing the channels in ConvNet, we are interested in studying whether one can easily convert a over-parameterized network into a compact one.
We start with a standard 4-layer convolutional neural network whose network attributes are speciﬁed in Table 1.
We use a ﬁxed learning rate µ t = 0 .
01 , scaling parameter α = 1 . 0 , and set batch size to 125.
Model A is trained from scratch using the base model with an initial warm-up ρ = 0 . 0002 for 30k steps, and then is trained by raising up ρ to 0 .
After the termination criterion are met, we prune the channels of the base model to generate a smaller network called model A.
We evaluate the classiﬁcation performance of model A with the running exponential average of its parameters.
It is found that the test accuracy of model A is even better than the base model.
Next, we start from the pre-trained model
A to create model B by raising ρ up to 0 .
We end up with a smaller network called model B, which is about 1% worse than model A, but saves about one third parameters.
Likewise, we start from the pre-trained model B to create model C.
The detailed statistics and its pruned channel size are reported in Table 1.
We also train a reference ConvNet from scratch whose channel sizes are 32-64-64-128 with totally 224,008 parameters and test accuracy being 86.3%.
The referenced model is not as good as Model B, which has smaller number of parameters and higher accuracy.
We have two major observations from the experiment: (1) When the base network is overparameterized, our approach not only signiﬁcantly reduces the number of channels of the base model but also improves its generalization performance on the test set.
(2) Performance degradation seems unavoidable when the channels in a network are saturated, and our approach gives satisfactory tradeoff between test accuracy and model efﬁciency.
ResNet-20 We also want to verify our second observation with the state-of-art models.
We choose the popular ResNet-20 as our base model for the CIFAR-10 benchmark, whose test accuracy is 92%.
We focus on pruning the channels in the residual modules in ResNet-20, which has 9 convolutions in total.
As detailed in Table 2, model A is trained from scratch using ResNet-20’s network structure as its base model.
We use a warm-up ρ = 0 .
001 for 30k steps and then train with ρ = 0 .
We are able to remove 37% parameters from ResNet-20 with only about 1 percent accuracy loss.
Likewise,
Model B is created from model A with a higher penalty ρ = 0 .
[Table]
[Table]
5. ILSVRC2012 E XPERIMENT
We experiment our approach with the pre-trained ResNet-101 on ILSVRC2012 image classiﬁcation dataset (He et al., 2016).
ResNet-101 is one of the state-of-the-art network architecture in ImageNet
Challenge.
We follow the standard pipeline to pre-process images to 224 × 224 for training ResNets.
We adopt the pre-trained TensorFlow ResNet-101 model whose single crop error rate is 23.6% with about 4 .
47 × 10 7 parameters.
2 We set the scaling parameter α = 0 .
01 , the initial learning rate µ t = 0 .
001 , the sparsity penalty ρ = 0 .
1 , and the batch size = 128 (across 4 GPUs).
The learning rate is decayed every four epochs with rate 0 .
We create two pruned models from the different iterations of training ResNet-101: one has 2 .
36 × 10 7 parameters and the other has 1 .
73 × 10parameters.
We then ﬁne-tune these two models using the standard way for training ResNet-101, and report their error rates.
The Top-5 error rate increases of both models are less than 0 .
The
Top-1 error rates are summarized in Table 3.
To our knowledge, only a few works have reported their performance on this very large-scale benchmark w.r.t.
the Top-1 errors.
We compare our approach with some recent works in terms of model parameter size, ﬂops, and error rates.
As shown in Table 3, our model v2 has achieved a compression ratio more than 2.5 while maintaining more than 1% lower error rates than that of other state-of-the-art models at comparable size of parameters.
In the ﬁrst experiment (CIFAR-10), we train the network from scratch and allocate enough steps for both γ and W adjusting their own scales.
Thus, initialization of an improper scale of γ - W is not really an issue given we optimize with enough steps.
But for the pre-trained models which were originally optimized without any constraints of γ , the γ s scales are often unanticipated.
It actually takes as many steps as that of training from scratch for γ to warm up.
By adopting the rescaling trick setting α to a smaller value, we are able to skip the warm-up stage and quick start to sparsify γ s. For example, it might take more than a hundred epoch to train ResNet-101, but it only takes about 5epochs to complete the pruning and a [Table]
5. I MAGE F OREGROUND -B ACKGROUND S EGMENTATION E XPERIMENT
As we have discussed about the two major observations in Section 5.1, a more appealing scenario is to apply our approach in pruning channels of over-parameterized model.
It often happens when one adopts a pre-trained network on a large task (such as ImageNet classiﬁcation) and ﬁne-tunes the model to a different and smaller task (Molchanov et al., 2017).
In this case [Table] one might expect that some channels that have been useful in the ﬁrst pre-training task are not quite contributing to the outputs of the second task.
We describe an image segmentation experiment whose neural network model is composed from an inception-like network branch and a densenet network branch.
The entire network takes a 224 ×image and outputs binary mask at the same size.
The inception branch is mainly used for locating the foreground objects while the densenet network branch is used to reﬁne the boundaries around the segmented objects.
This model was originally trained on multiple datasets.
In our experiment, we attempt to prune channels in both the inception branch and densenet branch.
We set α = 0 .
01 , ρ = 0 .
5 , µ t = 2 × 10 − 5 , and batch size = 24 .
We train the pre-trained base model until all termination criterion are met, and build the pruned model for ﬁne-tuning.
The pruned model saves 86% parameters and 81% ﬂops of the base model.
We also compare the ﬁne-tuned pruned model with the pre-trained base model across different test benchmark.
Mean IOU is used as the evaluation metric.
It shows that pruned model actually improves over the base model on four of the ﬁve test datasets with about 2% ∼ 5% , while it performs worse than the base model on the most challenged dataset DUT-Omron, whose foregrounds might contain multiple objects
[Table]
C ONCLUSIONS
We proposed a model pruning technique that focuses on simplifying the computation graph of a deep convolutional neural network.
Our approach adopts ISTA to update the γ parameter in batch normalization operator embedded in each convolution.
To accelerate the progress of model pruning, we use a γ - W rescaling trick before and after stochastic training.
Our method cleverly avoids some possible numerical difﬁculties such as mentioned in other regularization-based related work, hence is easier to apply for practitioners.
We empirically validated our method through several benchmarks and showed its usefulness and competitiveness in building compact CNN models