Title: Pruning vs Quantization: Which is Better?
Venue: NeurIPS 2023
Accepted: yes
Keywords: Neural network quantization

neural network pruning

magnitude pruning

post-training quantization

quantization-aware training
Abstract: Neural network pruning and quantization techniques are almost as old as neural networks themselves. However, to date, only ad-hoc comparisons between the two have been published. In this paper, we set out to answer the question of which is better: neural network quantization or pruning? By answering this question, we hope to inform design decisions made on neural network hardware going forward. 
We provide an extensive comparison between the two techniques for compressing deep neural networks. 
First, we give an analytical comparison of expected quantization and pruning error for general data distributions.
Then, we provide lower and upper bounds for the per-layer pruning and quantization error in trained networks and compare these to empirical error after optimization.
Finally, we provide an extensive experimental comparison for training 8 large-scale models trained on 3 tasks and provide insights into the representations learned during fine-tuning with quantization and pruning in the loop.
Our results show that in most cases quantization outperforms pruning. Only in some scenarios with a very high compression ratio, compression might be beneficial from an accuracy standpoint.

Pruning vs Quantization: Which is Better?

Abstract

Neural network pruning and quantization techniques are almost as old as neural networks themselves. However, to date only ad-hoc comparisons between the two have been published. In this paper, we set out to answer the question on which is better: neural network quantization or pruning? By answering this question, we hope to inform design decisions made on neural network hardware going forward. We provide an extensive comparison between the two techniques for compressing deep neural networks. First, we give an analytical comparison of expected quantization and pruning error for general data distributions. Then, we provide lower bounds for the per-layer pruning and quantization error in trained networks, and compare these to empirical error after optimization. Finally, we provide an extensive experimental comparison for training 9 large-scale models on 4 tasks. Our results show that in most cases quantization outperforms pruning. Only in some scenarios with very high compression ratio, pruning might be beneficial from an accuracy standpoint. 1

1 Introduction

Recent advances in deep learning led to exceeding human-level performance in many tasks, including computer vision, machine translation, voice recognition, and language understanding. Real-world applications of DNNs rely heavily on their efficiency. Both mobile and cloud platforms greatly benefit from reduced latency and energy efficiency achieved by some form of model compression. In this work, we consider two mainstream techniques used in practice; pruning and quantization.

Pruning methods remove individual weights [70, 25], or sometimes groups of weights [28, 47]. This procedure can reduce the memory footprint. Furthermore, not having to perform the computations with weights that are zeroed out can make network inference more efficient. On the other hand, quantization reduces the bit-width used for both the weights and the computation used in networks, leading to both predictable memory savings and reductions in the necessary compute. In both scenarios, the hardware used for making use of these optimization schemes needs to take them into account.

Depending on the availability of training data and computing budget, most methods for pruning and quantization fall into one of two families. The first family includes fine-tuning approaches, namely quantization-aware training (QAT) and fine-tuning with pruning in the loop. The second family includes post-training approaches such as post-training quantization (PTQ). Previously, pruning techniques primarily relied on fine-tuning; however, some post-training pruning methods appeared recently as fine-tuning is not desirable for large language models [18].

Despite the importance of model efficiency and the plethora of approaches for pruning and quantization, the two fields are mostly disjoint. The literature presents little insight into which of the two

INT4 quantization versus 75% pruning, × ~ N(0,1)

Squared error weigthedbyp(x)

ComparisonofSNR

0.40

0.35

Original

Quantized

0.25

Quant.

Pruning

40

35

PruningSNR

QuantizationSNR

0.30

Pruned

（x-(x)o）（x）d

2

0.20

30

0.25

0.20

0.15

25

20

0.15

0.10

15

0.10

0.05

10

0.05

S

0.00

0.00

-3

-2

T-

口

1

2

3

-1

0

1

2

3

8b

7b

6b

5b

4b

3b

2b

X

X

techniques is more accurate. In practice, there is only limited time to compress a network and limited energy to spend on making deep learning inference hardware. For this reason, we ask the question: Should one focus on quantization or pruning for compression?

Wepresent an extensive study comparing pruning and quantization in equal settings. First, we consider different data distributions and analyze the conditions under which each method is preferable. We match our findings with real weight tensors from pre-trained models. Second, we consider a posttraining scenario and evaluate single-layer output errors for both methods. Because the comparison might depend on the specific choice of optimization method, we compare the two with theoretical bounds that apply regardless of the optimization method. Finally, we provide a full-model comparison for the most common scenario of fine-tuning networks after either pruning or quantization.

In our comparison, we intentionally avoid considering the hardware aspects of pruning and quantization. Instead, we focus solely on the accuracy of both methods, given similar theoretical compression ratios. A coarse discussion on the hardware necessary for both methods can be found in section 6.

2 Assumptions

In our work, we assume FP16 as the basic data type and measure any gains in compression with respect to it. Using FP16 for inference generally does not lead to a loss in accuracy. Neural networks are also very commonly trained with FP16, making it a common baseline. Thus, we compare 50% pruning sparsity to INT8 quantization, 75% sparsity to INT4 quantization and so forth. We also assume no overhead on storing the sparsity mask for pruning and relegate such hardware-specific implementations to section 6.

For the pruning experiments, we consider magnitude pruning. It is common to do fine-tuning after or during pruning [70]. Several works have independently shown that despite its simplicity, it is tough to improve upon magnitude pruning and fine-tuning [19, 4]. To our knowledge, no pruning algorithm exists that consistently outperforms this method.

For the quantization experiments, we use symmetric uniform quantization, which is defined by just the quantization scale factor and the bit-width. The scale is represented as a floating-point number and is used to map floating-point values to the integer grid. Further details on symmetric uniform quantization can be found in [49]. Uniform quantization is the standard in the quantization literature, and symmetric quantization is mostly employed for the weights. In all our experiments, we use a quantization range estimator minimizing the mean-squared error on weights by grid search [49].

