Year: 2020

Abstract:
By removing parameters from deep neural networks, unstructured pruning methods aim at cutting down memory footprint and computational cost, while maintaining prediction accuracy. In order to tackle this otherwise intractable problem, many of these methods model the loss landscape using first or second order Taylor expansions to identify which parameters can be discarded. We revisit loss modelling for unstructured pruning: we show the importance of ensuring locality of the pruning steps, and systematically compare first and second order Taylor expansions. Finally, we show that better preserving the original network function does not necessarily transfer to better performing networks after fine-tuning, suggesting that only considering the impact of pruning on the loss might not be a sufficient objective to design good pruning criteria.

heading: 1 INTRODUCTION
text: Neural networks are getting bigger, requiring more and more computational resources not only for training, but also when used for inference. However, resources are sometimes limited, especially on mobile devices and low-power chips. In unstructured pruning, the goal is to remove some parameters (i.e. setting them to zeros), while still maintaining good prediction performances. This is fundamentally a combinatorial optimization problem which is intractable even for small scale neural networks, and thus various heuristics have been developed to prune the model either before training (Lee et al., 2019b; Wang et al., 2020), during training (Louizos et al., 2017; Molchanov et al., 2017; Ding et al., 2019), or in an iterative training/fine-tuning fashion (LeCun et al., 1990; Hassibi & Stork, 1993; Han et al., 2015; Frankle & Carbin, 2018; Renda et al., 2020).
Early pruning work Optimal Brain Damage (OBD) (LeCun et al., 1990), and later Optimal Brain Surgeon (OBS) (Hassibi & Stork, 1993), proposed to estimate the importance of each parameter by approximating the effect of removing it, using the second order term of a Taylor expansion of the loss function around converged parameters. This type of approach involves computing the Hessian, which is challenging to compute since it scales quadratically with the number of parameters in the network. Several approximations have thus been explored in the literature (LeCun et al., 1990; Hassibi & Stork, 1993; Heskes, 2000; Zeng & Urtasun, 2019; Wang et al., 2019). However, state-ofthe-art unstructured pruning methods typically rely on Magnitude Pruning (MP) (Han et al., 2015), a simple and computationally cheap criterion based on weight magnitude, that works extremely well in practice (Renda et al., 2020).
This paper revisits linear and diagonal quadratic models of the local loss landscape for unstructured pruning. In particular, since these models are local approximations and thus assume that pruning steps correspond to small vectors in parameter space, we propose to investigate how this locality assumption affects their performance. Moreover, we show that the convergence assumption behind OBD and OBS, which is overlooked and violated in current methods, can be relaxed by maintaining the gradient term in the quadratic model. Finally, to prevent having to compute second order information, we propose to compare diagonal quadratic models to simpler linear models.
While our empirical study demonstrates that pruning criteria based on linear and quadratic loss models are good at preserving the training loss, it also shows that this benefit does not necessarily transfer to better networks after fine-tuning, suggesting that preserving the loss might not be the best objective to optimize for. Our contributions can be summarized as follows:
1. We present pruning criteria based on both linear and diagonal quadratic models of the loss, and show how they compare at preserving training loss compared to OBD and MP. 2. We study two strategies to better enforce locality in the pruning steps, pruning in several stages and regularising the step size, and show how they improve the quality of the criteria. 3. We show that using pruning criteria that are better at preserving the loss does not necessarily transfer to better fine-tuned networks, raising questions about the adequacy of such criteria.

heading: 2 BACKGROUND: UNSTRUCTURED PRUNING