3 Comparison on statistical distributions

Before diving into comparison results, we first describe theoretically what the quantization error and pruning error are. Looking at this with a theoretical lens helps with understanding the later experimental difference between the two methods. We start off by describing and analyzing both methods on simple data distributions.

In order to compare the error of pruning and quantization, we will frequently use the signal-to-noise ratio measure defined in the log scale: SNR dB = 10log 10 ( E [ W 2 ] / E [ ( W -F ( W )) 2 ]) , where F ( W ) is the quantization or pruning function. This measure is the same as a scaled logarithm of

Pruning SNR

QuantizationSNR

Pruning SNR > Quant. SNR

8

50

8

50

8

7

7

7

40

40

6

6

6

bits

5

30

s

30

bits

Quantizationisbetter

#

4

20

#

4

20

#

4

m

3

m

2

10

2

10

2

Pruningisbetter

0

0

D

10

15

20

0

5

10

15

20

0

2

5

8

10

12

15

18

20

Kurtosis

Kurtosis

Kurtosis

an MSE measure. Both are often employed to analyze the sensitivity of neural network layers to quantization, and they are theoretically well-founded to correlate with network performance [41, 48].

3.1 Quantization error

For quantization, we consider symmetric uniform quantization, which is also called integer quantization. Given a bit-width b and the scale δ , the grid nodes are defined as q i = δi, i ∈ {-2 b , . . . , 0 , 2 b -1 } . The quantization operation rounding-to-nearest Q ( w ) and the corresponding quantization error R ( w ) are defined as:

Following [36] we model neural network weights as a random variable W ∼ p ( w ) . The expected value of the quantization MSE can be expressed as follows:

where q min = min i q i and q max = max i q i are the quantization range limits. The left term corresponds to the rounding error, and the right two terms correspond to the clipping error. We use this analytic formulation for our distribution results below, the details are given in appendix A.

3.2 Pruning error

We consider magnitude pruning T ( x ) = x · 1 -t ≤ x ≤ t . This simply sets the values closest to zero to actual zero. Given this, the expected error of pruning is expressed as follows:

where t is the threshold value that controls how much is pruned. Given the compression ratio c ∈ (0 , 1) , we find the threshold value which satisfies P ( -t ≤ W ≤ t ) = c . In case of a symmetric zero-mean distribution, the threshold can be expressed as t = F -1 W ( 1 2 + c 2 ) , where F ( w ) = P ( W ≤ w ) is the CDF function and F -1 ( p ) is its inverse. The expected pruning error in equation 3 is similar to the clipping error for quantization (see the second and the third term in equation 2), and can also be computed analytically. We also use this formulation for our results below.

3.3 Analytical comparison

Standard normal distribution. Let us first look at a standard normal distribution. As many weights in neural networks are roughly Gaussian-shaped, this distribution is useful for our understanding of

Quantization SNR

()       1

Pruning SNR >Quant.SNR

60

INT8 vs 50.0% sparsity

INT8vs50.0%sparsity

50

INT8 vs 50.0% sparsity

INT8vs50.0%sparsity

INT8 vs 50.0% sparsity

INT8 vs 50.0% sparsity

40

INT8 vs 50.0% sparsity

Pruning SNR

Quantizationisbetter

#

30

Z

10

Pruning is better

10

Z

30

40

50

60

0°0

2.5

5.0

7.5

10.0

12.5

15.0

17.5

Kurtosis

the comparison. As we can see from figure 1 (middle), the errors for both methods have very different behavior. The quantization error oscillates between the quantization nodes and has a moderate range. The pruning error effectively corresponds to rounding many weights to zero and thus has a higher error. As we can see in figure 1 (right), this results in a higher SNR for quantization, e.g. 19.1 dB for INT4 quantization versus only 5.6 dB for 75% pruning. We see similar results for different compression ratios. For this distribution, quantization achieves a much higher signal-to-noise ratio.

Distributions with heavy tails. The trade-off is expected to change when more significant outliers are introduced. The quantization grid is expected to be effected strongly by outliers as it increases the quantization grid in size, whereas the pruning method is expected to be hardly effected with outliers as it only affects weights around zero. We thus analyze both quantization and pruning errors in the presence of many outliers. To simulate a distribution with outliers, we use a truncated Student's-t distribution with ν = 2 , and a symmetric range ( -r, r ) (the PDF is defined in appendix B). This distribution is nice as it gives a non-trivial weight to the tail ends of the distribution close to r . The wider the range r is, the heavier are the tails of the distribution.

In order to introduce a quantitative measure of the number of outliers, we will use the distribution's kurtosis given by Kurt [ X ] = E [ ( X -µ ) 4 ] / ( E [ ( X -µ ) 2 ]) 2 , where µ is the mean. We will see later that this kurtosis measure is predictive of quantiation and pruning performance for real layers. To increase the number of outliers, we will increase the range r . The results are given in figure 2. The kurtosis range is chosen so that it includes most of the weights from the model zoo. We see that despite the significant outliers and high kurtosis, quantization still has higher SNR in most of the cases for moderate compression. Pruning is better however in the region of high clipping range and very high compression rate, e.g. 2-3 bits per value (see figure 2 on the right).

3.4 Experiments on real weight tensors

The previous discussion was mostly theoretical. We set out to see happens when we do a similar analysis on real neural network weights. In order to investigate this, we compare the pruning and quantization SNR on the weight tensors for all the pre-trained models from the PyTorch model zoo 2 (46 models in total, the details are give in appendix E) combined with weight tensors from 3 large language models, namely Bloom-3b [3], Llama-3b [20], OPT-2.7b [67]. Each tensor is quantized using an integer grid of bit widths from 2 to 8. The results are shown in the figure 3(left). We see a similar trend to our previous discussion that pruning becomes more beneficial for lower bitwidth/higher sparsity ratios.