heading: 2.1 UNSTRUCTURED PRUNING PROBLEM FORMULATION
text: For a given architecture, neural networks are a family of functions fθ : X → Y from an input space X to an output space Y , where θ ∈ RD is the vector that contains all the parameters of the network. Neural networks are usually trained by seeking parameters θ that minimize the empirical risk L(θ) = 1N ∑ i ` (fθ (xi) , ti) of a loss function ` on a training dataset D = {(xi, ti)}1≤i≤N , composed of N (example, target) pairs.
The goal of unstructured pruning is to find a step ∆θ to add to the current parameters θ such that ‖θ+∆θ‖0 = (1−κ)D, i.e. the parameter vector after pruning is of desired sparsity κ ∈ [0, 1]. While doing so, the performance of the pruned network should be maintained, so L(θ + ∆θ) should not differ much from L(θ). Unstructured pruning thus amounts to the following minimization problem:
minimize ∆θ
∆L(θ,∆θ) def= |L(θ + ∆θ)− L(θ)| s.t. ‖θ + ∆θ‖0 = (1− κ)D (1)
Directly solving this problem would require evaluating L(θ + ∆θ) for all possible values of ∆θ, which is prohibitively expensive, so one needs to rely on heuristics to find good solutions.

heading: 2.2 OPTIMAL BRAIN DAMAGE CRITERION
text: Optimal Brain Damage (OBD) (LeCun et al., 1990) proposes to use a quadratic modelling of L(θ + ∆θ), leading to the following approximation of ∆L(θ,∆θ):
∆LQM (θ,∆θ) = ∣∣∣∣∣∂L(θ)∂θ >∆θ + 12∆θ>H(θ)∆θ ∣∣∣∣∣ (2)
where H(θ) is the Hessian of L(θ). H(θ) being intractable, even for small-scale networks, its Generalized Gauss-Newton approximation G(θ) (Schraudolph, 2002) is used in practice, as detailed in Appendix A.1 Then, two more approximations are made: first, it assumes the training of the network has converged, thus the gradient of the loss wrt θ is 0, which makes the linear term vanish. Then, it neglects the interactions between parameters, which corresponds to a diagonal approximation of G(θ), leading to the following model:
∆LOBD(θ,∆θk) ≈ 1
2 Gkk(θ)∆θ
2 k ⇒ sOBDk =
1 2 Gkk(θ)θ 2 k (3)
sOBDk is the saliency of each parameter, estimating how much the loss will change if that parameter is pruned, so if ∆θk = −θk. Parameters can thus be ranked by order of importance, and the ones with the smallest saliencies (i.e. the least influence on the loss) are pruned, while the ones with the biggest saliencies are kept unchanged. This can be interpreted as finding and applying a binary mask m ∈ {0, 1}D to the parameters such that θ + ∆θ = θ m, where is the element-wise product.

heading: 2.3 MAGNITUDE PRUNING CRITERION
text: Magnitude Pruning (MP) (Han et al., 2015), is a popular pruning criterion in which the saliency is simply based on the norm of the parameter:
sMPk = θ 2 k (4)
Despite its simplicity, MP works extremely well in practice (Gale et al., 2019), and is used in current state-of-the-art methods (Renda et al., 2020). We use global MP as baseline in all our experiments.
1Although LeCun et al. (1990) uses H(θ) in the equations of OBD, it is actually G(θ) which was used in practice (LeCun, 2007).

heading: 2.4 OPTIMAL BRAIN SURGEON
text: Optimal Brain Surgeon (OBS) (Hassibi & Stork, 1993) also relies on the quadratic model in Equation 2 to solve the minimization problem given in Equation 1, but uses the Lagrangian formulation to include the constraint to the solution of the minimization problem. Since OBS requires to compute the inverse of H(θ), several approximations have been explored in the literature, including diagonal, as in the original OBS, Kronecker-factored (Martens & Grosse, 2015) as in ML-Prune (Zeng & Urtasun, 2019), or diagonal, but in an Kronecker-factored Eigenbasis (George et al., 2018), as in EigenDamage (Wang et al., 2019). While we use OBD in our demonstrations and experimental setup, everything presented in this paper can also be used in OBS-based methods. We leave that for future work.

heading: 3 REVISITING LOSS MODELLING FOR UNSTRUCTURED PRUNING
text: In this work, we investigate linear and diagonal quadratic models of the loss function and their performance when used for pruning neural networks. In our empirical study, we aim at answering the following questions:
1. How do criteria based on weight magnitude, or linear or quadratic models compare at preserving training loss (i.e. at solving the minimization problem in Equation 1)? 2. How does the locality assumption behind criteria based on linear and quadratic models affect their performances? 3. Do pruning criteria that are better at preserving the loss lead to better fine-tuned networks?
We now describe the linear and quadratic models we use, as well as the strategies to enforce locality of the pruning steps.

heading: 3.1 LINEAR AND QUADRATIC MODELS
text: In current training strategies, regularization techniques such as early stopping or dropout (Srivastava et al., 2014) are often used to counteract overfitting. In these setups, there is no reason to assume that the training has converged, implying that the linear term in the Taylor expansion should not be neglected. Thus, one can build a pruning criterion similar to OBD that includes the gradient term in the quadratic model from Equation 2, leading to the following saliencies:2
∆LQM (θ,∆θk) ≈ ∣∣∣∣∣∂L(θ)∂θk > ∆θk + 1 2 Gkk(θ)∆θ 2 k ∣∣∣∣∣⇒ sQMk = ∣∣∣∣−∂L(θ)∂θk θk + 12Gkk(θ)θ2k ∣∣∣∣ (5) Recall the constraint ∆θk ∈ {−θk, 0}, hence the saliencies. This criterion generalizes OBD for networks that are not at convergence, and provides similar saliencies for networks that have converged.
To avoid the computational cost associated with computing second order information, which is prohibitive for large scale neural networks, one can use a simpler linear model (LM) instead of a quadratic one to approximate ∆L(θ,∆θ), leading to the following approximation and saliencies:
∆LLM (θ,∆θ) = ∣∣∣∣∣∂L(θ)∂θ >∆θ ∣∣∣∣∣ ⇒ sLMk = ∣∣∣∣∂L(θ)∂θk θk ∣∣∣∣ (6)
The saliencies of the linear model are very related to the criterion used in Single-shot Network Pruning (Lee et al., 2019b), as demonstrated by Wang et al. (2020).

heading: 3.2 ENFORCING LOCALITY
text: One important point to keep in mind is that linear and quadratic models (whether diagonal or not) are local approximations, and are generally only faithful in a small neighbourhood of the current parameters. Explicitly showing the terms that are neglected, we have:
∆L(θ,∆θ) = ∆LLM (θ,∆θ) +O(‖∆θ‖22) = ∆LQM (θ,∆θ) +O(‖∆θ‖32) (7) 2Note that this idea has been explored for OBS (Singh & Alistarh, 2020), as well as for structured prun-
ing (Molchanov et al., 2019)
So when approximating ∆L with ∆LLM we neglect the terms in O(‖∆θ‖22), and when approximating ∆L with ∆LQM we neglect the terms in O(‖∆θ‖32). Both approximations are thus only valid in a small neighbourhood of θ, and are extremely likely to be wrong when ‖∆θ‖2 is large. We list here different tricks to prevent this from happening.
Performing the Pruning in several Stages ‖∆θ‖2 can be large when a large portion of the parameters is pruned at once. An easy fix typically used to mitigate this issue is to perform the pruning in several stages, re-estimating the model at each stage. The number of stages, which we denote by π, is typically overlooked (e.g. both Zeng & Urtasun (2019) and Wang et al. (2019) use only 6 stages of pruning). Our experiments, in upcoming Section 5, show that it has a drastic impact on the performances. Note that, without fine-tuning phases between the different pruning stages, this strategy violates the convergence assumption behind OBD and OBS, since after the first stage of pruning the network is no more at convergence.
The sparsity at each stage can be increased following either a linear schedule, where each step prunes the same number of parameter, or an exponential schedule, where the number of parameters pruned at each stage gets smaller and smaller. The later is typically used in the literature (Zeng & Urtasun, 2019; Wang et al., 2019; Frankle & Carbin, 2018; Renda et al., 2020). We compare them in Section 5.
Constraining the Step Size As is often done when using quadratic models (e.g. Nocedal & Wright (2006)), one can penalize the model when it decides to take steps that are too large, in order to stay in a region where we can trust the model. This can be done by simply adding the norm penalty λ2 ‖θk‖ 2 2 to the saliencies computed by any criterion (Equations 3, 5 or 6), where λ is a hyper-parameter that controls the strength of the constraint: a small value of λ leaves the saliencies unchanged, and a large value of λ transforms the pruning criterion into MP (Equation 4).
Other Considerations ‖∆θ‖2 can be large if θ is large itself. This is dependent on the training procedure of the network, but can be easily mitigated by constraining the norm of the weights, which can be done using L2 regularisation or weight decay. Since nowadays weight decay is almost systematically used by default when training networks (e.g. He et al. (2016b); Xie et al. (2017); Devlin et al. (2018)), we do not investigate this further.