In order to match the analytical results from figure 2, we consider the sample kurtosis of every weight tensor given by k = 1 n ∑ n i =1 ( x i -x ) 4 / [ 1 n ∑ n i =1 ( x i -x ) 2 ] 2 . See figure 3 (right). We consider a range of kurtosis values for every quantization bit-width. Using a kernel density estimator, we compute the probability density of encountering a tensor for which pruning has higher SNR than

20.0

quantization SNR. We compare the PDF to that for quantization and thus determine the region where each method is preferable. The results are given in figure 3 on the right. We see that the results from the previous theoretical section (figure 2 on the right) hold very nicely. We can also see that as predicted, the kurtosis is indeed a good metric for predicting if a tensor should be quantized or pruned for optimal accuracy.

4 Per-layer comparison

Most PTQ methods compress the model layer by layer. Given one layer, we use the mean-squared error of the output activations as an objective for optimization. As [48] shows, minimizing per layer MSE on the output activations of each layer is a computationally affordable second-order approximation of the loss function. The local MSE objective correlates well with the task loss and is often used in practice in DNN compression and quantization literature [32, 40, 68]. Our experiments in appendix D confirm this. For the experiments in this section, we will use SNR as it represents a normalized version of MSE. As opposed to section 3 where we used SNR on weights, in this section, we will use SNR on the output activations instead.

The goal of a PTQ method is to minimize the error in the output activations of the compressed layer by optimizing over the quantized weights subject to integer range constraints. Similarly, for pruning, the weights are optimized subject to a sparsity constraint. As the underlying combinatorial optimization problem for both methods is NP-hard [56, 14], in practice, each method relies on some form of heuristic providing a reasonably good solution given a realistic compute budget. This means that any practical comparison between pruning and quantization would depend on the choice of the method for both and would be open to debate of the optimality of the algorithm. In order to eliminate this dependence, we provide a tight lower bound on the output errors for quantization. For pruning we provide a way to solve the problem exactly for moderate dimensionalities. This way, we can provide a comparison that holds regardless of the algorithm used for each method.

4.1 Post-training quantization

We set out to formulate a way by which we can get relatively tight bounds for comparison when quantizing a single layer with the MSE as the objective. The higher bound is simple to obtain by using a solution with a heuristic quantization algorithm, but for the lower bound, we have to reformulate the problem. The mean-squared error of the output activations of a quantized layer can be expressed as:

where X is the input data in an unfolded form, and w orig are the floating point weights. The quantized weights are computed as the product of the quantization scale δ , and the integer weights w . w min and w max are the integer limits. We ignore the averaging operation to simplify the notation, as it is not important for optimization. We also note that this problem can be solved independently for each output channel of a convolution or every row of a fully-connected layer weight.

This problem is an instance of a mixed-integer quadratic program:

where P = 2 δ 2 X T X , q = 2( w T orig X T ) X δ . In order to simplify the objective, we can omit the constant term that is irrelevant for the optimization c = ∥ Xw orig ∥ 2 2 , i.e. ˜ E ( W ) = E ( W ) -c .

In order to find the lower bound of the objective, we follow [55] and relax the integer constraint to w i ( w i -1) ≥ 0 , which allows the weight to take values within the interval from 0 to 1. In order to

obtain the lower bound, we will consider the dual version of the relaxed problem:

where λ ∈ R n , γ ∈ R . The dual problem is convex, and its solution can be used as a lower bound on the solution of the original problem, i.e., ˜ E ( w ) ≥ L ( λ ) . The dual has a semi-definite constraint which can be solved with a semi-definite programming (SDP) solver with O ( n 3 ) complexity. In our work, we used CVX solver [21]. As discussed in [55], this bound is a computationally efficient alternative to branch-and-bound approaches, while tightness is better than that for the alternative methods introduced in [5]. We use this approach for estimating the lower bound for MSE on the output activations for PTQ below.

4.2 Post-training pruning

We also need a similar lower bound for pruning for comparison. To the best of our knowledge we are not aware of the ways to provide a tight lower bound for this problem, therefore we formulate a way to solve a problem for moderate dimensionalities exactly. Similar to quantization, post-training pruning of one layer of the network can mathematically be expressed as solving the following optimization problem:

where the number of non-zero elements s in the solution is theoretically constrained by using the L 0 norm, which is non-convex and not smooth. In order to solve the problem, we introduce the sparsity mask m ∈ R n :

where ⊙ is an element-wise product operation, and l, u ∈ R are constants chosen such that any solution satisfies the constraint -m ⊙ l ≤ ˆ w ≤ m ⊙ u . We solve this problem using the branch-andbound method implemented in the Gurobi solver [23] that gives the global solution.

4.3 Experiments

With our algorithms in the bag, we can now compare quantization versus pruning in the post-training settings with theoretical bounds. In each case, we analyze individual layers of several networks. Given a batch of input data, we optimize the pruned or quantized weights to minimize the error between the output activations and the output of the uncompressed layer. We provide a range between two SNR values for each method in each case. The performance of the heuristic method gives the first value, and the second value is given by the error lower bound or the global solution, which translates into SNR upper bound.

As a heuristic method for pruning, we use magnitude pruning with a fixed sparsity mask m optimized weights w given by w = argmin ∥ X ( m ⊙ w ) -Xw orig ∥ 2 . This is a convex problem and dataw 2

and has a unique solution. As a heuristic method for quantization, we use the mixed-integer solver introduced in [55]. We clip every sample in order to satisfy the integer quantization range constraint.

We chose a representative set of 10 layers, including 9 convolutional layers (one 3x3 convolutional layer and 8 point-wise convolutions) from MobileNet-V2, EfficientNet-lite, and Resnet-18, and one fully-connected layer from ViT. The full details for reproducing the experiments are given in appendix F. Due to the high computational complexity of the global solution for pruning, the layers

Per layer comparison (FP16 basic type)

INT8 vs 50.0% sparsity

50