heading: 4 METHODOLOGY
text: We follow the main recommendations from Blalock et al. (2020). For fair comparison between criteria, all experiments are from our own PyTorch (Paszke et al., 2017) re-implementation, and ran on V100 GPUs.We use 5 different random seeds, and both mean and standard deviations are reported. We experiment with a MLP on MNIST, and with both VGG11 (Simonyan & Zisserman, 2014) and a pre-activation residual network 18 (He et al., 2016b) on CIFAR10 (Krizhevsky et al., 2009), to have variability in architectures, while using networks with good performance to number of parameters ratio. We further validate our findings on ImageNet (Deng et al., 2009) using a residual network 50 (He et al., 2016a). Although MNIST is not considered a good benchmark for pruning (Blalock et al., 2020), it can still be used to compare the ability of different criteria to solve the minimization problem in Equation 1. See Appendix B for details about splits, data augmentation and hyper-parameters.
Pruning Framework Algorithm 1 presents the pruning framework used in this work: we first train the network, then perform several stages of pruning, and finally perform a single phase of fine-tuning, using the same hyper-parameters as for the original training. Global pruning is used for all the criteria. Note that because of their convergence assumption, OBD and OBS advocate for fine-tuning after each stage of pruning. Since LM and QM are not based on this assumption, they should perform well in this proposed framework. While the fine tuning-phase would require hyper-parameters optimisation, Renda et al. (2020) showed that using the same ones as for the original training usually leads to good results. The hyper-parameters used in our experiments are provided in Appendix B.
Performance Metrics The performances of the pruning criteria are measured using two metrics: First, we use ∆L(θ,∆θ) = |L(θ + ∆θ)− L(θ)|, which is the quantity that the pruning criteria
Algorithm 1 Pruning Framework
Require: Network fθ with θ ∈ RD, dataset D, number of pruning iterations π, and sparsity κ. 1: fθ ← Training(fθ, D) 2: κ0 ← 0 3: m← 1D 4: for i = 1 to π do 5: κi ← κi−1 + (κ−κ0)π or κi ← κi−1 + (κ− κ0)
i/π . Compute sparsity for iteration i 6: s← Saliencies(fθ m,D) . Compute saliencies (Equation 3, 4, 5 or 6). 7: m[argsort(s)[: κiD]]← 0 . Mask the parameters with smallest saliencies. 8: fθ m ← Training(fθ m, D) . Optional fine-tuning 9: return fθ m,m
are designed to minimize (recall Equation 1). Second, we use the validation error gap before/after fine-tuning, which is the metric we ultimately care about when designing pruning methods.

heading: 5 PERFORMANCES BEFORE FINE-TUNING
text: We evaluate the impact of enforcing locality in the LM, QM and OBS criteria. For each criterion, Figure 1 reports ∆L(θ,∆θ) as a function of λ, for different number of pruning stages π, using the exponential pruning schedule, and Figure 5 in Appendix show the same results for the linear pruning schedule. A typical usage of these criteria would be with a regularisation strength λ = 0 and a number of pruning stages π ≈ 1. MP, the baseline, which is invariant to both λ and π, is also reported in dashed black. For reference, the networks reached a validation error rate before pruning of 1.47± 0.04 % for the MLP, 10.16± 0.29 % for VGG11 and 4.87± 0.04 % for the PreActResNet18.

heading: 5.1 IMPACT OF THE ASSUMPTIONS BEHIND THE DIFFERENT CRITERIA
text: Locality Assumption Figure 1 shows that increasing the number of pruning stages can drastically reduce ∆L(θ,∆θ) when using LM, QM and OBS criteria. It demonstrates the importance of applying local steps when pruning. Constraining the steps size through λ2 ‖θk‖ 2 2 can also reduce ∆L(θ,∆θ), on CIFAR10 in particular. The trend, however, is less pronounced on MNIST. We hypothesize that it is due to the pruning step size: the MLP contains 260k parameters, vs 9.7M for VGG11, so the number of parameters pruned at each stage in VGG11 is still large, even with π = 140. This translates to a bigger ‖∆θ‖2 that needs to be controlled by the regularisation constraint.
Convergence Assumption When performing the pruning in several stages, we also observe that LM and QM can reach better performances than OBD. Without retraining phases between pruning stages, we violate the convergence assumption of OBD. This is however not the case for LM and QM, since they are not based on this assumption. Note that OBD still works reasonably well on VGG11. This could be be related to the depth of VGG11: VGG11 is deeper than the MLP, but not equipped with residual connections like the PreActResNet18.

heading: 5.2 LOSS-PRESERVATION CAPABILITIES OF THE DIFFERENT CRITERIA
text: Table 1 contains the best ∆L(θ,∆θ) for each of the networks and pruning criteria. Our main observation is that the criteria that model the loss (LM and QM in particular) are better at preserving the loss than MP. Similarly to Table 1, Table 3 in Appendix contains the best validation error gap before/after pruning, where we can observe similar tendencies.

heading: 5.3 LINEAR VS EXPONENTIAL PRUNING SCHEDULE
text: Figure 2 compares the impact of ‖∆θ‖2 and reports the training error gap when pruning VGG11 on CIFAR10 in several stages, using either the linear or the exponential pruning schedule. We also compare against one-shot pruning, as reference. The exponential schedule allows to maintain a more constant ‖∆θ‖2 throughout the pruning procedure, which limits the maximum size of ‖∆θ‖2, and thus better satisfies the locality assumption.

heading: 6 PERFORMANCES AFTER FINE-TUNING
text: We now fine-tune the pruned networks using the same hyper-parameters and number of epochs than for the original training. Table 2 shows the validation error gap between the non-pruned networks and the pruned networks after fine-tuning, for all considered criteria. LM performs better than MP on both the MLP and VGG11 (0.5% difference), but all criteria perform similarly on the PreActResNet18. These results are consistent with the observations of Blalock et al. (2020). As reference, global random pruning resulted in validation error rate of 47.18 ± 6.8 % for the MLP, and resulted in non-retrainable networks on CIFAR10 (with 90 % error rate).

heading: 6.1 CORRELATION BETWEEN LOSS-PRESERVATION AND PERFORMANCES AFTER FINE-TUNING
text: An important observation is that the hyper-parameters λ and π that give the best performing criteria in terms of ∆L(θ,∆θ) in Table 1 are not the same as the ones that give the best performing criteria after fine-tuning in Table 2. We display in Figure 3 scatter plots of all the experiments we ran, to observe how well loss-preservation correlates with performance after fine-tuning.
Quite surprisingly, although we are able to obtain networks with smaller ∆L(θ,∆θ), and thus better performing networks right after pruning, the performances after fine-tuning do not correlate significantly with the gap. Except for the MLP on MNIST, whose Spearman’s rank correlation coefficient is ρ = 0.67, there is only a weak correlation between ∆L(θ,∆θ) and the validation error gap after fine-tuning (ρ = 0.27 for VGG11 and ρ = 0.20 for PreActResNet18). Figure 10 in Appendix contains the same scatter plots, but showing L(θ m) after fine-tuning instead of the validation error gap, and similar trends can be observed. Figure 11, also in Appendix, shows similar scatter plots, but for different sparsity levels on VGG11. Finally, Figure 9 in Appendix contains the same scatter plots but displaying the validation error gap before fine-tuning versus the validation error gap before fine-tuning.
To verify that these observations are not due to a specific choice of fine-tuning hyper-parameters, we perform a hyper-parameter grid search and report similar results in Appendix C.2. Also, we show in Figure 15 in Appendix C.3 the fine-tuning curves of networks pruned using MP and our best QM criteria. We observe that, except for MNIST, the difference in training loss right after pruning disappears after only one epoch of fine-tuning, erasing the advantage of QM over MP.