INT7 vs 56.25% sparsity

INT6 vs 62.5% sparsity

INT5 vs 68.75% sparsity

40

INT4 vs 75.0% sparsity

INT3 vs 81.25% sparsity

INT2 vs 87.5% sparsity

Pruning SNR

OE

20

10

0

10

20

OE

40

50

QuantizationSNR

had to be split into chunks. The slice of 4 input channels over all output channels was used for 3x3 convolutions. In the case of linear layers and point-wise convolutions, slices 36 input features over all the output features were used.

The results are shown in figure 4 grouped by bit-width. The rectangles indicate the full range of the pruning and quantization methods between the heuristic solution and the error lower bound or the global solution. Whenever a rectangle for each chunk intersects the diagonal line, the ranking of the two methods could depend on the optimization method, while in cases below or above the diagonal, the ranking is guaranteed regardless of the optimizer. We see that quantization mostly outperforms pruning for moderate compression, while methods become more comparable for higher compression ratios.

5 Full-model comparison

Now that we have seen the comparison between the methods in the PTQ setting, we turn to fine-tuning quantized and pruned models. This is the setting where pruning is applied in most, and it is possible that fine-tuning can change the models significantly enough that the performance between the two methods changes.

In order to provide a fair comparison of pruning and quantization, we chose the two most commonly used methods with performance competitive to state-of-the-art. For quantization-aware training, we used the widely adapted LSQ method suggested in [12, 2]. Following this approach, we jointly learn the weights and quantization scales, keep the batch norm layers unfolded, and re-estimated the batch norm statistics after training to avoid wrong running estimates due to oscillations [51]. We use the method suggested in [70] for pruning, which gradually increases the sparsity during fine-tuning and re-estimates batch norm statistics after training.

In our experiments we used a set of 4 models trained for 4 tasks including Resnet18, Resnet50 [27], MobileNet-V2 [58], MobileNet-V3-small [30], EfficientNet-lite [60], and ViT [11] trained on ImageNet classification [57]; DeepLab-V3 [7] with MobileNet-V2 backbone trained for semantic segmentation on Pascal VOC [13]; EfficientDet [61] trained for object detection on MS COCO [43]; OPT-350 fine-tuned on WikiText-103.

For a fair comparison, we used the same amount of epochs of fine-tuning for each method (full details on hyperparameters are given in appendix G). The results given in table1 suggest that pruning almost never leads to higher accuracy than quantization if an equal compression rate is considered. The differences are sufficiently large enough that the small purported improvements by some methods [59] will likely not close the gap.

To study the effect of training time, we also performed an ablation with 2 times longer fine-tuning on a subset of 3 models (Resnet50, EfficientNet, and ViT). The results are given in appendix H. We observe that pruned models generally benefit from fine-tuning more, and in particular pruning

becomes more beneficial for most compression ratios on Resnet50. However, for the other models, quantization is still more beneficial due to a larger gap in performance.

Combining pruning and quantization Another interesting questions is whether pruning is beneficial in combination with quantization. To answer it, we perfromed an experiment on pruning quantized Resnet-18, MobileNet-V2 and ViT with different pruning ratios. The results are given on figure 5. On x-axis we plot the expected bit-widths which is a product of the base bit-width and the sparsity in the pruned model including the natural sparsity. The points marked by crosses are quantized models with only natural sparsity and no extra pruning applied. As we can see, mild degrees of pruning are beneficial in the combinations. However, we note that no extra overhead was assumed for storing the pruning mask.

Resnet-18, pruning and quant. combinations

MobileNet-V2, pruning and quant. combinations

ViT, pruning and quant. combinations

00

0.7

0.80

0.6

0.68

0.5

0.78

0.66

0.4

0.76

INT8 + pruning

0.3

6uqunud + 81N1

INT8 + pruning

0.64

INT7 + pruning

INT6 + pruning

INT5 + pruning

INT4 + pruning

0.2

0.1

6uurud + LINI

5urunud + SLNI

INT4 + pruning

INT6 + pruning

0.74

INT7 + pruning

INT6 + pruning

INT4 + pruning

0.62

INT3 + pruning

INT2

0.0

6urunud + CLN1

INT2

0.72

INT3 + pruning

INT2

avg. # bits

5

为

4

avg. # bits

u1

b

7

8

4

avg. # bits

7

6 Discussion

Other types of pruning While we solely focused in our comparison on unstructured pruning in which individual weights are removed, our results translate to semi-structured and structured pruning. Unstructured pruning has more degrees of freedom and is a strict superset of what can be

represented by (semi-)structured pruning. Therefore, unstructured pruning gives an upper bound of the accuracy for all pruning methods. This means that for the cases in which quantization is better than unstructured pruning, quantization will also be better than (semi-)structured pruning. However, we can not make any claims for (semi-)structured pruning for the few scenarios in which pruning is better than quantization.

Natural sparsity in quantized tensors In our comparison, we used a theoretical compression ratio for quantization, which depends on the bitwidth. However, we also observe that quantized tensors naturally contain many zeros; for example, 8-bit tensors from PyTorch model zoo have an average sparsity of 13% while 4-bit tensors are 35% sparse. We give more details on this in appendix C.

Representations learned in the compressed models To provide insights into representations learned during pruning or QAT, we studied the evolution of models during fine-tuning. We found that fine-tuning after pruning tends to recover the original representation, while quantization-aware training leads to learning completely new representations. We provide further details on these experiments in appendix I.

Hardware implications So far, we have deliberately avoided discussing the hardware implementations of pruning and quantization and focused solely on the accuracy of both methods at the same ideal compression rates. However, in practice, the hardware considerations do matter for the usability of the methods.

The analysis above assumed an idealistic case for pruning in terms of memory size and data transfer. Since the pruning is unstructured, in order to achieve memory savings in practice, one would need at least 1 bit of information for each weight indicating whether a weight is pruned or not. On top of 16-bit weights, this gives a 6.25% storage overhead at a minimum. Quantization does not have this overhead, as INT8 is just 8 bits smaller than 16 bits, and the only storage overhead is a single scaling factor per tensor (or channel).