heading: 6.2 DISCUSSION
text: These results highlight an important issue: minimizing ∆L(θ,∆θ), no matter what model is used, might be used to design better pruning criteria, but it does not necessarily transfer to a better pruning method when fine-tuning is involved. The performance after fine-tuning cannot be explained solely by the local loss-preserving abilities of the criteria, and other mechanisms might be at play. Thus, the effect of fine-tuning should also be taken into account when designing pruning criteria.
For instance, Lee et al. (2019a) and Wang et al. (2020) proposed different heuristics to take into account gradient propagation in the context of foresight pruning, i.e. pruning untrained networks right after initialisation. Wang et al. (2020) argues that minimizing ∆L(θ,∆θ) in that context makes little sense, since the network is producing random predictions. In Appendix C.4 we compare our results to two pruning methods based on preserving the gradient flow, GraSP (Wang et al., 2020) and SynFlow (Tanaka et al., 2020), and show that they comply with our observations above.
Finally, several recent articles are looking further into the impact of various pruning criteria on subsequent training or fine-tuning (Lubana & Dick, 2020; Evci et al., 2020; Frankle et al., 2020).

heading: 7 SCALING UP TO IMAGENET
text: To investigate whether our observations also hold on larger datasets, we perform similar experiments with LM, QM and OBD on the ResNet50 on ImageNet. Before pruning, the network reached 76.41% validation accuracy. Figure 4 presents results at 70 % sparsity, in a similar fashion as Figure 1 and Figure 3. We observe a similar trend: The best loss-preserving models are not necessarily the best models after fine-tuning. See Appendix B for the detailed experimental setting, and see Figure 17 for results at 90 % sparsity.

heading: 8 CONCLUSION
text: In this paper, we revisited loss modelling for unstructured pruning. We showed that keeping the gradient term in the diagonal quadratic model allows to relax the convergence assumption behind
OBS and OBD. We also showed the importance of locality when using loss models for pruning: increasing the number of pruning stages and constraining the step size are two improvements that produce better loss-preserving pruning criteria and that should be added to the recommendation list of Blalock et al. (2020). Finally we observed that the loss right after pruning does not always correlate with the performances after fine-tuning, suggesting that a better loss before fine-tuning is not solely responsible for the performances after fine-tuning. Thus, future research should focus on ways to model the actual effect of subsequent fine-tuning when designing pruning criteria.

heading: A GENERALIZED GAUSS-NEWTON
text: Having to compute H(θ) is an obvious drawback of quadratic models, and thus a common first step is to approximate H(θ) using the Generalized Gauss-Newton approximation (Schraudolph, 2002):
H(θ) = 1
N N∑ i=1 ∂fθ (xi) ∂θ > ∇2u=fθ(xi)` (u, ti) ∂fθ (xi)
∂θ︸ ︷︷ ︸ G(θ), the Generalized Gauss-Newton
+ K∑ k ∂` (u, ti) ∂uk ∣∣∣ u=fθ(xi) ∂2fθ (xi)k ∂θ2︸ ︷︷ ︸
≈0
(8)
≈ G(θ) (9)
where K is the number of outputs of the network. G(θ) has the advantage of being easier to compute and is also positive semi-definite by construction.

heading: B DETAILS ON THE EXPERIMENTAL SETUP
text: B.1 SETUP
Datasets We use the MNIST dataset (LeCun et al., 1998), and hold-out 10000 examples randomly sampled from the training set for validation. We also use CIFAR10 (Krizhevsky et al., 2009), where the last 5000 examples of the training set are used for validation, and we apply standard data augmentation (random cropping and flipping, as in He et al. (2016b)) during training phases. For ImageNet (Deng et al., 2009), we follow the experimental setting of Goyal et al. (2017).
Network Architectures On MNIST, we use a MLP of dimensions 784-300-100-10, with Tanh activation functions. On CIFAR10, we use both: a VGG11 (Simonyan & Zisserman, 2014), equipped with ReLUs (Nair & Hinton, 2010), but no Batch Normalisation (Ioffe & Szegedy, 2015); and the PreActResNet18, which is the 18-layer pre-activation variant of residual networks (He et al., 2016b). MLP leverages Glorot & Bengio (2010) as initialization while the the weights of VGG11 and PreActResNet18 are initialized following He et al. (2015), and the biases are initialized to 0. On ImageNet (Deng et al., 2009), we use a ResNet-50 (He et al., 2016a) with Batch Normalization, and follow the initialization strategy described in (Goyal et al., 2017).
B.2 EXPERIMENTS
For the MNIST and CIFAR10 experiments, the network is first trained for a fixed number of epochs, using early stopping on the validation set to select the best performing network.The hyper-parameters used for training are selected via grid search (before even considering pruning). Then we prune a large fraction of the parameters. For OBD, LM and QM, we randomly select, at each iteration of pruning, 1000 examples (10 mini-batches) from the training set to compute the gradients and second
order terms of the models.3 Finally, we retrain the network using exactly the same hyper-parameters as for the initial training.
For ImageNet, we uses the exact same hyper-parameters than Goyal et al. (2017).
MLP on MNIST We train the network for 400 epochs, using SGD with learning rate of 0.01, momentum factor of 0.9, l2 regularisation of 0.0005 and a mini-batch size of 100. We prune 98.85% of the parameters.
VGG11 on CIFAR10 We train the network for 300 epoch, using SGD with a learning rate of 0.01, momentum factor of 0.9, a l2 regularisation of 0.0005 and a mini-batch size of 100. The learning rate is divided by 10 every 60 epochs. We prune 95.6% of the parameters.
PreActResNet18 on CIFAR10 We train the network for 200 epochs, using SGD with a learning rate of 0.1, momentum factor of 0.9, a l2 regularisation of 0.0005 and a mini-batch size of 100. The learning rate is divided by 10 every 70 epochs. We prune 95.6% of the parameters.
ResNet50 on ImageNet For ImageNet, we train a ResNet50 using 8 V100 GPUs. The total minibatch size is 256, and we train our baseline network for 90 epochs. The learning rate schedule is identical to Goyal et al. (2017): a linear warm-up in the first 5 epochs and decay by a factor of 10 at epochs 30, 60 and 80. We then prune 70% of the parameters. After pruning, we fine-tune the models for 90 epochs using a learning rate of 1e−3. For LM, QM, OBD, we investigates the following hyper-parameter values: π ∈ {1, 100}, λ ∈ {1e−3, 1e−1, 0, 10, }. 1600 examples are used to compute the first and second order terms of the linear and quadratic models.