Also, in terms of the cost of computations done by the hardware, there is a difference between the two methods. For pruning, any hardware would have to take the densely stored weights and mask and either decompress them to the dense format with all weights and many 0s or take the pruning into account in the compute itself. No compute benefits are gained in the former, as the dense calculations are done in the uncompressed number format. In the latter, dedicated hardware to take into account the 0s is necessary. The overhead for this is generally non-trivial, leading vendors to implement more semi-structured pruning schemes [47]. Similarly, it is rare to see unstructured activation compression for the same reason that this needs to happen algorithmically on-the-fly. In contrast, quantization gives quadratic improvements in the compute. Going from INT8 to INT4 theoretically improves the compute performance by a factor 4, although practical gains depend on the memory overhead (which improves by only a factor 2x) and the existence of other formats in the same hardware compute unit.

Impact Using pruning or quantization leads to power reduction on many architectures and enables new applications on mobile platforms. We see only a positive impact from this on the whole. In some cases both pruning and quantization might lead to biased predictions, a further discussion can be found in [29].

Limitations First, our work has not extensively considered the hardware implications of pruning or quantization. Second, we do not study combinations of pruning and quantization apart from analyzing the inherent sparsity due to pruning. We leave this for future work. Finally, we consider only uniform quantization and ignore the other formats, such as low-precision floating or logarithmic quantization, although these are not likely to change the results presented in this paper.

7 Related work

Quantization Integer quantization, or fixed-point quantization, is one of the most widely used techniques for inference, allowing to reduce the latency and improved energy efficiency. There are two main families of methods for model quantization. The first family includes post-training quantization (PTQ) methods [42, 52, 10, 1, 9, 6, 48, 40], which improve the model accuracy based on per-layer optimization of the quantized weights in a data-optimized fashion. The second family includes quantization-aware training methods [22, 34, 69, 8, 44, 12, 35, 2, 63, 51] which usually fine-tune

the model with quantization in the loop using straight-through estimator (STE) for computing the gradient of rounding operations. A more comprehensive overview of quantization methods can be found in [50].

Pruning Neural network pruning is one of the oldest methods to compress neural networks [37, 26]. A central problem in pruning is how to choose which weights to prune. Approaches published in the literature include: binary gating, in which a binary gate is learned on each individual weight [45, 46, 64]; sensitivity-based methods [39, 38, 66, 17, 18] in which sensitivity, based on a weights' gradient or hessian diagonal value, is used, and magnitude pruning [24, 54, 70, 47, 59]. While conceptually simple, magnitude-based methods have been shown to consistently outperform more intricate methods at scale [19, 4]. Weight re-initialization schemes [15, 16] or mask-reinitialization [59] yield additional minor improvements. While most pruning approaches require fine-tuning and yield unsatisfactory results in post-training scenarios, recent adaptations of Hessian-based sensitivity approaches [37, 26], in which the Hessian of a layerwise reconstruction loss is used instead of the task loss Hessian, show good pruning results in post-training pruning of large language models [17, 18].

Combining pruning and quantization A number of works study combinations of pruning and quantization with different levels of granularity [24, 64, 31, 65, 62, 65].

Comparing pruning and quantization Despite the large amount of work on pruning, quantization, and combining them, there is little literature comparing the two methods. To the best of our knowledge, the closest work that performs a comparison of pruning versus non-uniform quantization [33]. The work considers only small-scale models and provides only an empirical comparison with no further analysis. Another related study is [53].

8 Conclusion

We have seen in this paper that in several settings, unstructured pruning only performs better than quantization in rare cases. In our theoretical analysis of distributions and on the real-layer-data, pruning is only better than quantization, compressing the network to an equivalent of 2 or 3 bits. This amount of compression comes with such a degree of a drop in performance it is rarely used in practice. The post-training quantization results are also informative. In the setting without fine-tuning, we have shown with theoretical bounds on many layers in neural networks that quantization is almost always provably better than pruning. Our hypothesis is that quantized layers are more accurate than pruned ones, as shown in the theoretical and PTQ setting, and fine-tuning a network is still highly dependent on that. This is in line with fine-tuning results, in which for many networks trained under the same conditions, quantization always has higher performance than pruning.

The conclusion is clear: Quantization generally outperforms pruning for neural networks. Taking into account the unfavorable hardware implications for pruning described, it could be argued that the conclusion holds even stronger. Based on this research, we recommend quantizing neural networks when efficiency is required before pruning is explored.

References

Ron Banner, Yury Nahshan, and Daniel Soudry. Post training 4-bit quantization of convolutional networks for rapid-deployment. In Advances in Neural Information Processing Systems , 2019.

Yash Bhalgat, Jinwon Lee, Markus Nagel, Tijmen Blankevoort, and Nojun Kwak. Lsq+: Improving low-bit quantization through learnable offsets and better initialization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) Workshops , 2020.

BigScience Workshop. BLOOM (revision 4ab0472), 2022.

Davis Blalock, Jose Javier Gonzalez Ortiz, Jonathan Frankle, and John Guttag. What is the state of neural network pruning? Proceedings of machine learning and systems , 2:129-146, 2020.

Christoph Buchheim, Ruth Huebner, and Anita Schoebel. Ellipsoid bounds for convex quadratic integer programming. SIAM Journal on Optimization , 25(2):741-769, 2015.

Yaohui Cai, Zhewei Yao, Zhen Dong, Amir Gholami, Michael W. Mahoney, and Kurt Keutzer. Zeroq: A novel zero shot quantization framework. arXiv preprint arXiv:2001.00281 , 2020.

Liang-Chieh Chen, George Papandreou, Florian Schroff, and Hartwig Adam. Rethinking atrous convolution for semantic image segmentation, 2017.