heading: C SUPPLEMENTARY RESULTS
text: C.1 PERFORMANCES BEFORE FINE-TUNING
Validation error Table Table 3 is the same as Table 1, but containing the best validation error gap before/after pruning instead of ∆L(θ,∆θ). We can observe a similar trend as in Table 1: LM and QM give better performances than MP, and OBD performs poorly, since the convergence assumption is not respected.
Linear pruning schedule Figure 5 contains the same experiments than Figure 5, but using the linear schedule instead of the exponential one. There is a drastic difference in performances: One need roughly 10x more stages of pruning with the linear schedule to reach the training gap of the exponential schedule.
C.2 PERFORMANCES AFTER FINE-TUNING
Validation error figures Figures 8 and 7 contain the same experiments than Figure 5, but displaying the validation error gap, for linear and exponential schedules, respectively. For completeness, Figure 6 shows the validation error gap before fine-tuning.
3Using 1000 examples or the whole training set made no difference in our experiments. Using less examples started to degrade the performances, which concord with the observations of Lee et al. (2019b)
Validation gap before and after fine-tuning Figure 9 is the same as Figure 3, but showing the validation error gap after fine-tuning as a function of the validation error gap before fine-tuning. As for Figure 3, we do not observe much correlation between the validation error before and after the fine-tuning.
Training loss after fine-tuning Figure 10 is the same as Figure 3 but showing L(θ m) after finetuning as a function of ∆L(θ,∆θ). It has a similar trend as Figure 3: there is not much correlation between the loss before and after fine-tuning, except on MNIST.
Different sparsity levels Figure 11 shows the performances of different criteria on VGG11 on CIFAR10, for different sparsity levels. When the sparsity is low (89.3 %), the network has enough capacity to return to its original performances after fine-tuning. When the sparsity is too high (98.6 %),
then all criteria produce networks with random predictions. There might be a sweet spot in between, but one would require more powerful model to verify this supposition.
Hyper-parameters optimisation Figure 13 shows the impact of hyper-parameter optimization for the fine-tuning phase. We performed a grid search with three different learning rate (0.1, 0.01, 0.03)
and three different l2-regularisation (0, 5e-4, 5e-5). All 9 sets of hyper-parameters were tested on LM, QM and MP on 5 different random seeds. In this set of experiments, we used λ ∈ {0, 0.01, 0.1, 1} and π ∈ {14, 140}. Optimizing hyper-parameters for fine-tuning can lead to better performance after fine-tuning, but does not increases the correlation between the performances after fine-tuning and ∆L(θ,∆θ). The lack of correlation can thus not be explained by bad fine-tuning hyper-parameters.
C.3 FINE-TUNING CURVES
To investigate whether one of the networks is suffering from optimization issues during fine-tuning, we show in Figure 15 the fine-tuning curves of networks pruned using MP and our best QM criteria. We observe that, except for MNIST, the difference in training loss right after pruning disappears after only one epoch of fine-tuning, erasing the advantage of QM over MP.
C.4 RESULTS USING GRASP AND SYNFLOW
We compare our results with two additional pruning methods that focus on preserving the flow of the gradient in the network instead of preserving the loss: GraSP (Wang et al., 2020), a datadependant method, and SynFlow (Tanaka et al., 2020), a data-agnostic one. Both methods were design to be applied at initialisation, so we investigate here their use on trained networks. We use π ∈ {1, 100, 1000}, and added our proposed step size constraint λ to the pruning criteria as well. Figure 16 shows the scatter plot of the preservation of the loss vs the performance after fine-tuning. Similarly to what we observed before, there is no clear evidence that better preserving the loss lead to better performance after fine-tuning.
C.5 RESULTS ON IMAGENET
Figure 17 is the same as Figure 4, but with 90 % sparsity. At that sparsity level, the validation accuracy right after pruning is close to random for all the pruning criteria. There is however quite a big variation in performances after fine-tuning: at equal performance before fine-tuning, some models achieve 70 % validation accuracy after fine-tuning, while others only reach 60 %.

Review summaries:
- This paper conducted a detailed study on how does the loss modeling affects the final performance of the pruned model. The authors first provided a unified view of various pruning algorithms (e.g., Magnitude Pruning, SNIP, OBD, and OBS), which can be categorized into three classes: weight magnitude, linear and quadratic models of the loss function. In the experiments, the authors seek to answer the questions: 1) how well do each criterion preserve the loss; 2) how does the locality assumption affect the final performance; and 3) how does the loss relate to the final performance? Empirical, the authors found that the quadratic model preserves the loss the best, as expected. Also, the loss after pruning seems not strongly correlated with the performance after fine-tuning.

The authors study the use of loss-modeling to maintain model quality when inducing unstructured sparsity in deep neural networks. They study a range of different approximations and modifications that can help improve the quality of the approximation (taking local steps, avoid large changes in weight magnitude, avoiding assumptions about convergence). The authors conduct a thorough empirical investigation that yields practical observations for the design of future pruning techniques.