Jungwook Choi, Zhuo Wang, Swagath Venkataramani, Pierce I-Jen Chuang, Vijayalakshmi Srinivasan, and Kailash Gopalakrishnan. PACT: parameterized clipping activation for quantized neural networks. arXiv preprint arxiv:805.06085 , 2018.

Yoni Choukroun, Eli Kravchik, and Pavel Kisilev. Low-bit quantization of neural networks for efficient inference. International Conference on Computer Vision (ICCV) , 2019.

Zhen Dong, Zhewei Yao, Amir Gholami, Michael W Mahoney, and Kurt Keutzer. Hawq: Hessian aware quantization of neural networks with mixed-precision. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 293-302, 2019.

Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale, 2020.

Steven K. Esser, Jeffrey L. McKinstry, Deepika Bablani, Rathinakumar Appuswamy, and Dharmendra S. Modha. Learned step size quantization. In International Conference on Learning Representations (ICLR) , 2020.

M. Everingham, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The pascal visual object classes (voc) challenge. International Journal of Computer Vision , 88(2):303-338, June 2010.

Simon Foucart and Holger Rauhut. A Mathematical Introduction to Compressive Sensing . Applied and Numerical Harmonic Analysis. Springer New York, New York, NY, 2013.

Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635 , 2018.

Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M Roy, and Michael Carbin. Stabilizing the lottery ticket hypothesis. arXiv preprint arXiv:1903.01611 , 2019.

Elias Frantar and Dan Alistarh. Optimal brain compression: A framework for accurate posttraining quantization and pruning. arXiv preprint arXiv:2208.11580 , 2022.

Elias Frantar and Dan Alistarh. Sparsegpt: Massive language models can be accurately pruned in one-shot, 2023.

Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574 , 2019.

Xinyang Geng and Hao Liu. Openllama: An open reproduction of llama, May 2023.

Michael Grant and Stephen Boyd. CVX: Matlab software for disciplined convex programming, version 2.1. http://cvxr.com/cvx , March 2014.

Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In International Conference on Machine Learning, (ICML) , 2015.

Gurobi Optimization, LLC. Gurobi Optimizer Reference Manual, 2023.

Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149 , 2015.

Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. Advances in neural information processing systems , 28, 2015.

Babak Hassibi, David G Stork, and Gregory J Wolff. Optimal brain surgeon and general network pruning. In IEEE international conference on neural networks , pages 293-299. IEEE, 1993.

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition , 2016.

Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE international conference on computer vision , pages 1389-1397, 2017.

Sara Hooker, Nyalleng Moorosi, Gregory Clark, Samy Bengio, and Emily Denton. Characterising bias in compressed models. arXiv preprint arXiv:2010.03058 , 2020.

Andrew Howard, Ruoming Pang, Hartwig Adam, Quoc Le, Mark Sandler, Bo Chen, Weijun Wang, Liang-Chieh Chen, Mingxing Tan, Grace Chu, Vijay Vasudevan, and Yukun Zhu. Searching for mobilenetv3. In International Conference on Computer Vision (ICCV) , 2019.

Peng Hu, Xi Peng, Hongyuan Zhu, Mohamed M Sabry Aly, and Jie Lin. Opq: Compressing deep neural networks with one-shot pruning-quantization. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 35, pages 7780-7788, 2021.

Itay Hubara, Yury Nahshan, Yair Hanani, Ron Banner, and Daniel Soudry. Accurate post training quantization with small calibration sets. In International Conference on Machine Learning , pages 4466-4475. PMLR, 2021.

Yerlan Idelbayev and Miguel Á Carreira-Perpiñán. An empirical comparison of quantization, pruning and low-rank neural network compression using the lc toolkit. In 2021 International Joint Conference on Neural Networks (IJCNN) , pages 1-8. IEEE, 2021.

Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. Conference on Computer Vision and Pattern Recognition (CVPR) , 2018.

Sambhav R. Jain, Albert Gural, Michael Wu, and Chris Dick. Trained uniform quantization for accurate and efficient neural network inference on fixed-point hardware. arxiv preprint arxiv:1903.08066 , 2019.

Andrey Kuzmin, Mart Van Baalen, Yuwei Ren, Markus Nagel, Jorn Peters, and Tijmen Blankevoort. Fp8 quantization: The power of the exponent. arXiv preprint arXiv:2208.09225 , 2022.

Yann LeCun, John Denker, and Sara Solla. Optimal brain damage. Advances in neural information processing systems , 2, 1989.

Namhoon Lee, Thalaiyasingam Ajanthan, Stephen Gould, and Philip HS Torr. A signal propagation perspective for pruning neural networks at initialization. arXiv preprint arXiv:1906.06307 , 2019.

Namhoon Lee, Thalaiyasingam Ajanthan, and Philip HS Torr. Snip: Single-shot network pruning based on connection sensitivity. arXiv preprint arXiv:1810.02340 , 2018.

Yuhang Li, Ruihao Gong, Xu Tan, Yang Yang, Peng Hu, Qi Zhang, Fengwei Yu, Wei Wang, and Shi Gu. Brecq: Pushing the limit of post-training quantization by block reconstruction. In International Conference on Learning Representations (ICLR) , 2021.

Darryl Lin, Sachin Talathi, and Sreekanth Annapureddy. Fixed point quantization of deep convolutional networks. In International conference on machine learning , pages 2849-2858. PMLR, 2016.

Darryl D. Lin, Sachin S. Talathi, and V. Sreekanth Annapureddy. Fixed point quantization of deep convolutional networks. In International Conference on Machine Learning , 2016.

Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft coco: Common objects in context. In David Fleet, Tomas Pajdla, Bernt Schiele, and Tinne Tuytelaars, editors, Computer Vision - ECCV 2014 , pages 740-755, Cham, 2014. Springer International Publishing.

Christos Louizos, Matthias Reisser, Tijmen Blankevoort, Efstratios Gavves, and Max Welling. Relaxed quantization for discretized neural networks. In International Conference on Learning Representations (ICLR) , 2019.

Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l _ 0 regularization. arXiv preprint arXiv:1712.01312 , 2017.

Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l 0 regularization. International Conference on Learning Representations (ICLR) , 2018.

Asit Mishra, Jorge Albericio Latorre, Jeff Pool, Darko Stosic, Dusan Stosic, Ganesh Venkatesh, Chong Yu, and Paulius Micikevicius. Accelerating sparse deep neural networks. arXiv preprint arXiv:2104.08378 , 2022.

Markus Nagel, Rana Ali Amjad, Mart Van Baalen, Christos Louizos, and Tijmen Blankevoort. Up or down? Adaptive rounding for post-training quantization. In International Conference on Machine Learning (ICML) , 2020.

Markus Nagel, Marios Fournarakis, Rana Ali Amjad, Yelysei Bondarenko, Mart van Baalen, and Tijmen Blankevoort. A white paper on neural network quantization. ArXiv , abs/2106.08295, 2021.

Markus Nagel, Marios Fournarakis, Rana Ali Amjad, Yelysei Bondarenko, Mart van Baalen, and Tijmen Blankevoort. A white paper on neural network quantization. ArXiv , abs/2106.08295, 2021.

Markus Nagel, Marios Fournarakis, Yelysei Bondarenko, and Tijmen Blankevoort. Overcoming oscillations in quantization-aware training. In International Conference on Machine Learning , pages 16318-16330. PMLR, 2022.

Markus Nagel, Mart van Baalen, Tijmen Blankevoort, and Max Welling. Data-free quantization through weight equalization and bias correction. In International Conference on Computer Vision (ICCV) , 2019.

Satya Sai Srinath Namburi, Makesh Sreedhar, Srinath Srinivasan, and Frederic Sala. The cost of compression: Investigating the impact of compression on parametric knowledge in language models. In Findings of the Association for Computational Linguistics: EMNLP 2023 , pages 5255-5273, 2023.

Sharan Narang, Erich Elsen, Gregory Diamos, and Shubho Sengupta. Exploring sparsity in recurrent neural networks. arXiv preprint arXiv:1704.05119 , 2017.

Jaehyun Park and Stephen Boyd. A semidefinite programming method for integer convex quadratic minimization. Optimization Letters , 12:499-518, 2018.

Alberto Del Pia, Santanu S Dey, and Marco Molinaro. Mixed-integer quadratic programming is in np. Mathematical Programming , 162:225-240, 2017.

Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV) , 2015.

Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Conference on Computer Vision and Pattern Recognition (CVPR) , 2018.

Suraj Srinivas, Andrey Kuzmin, Markus Nagel, Mart van Baalen, Andrii Skliar, and Tijmen Blankevoort. Cyclical pruning for sparse neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 2762-2771, 2022.

Mingxing Tan and Quoc Le. EfficientNet: Rethinking model scaling for convolutional neural networks. In International Conference on Machine Learning (ICML) , 2019.

Mingxing Tan, Ruoming Pang, and Quoc V. Le. Efficientdet: Scalable and efficient object detection, 2020.

Frederick Tung and Greg Mori. Deep neural network compression by in-parallel pruningquantization. IEEE transactions on pattern analysis and machine intelligence , 42(3):568-579, 2018.

Stefan Uhlich, Lukas Mauch, Fabien Cardinaux, Kazuki Yoshiyama, Javier Alonso Garcia, Stephen Tiedemann, Thomas Kemp, and Akira Nakamura. Mixed precision dnns: All you need is a good parametrization. In International Conference on Learning Representations (ICLR) , 2020.

Mart van Baalen, Christos Louizos, Markus Nagel, Rana Ali Amjad, Ying Wang, Tijmen Blankevoort, and Max Welling. Bayesian bits: Unifying quantization and pruning. arXiv preprint arXiv:2005.07093 , 2020.

Haichuan Yang, Shupeng Gui, Yuhao Zhu, and Ji Liu. Automatic neural network compression by sparsity-quantization joint learning: A constrained optimization-based approach. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 2178-2188, 2020.

Ruichi Yu, Ang Li, Chun-Fu Chen, Jui-Hsin Lai, Vlad I Morariu, Xintong Han, Mingfei Gao, Ching-Yung Lin, and Larry S Davis. Nisp: Pruning networks using neuron importance score propagation. In Proceedings of the IEEE conference on computer vision and pattern recognition , pages 9194-9203, 2018.

Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li, Xi Victoria Lin, et al. Opt: Open pre-trained transformer language models. arXiv preprint arXiv:2205.01068 , 2022.

Xiangyu Zhang, Jianhua Zou, Kaiming He, and Jian Sun. Accelerating very deep convolutional networks for classification and detection. IEEE transactions on pattern analysis and machine intelligence , 38(10):1943-1955, 2015.

Shuchang Zhou, Zekun Ni, Xinyu Zhou, He Wen, Yuxin Wu, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160 , 2016.

Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878 , 2017.

Peer reviews:
comments: SUMMARY:
This submission conducts a series empiricial experiments and anlysis between neural network pruning and quantization. It first used some statistics method to compare pruning/quantization. Then it measure the per-layer error based on a post-training compression framework. Finally, it conducted some experiments using LSQ for quantization and iterative magnitude-based iterative pruning.

STRENGTHS:
Statistics method for compression comparison as a non-parameteric and non-trainable method is interesting.

WEAKNESSES:
1. The main drawback of the submission is that it barely proposed new algorithm or insight. The submission is a collection of empiricial experiments and analysis.
2. Comprehensive empiricial experiments can be regarded as contribution. However, the compression methods used in the submission is limited and the experimental setting is not solid. The submission basically focused on magnitude-based pruning and uniform quantization. Author may refer to [1] for some examples.

[1] https://arxiv.org/pdf/1810.05270.pdf

QUESTIONS:
N.A.

LIMITATIONS:
N.A.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2023-07-06

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors compare the performance of post-training quantization and pruning methods with the same compression ratio using a signal-to-noise metric, a kurtosis metric, and, ultimately, model accuracy. They study the expected performance analytically and in simple toy problems, i.e., Gaussian- and Student's t-distributed weights. They also run experiments on real pre-trained models from the PyTorch Model Zoo. They conclude that post-training quantization alone generally outperforms post-training pruning alone based on their per-layer weight fidelity metrics and full-model accuracy.\n\nSTRENGTHS:\n- The paper represents a complete analysis of post-training pruning alone vs. post-training quantization alone when targeting the same compression ratio.\n- The authors analyze the problem at multiple levels (more theoretical/analytical and more empirical/experiment driven) and find the two viewpoints complement and support each other.\n- The toy model analysis, though straightforward, illuminates the general issues at play for pruning vs. quantization.\n\nWEAKNESSES:\n- The SNR appears to be well-motivated, but it would be ideal to demonstrate explicitly that it maps to model accuracy, e.g. by adding a subfigure with accuracy to Fig. 3 and/or adding the SNR metric to Table 1.\n- The authors note that the quantized models naturally exhibit a larger compression ratio than the pruned models because they have a larger fraction of real 0s, which is a minor caveat.\n- Some additional references could be added to the related work, e.g., \n  - combining pruning and quantization: https://arxiv.org/abs/2102.11289, \n  - quantization-aware training: https://arxiv.org/abs/2006.10159, https://arxiv.org/abs/1905.03696\n- In the Impacts section, there is no discussion of the potential decrease in model robustness and generalization when pruning or quantization.\n\nQUESTIONS:\n- Why does the SNR metric use weights and not activations?\n- How does the layer-wise SNR metric you evaluate look for the real models in Table 1? Does it match the conclusions based on accuracy?\n- Can you indicate how computationally costly the pruning/quantization methods you employ are?\n\nLIMITATIONS:\nThe authors discuss the limitations that they do not consider combinations of pruning and quantization, hardware considerations, and other quantization or pruning schemes.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-07"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper sets out to answer the question whether quantization or pruning is better. It first provides an analytical analysis of the two methods in terms of signal-to-noise ratio (SNR) and establishes an early relationship between kurtosis and SNR. It then provides a mathematical breakdown of the compression error in both methods. Then, it empirically compares the two methods on 46 models from the PyTorch model zoo to validate the early analytical results. The authors then compress and fine-tune a set of vision models to compare the two methods after fine-tuning and show that quantization still outperforms in this region. Finally it explores the hardware considerations since dense pruned models can be difficult to accelerate on most hardware.\n\nSTRENGTHS:\nThe authors use the reasonable FP16 baseline instead of the more common FP32.\n\nThis paper makes an interesting connection between kurtosis and the relative performance of quantization over pruning.\n\nObservation that pruning tends to recover the original representation but quantization builds new ones is intriguing.\n\nThe empirical evaluation spans across image classification and detection tasks.\n\nWEAKNESSES:\nEspecially when considering the hardware, it would be useful to consider block sparsity like 2:4, which is supported in some modern GPUs. However, element-wise sparsity presumably has strictly better accuracy / memory performance, so block sparsity would likely be worse.\n\nGiven the recent success of transformers, it may be helpful to include more (in addition to ViT) in the empirical evaluation. That said, I do not expect this will change the conclusion.\n\nYou correctly point out that weight distributions are typically quantized symmetrically but they also typically use channel-wise quantization, which is especially helpful with low bitwidths. I expect channel-wise quantization could further shrink the region where pruning is preferred.\n\nI am slightly concerned about the novelty of this comparison, but I will do a better literature search later in the review process. One other potential critique may be that this conclusion may not be too surprising given the exponential decay in the importance of bits. This decay likely does not hold for individual weights.\n\nMinor: L87 is a little confusing for the definition of T, which is more the error of the magnitude pruning, as opposed to the magnitude pruning itself.\n\nQUESTIONS:\nDid you consider clipping to make the distribution less sensitive to outliers? This seems standard with weight quantization too since weights are easy to profile and optimize the quantization settings.\n\nFigure 1 (right) is computed with the analytical equations with the normal distribution substituted? \n\nAre there any regions when the combination of the two techniques outperforms the techniques individually?\n\nI'm confused about Appendix H, where the conclusion is that quantization tends to relearn different representations but pruning recovers the previous ones. The figure shows that the distance between the original and new activations is larger for pruning, which should imply that it doesn't relearn the original distributions.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-07"}

comments: SUMMARY:
In this paper, the authors try to answer whether pruning or quantization is better for network compression. The paper start by analyze the qunatization error and pruning error under standard normal distribution and heavy-tail distributions. Full-model comparison are done between quantization and pruning with a set of 8 models. In most cases, the quantization method performs better than pruning. Quantization is much better than pruning under extreme compression targets.

STRENGTHS:
1. The paper is well-written. The whole writing is to the point. The content is well organized, which makes the paper easy to understand.
2. Thorough full-model comparison is done for a set of 8 models.

WEAKNESSES:
1. The standing point of this paper might be biased. Quantization and pruning are not two competitive methods. Each of them have a specific application scenario. They could be used sololy and jointly. According to the experiments, quantization is almost always better than pruning. Yet, this does not mean that pruning is not useful.
2. The comparison is done such that the model size after pruning and quantization are the same. Not sure whether this comparison is proper.
3. Even without the investigation in this paper, quantization is still used more often than pruning.

QUESTIONS:
1. Quantization and pruning are two different network compression techniques. But this paper tries to compare them under the setting of same model size. Nevertheless, model size is not the most important factor for efficient applications.

LIMITATIONS:
The novelty of this paper is quite limited. It is more like an empirical study.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2023-07-09