Original: A DDITIVE P OWERS - OF -T WO Q UANTIZATION : A N E FFICIENT N ON - UNIFORM D ISCRETIZATION FOR N EURAL N ETWORKS
Revised: A DDITIVE P OWERS - OF -T WO Q UANTIZATION : A N E FFICIENT N ON - UNIFORM D ISCRETIZATION FOR N EURAL N ETWORKS

Original: A BSTRACT
Revised: A BSTRACT

Original: We propose A dditive P owers- o f- T wo (APoT) quantization, an efﬁcient nonuniform quantization scheme that attends to the bell-shaped and long-tailed distribution of weights and activations in neural networks.
Revised: We propose A dditive P owers- o f- T wo (APoT) quantization, an efﬁcient nonuniform quantization scheme for the bell-shaped and long-tailed distribution of weights and activations in neural networks.

Original: By constraining all quantization levels as a sum of several Powers-of-Two terms, APoT quantization enjoys the overwhelming efﬁciencyof computation and a good match with weights’ distribution.
Revised: By constraining all quantization levels as a sum of several Powers-of-Two terms, APoT quantization enjoys high computational efﬁciency and a good match with weights’ distribution.

Original: A simple reparameterization on the clipping function is applied to generate a better-deﬁned gradient for updating of optimal clipping threshold.
Revised: A simple reparameterization on the clipping function is applied to generate a better-deﬁned gradient for learning the clipping threshold.

Original: Moreover, weight normalization is presented to reﬁne the input distribution of weights to be more stable and consistent.
Revised: Moreover, weight normalization is presented to reﬁne the input distribution of weights to be more stable and consistent.

Original: Experimental results show that our proposed method outperforms state-of-the-art methods, and is even competitive with the full-precision models demonstrating the effectiveness of our proposed APoT quantization.
Revised: Experimental results show that our proposed method outperforms state-of-the-art methods, and is even competitive with the full-precision models demonstrating the effectiveness of our proposed APoT quantization.

Original: For example, our 4-bit quantized ResNet-50 on ImageNet achieves 76.8% top-1 accuracy without bells and whistles, meanwhile, our model is capable to decrease 22%ﬁxed point computation overhead in uniformly quantized counterpart.Code is available at https://github.com/yhhhli/APoT_ Quantization .
Revised: For example, our 4-bit quantized ResNet-50 on ImageNet achieves 76.6% top-1 accuracy without bells and whistles, meanwhile, our model is capable to decrease 22% computation overhead in uniformly quantized counterpart.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Deep Neural Networks (DNNs) have made a signiﬁcant improvement for various real-world applications.
Revised: Deep Neural Networks (DNNs) have made a signiﬁcant improvement for various real-world applications.

Original: However, the huge memory and computational cost impede the mass deployment of DNNs, e.g., on resource-constrained devices.
Revised: However, the huge memory and computational cost impede the mass deployment of DNNs, e.g., on resource-constrained devices.

Original: Tothe reduce memory footprint and computational burden, several model compression methods such as quantization (Zhou et al., 2016), pruning (Han et al., 2015) and low-rank decomposition (Denil et al., 2013) have been widely explored.
Revised: To reduce memory footprint and computational burden, several model compression methods such as quantization (Zhou et al., 2016), pruning (Han et al., 2015) and low-rank decomposition (Denil et al., 2013) have been widely explored.

Original: In this paper, we focus on the neural network quantization for efﬁcient inference.
Revised: In this paper, we focus on the neural network quantization for efﬁcient inference.

Original: Two operations are involved in the quantization process, namely clipping and projection.
Revised: Two operations are involved in the quantization process, namely clipping and projection.

Original: The clipping operation sets a full precision number to the range boundary if it is outside of the range; the projection operation maps each number (after clipping) into a predeﬁned quantization level (a ﬁxed number).
Revised: The clipping operation sets a full precision number to the range boundary if it is outside of the range; the projection operation maps each number (after clipping) into a predeﬁned quantization level (a ﬁxed number).

Original: We can see that both operations incur information loss.
Revised: We can see that both operations incur information loss.

Original: A good quantization method should resolve the two following questions/challenges, which correspond to two contradictions respectively.
Revised: A good quantization method should resolve the two following questions/challenges, which correspond to two contradictions respectively.

Original: How to determine the optimal clipping threshold to balance clipping range and projection resolution?
Revised: How to determine the optimal clipping threshold to balance clipping range and projection resolution?

Original: The resolution indicates the interval between two quantization levels; the smaller the interval, the higher the resolution.
Revised: The resolution indicates the interval between two quantization levels; the smaller the interval, the higher the resolution.

Original: The ﬁrst contradiction is that given a ﬁxed number of bits to represent weights, the range and resolution are inversely proportional.
Revised: The ﬁrst contradiction is that given a ﬁxed number of bits to represent weights, the range and resolution are inversely proportional.

Original: For example, a larger range can clip fewer weights; however, the resolution becomes smaller and thus damage the projection.
Revised: For example, a larger range can clip fewer weights; however, the resolution becomes lower and thus damage the projection.

Original: Note that slipshod clipping of outliers can jeopardize the network a lot (Zhao et al., 2019) although they may only take 1-2% of all weights in one layer.
Revised: Note that slipshod clipping of outliers can jeopardize the network a lot (Zhao et al., 2019) although they may only take 1-2% of all weights in one layer.

Original: Previous works have tried either pre-deﬁned (Cai et al., 2017;
Revised: Previous works have tried either pre-deﬁned (Cai et al., 2017;

Original: Zhou et al., 2016) or trainable (Choi et al., 2018b) clipping thresholds, but how to ﬁnd the optimal threshold during training automatically is still not resolved.
Revised: Zhou et al., 2016) or trainable (Choi et al., 2018b) clipping thresholds, but how to ﬁnd the optimal threshold during training automatically is still not resolved.

Original: How to design quantization levels with consideration for both the computational efﬁciency and the distribution of weights?
Revised: How to design quantization levels with consideration for both the computational efﬁciency and the distribution of weights?

Original: Most of the existing quantization approaches (Cai et al., 2017; Gong et al., 2019), use uniform quantization although non-uniform quantization can usually achieve better
Revised: Most of the existing quantization approaches (Cai et al., 2017; Gong et al., 2019) use uniform quantization although non-uniform quantization can usually achieve better

Original: [Figure]
Revised: [Figure]

Original: accuracy (Zhu et al., 2016).
Revised: accuracy (Zhu et al., 2016).

Original: The reason is that projection against uniform quantization levels are much more hardware-friendly (Zhou et al., 2016).
Revised: The reason is that projection against uniform quantization levels are much more hardware-friendly (Zhou et al., 2016).

Original: However, empirical study (Han et al., 2015) has shown that weights in a layer of DNN follow a bell-shaped and long-tailed distribution instead of a uniform distribution (as shown in the right ﬁgure).
Revised: However, empirical study (Han et al., 2015) has shown that weights in a layer of DNN follow a bell-shaped and long-tailed distribution instead of a uniform distribution (as shown in the right ﬁgure).

Original: In other words, a fair percentage of weights concentrate around the mean (peak area); and a few weights are of relatively high magnitude and out of the quantization range (called outliers).
Revised: In other words, a fair percentage of weights concentrate around the mean (peak area); and a few weights are of relatively high magnitude and out of the quantization range (called outliers).

Original: Such distribution also exists in activations (Miyashita et al., 2016).
Revised: Such distribution also exists in activations (Miyashita et al., 2016).

Original: The second contradiction is: considering the bell-shaped distribution of weight, it is well-motivated to assign higher resolution (i.e. smaller quantization interval) around the mean; however, such non-uniform quantization levels will introduce high computational overhead.
Revised: The second contradiction is: considering the bell-shaped distribution of weight, it is well-motivated to assign higher resolution (i.e. smaller quantization interval) around the mean; however, such non-uniform quantization levels will introduce high computational overhead.

Original: Powers-of-Two quantization levels (Miyashita et al., 2016;
Revised: Powers-of-Two quantization levels (Miyashita et al., 2016;

Original: Zhou et al., 2017) are then proposed because of its cheap multiplication implemented by shift operations on hardware, and super high resolution around the mean.
Revised: Zhou et al., 2017) are then proposed because of its cheap multiplication implemented by shift operations on hardware, and super high resolution around the mean.

Original: However, the vanilla powers-of-two quantization method only increases the resolution near the mean and ignores other regions at all when the bit-width is increased.
Revised: However, the vanilla powers-of-two quantization method only increases the resolution near the mean and ignores other regions at all when the bit-width is increased.

Original: Consequently, it assigns inordinate quantization levels for a tiny range around the mean.
Revised: Consequently, it assigns inordinate quantization levels for a tiny range around the mean.

Original: To this end, we propose additive Powers-of-Two (APoT) quantization to resolve these two contradictions, our contribution can be listed as follows:
Revised: To this end, we propose additive Powers-of-Two (APoT) quantization to resolve these two contradictions, our contribution can be listed as follows:

Original: We introduce the APoT quantization scheme for the weights and activations of DNNs.
Revised: We introduce the APoT quantization scheme for the weights and activations of DNNs.

Original: APoT is a non-uniform quantization scheme, in which the quantization levels is a sum of several PoT terms and can adapt well to the bell-shaped distribution of weights.
Revised: APoT is a non-uniform quantization scheme, in which the quantization levels is a sum of several PoT terms and can adapt well to the bell-shaped distribution of weights.

Original: APoT quantization enjoys an approximate 2 × multiplication speed-up compared with uniform quantization on both generic and speciﬁc hardware.
Revised: APoT quantization enjoys an approximate 2 × multiplication speed-up compared with uniform quantization on both generic and speciﬁc hardware.

Original: We propose a Reparameterized Clipping Function (RCF) that can compute a more accurate gradient for the clipping threshold and thus facilitate the optimization of the clipping threshold.
Revised: We propose a Reparameterized Clipping Function (RCF) that can compute a more accurate gradient for the clipping threshold and thus facilitate the optimization of the clipping threshold.

Original: We also introduce weight normalization for neural network quantization.
Revised: We also introduce weight normalization for neural network quantization.

Original: Normalized weights in the forward pass are more stable and consistent for clipping and projection.
Revised: Normalized weights in the forward pass are more stable and consistent for clipping and projection.

Original: Experimental results show that our proposed method outperforms state-of-the-art methods, and is even competitive with the full-precision implementation with higher computational efﬁciency.
Revised: Experimental results show that our proposed method outperforms state-of-the-art methods, and is even competitive with the full-precision implementation with higher computational efﬁciency.

Original: Speciﬁcally, our 4-bit quantized ResNet-50 on ImageNet achieve 76.8% Topand 93.3% Top-5 accuracy.
Revised: Speciﬁcally, our 4-bit quantized ResNet-50 on ImageNet achieve 76.6% Topand 93.1% Top-5 accuracy.

Original: Compared with uniform quantization, our method canfurther decrease 22% computation, demonstrating the proposed algorithm is hardware-friendly.
Revised: Compared with uniform quantization, our method can decrease 22% computational cost, demonstrating the proposed algorithm is hardware-friendly.

Original:  M ETHODOLOGY 2. P RELIMINARIES
Revised:  M ETHODOLOGY 2. P RELIMINARIES

Original: Suppose kernels in a convolutional layer are represented by a 4D tensor W ∈ R C out × C in × K × K , where C out and C in are the number of output and input channels respectively, and K is the kernel size.
Revised: Suppose kernels in a convolutional layer are represented by a 4D tensor W ∈ R C out × C in × K × K , where C out and C in are the number of output and input channels respectively, and K is the kernel size.

Original: We denote the quantization of the weights as
Revised: We denote the quantization of the weights as

Original: [Equation]
Revised: [Equation]

Original: where α is  clipping threshold and the clipping function (cid:98)· , α (cid:101) clips weights into [ − α, α ] .
Revised: where α is the clipping threshold and the clipping function (cid:98)· , α (cid:101) clips weights into [ − α, α ] .

Original: After clipping, each element of W is projected by Π( · ) onto the quantization levels.
Revised: After clipping, each element of W is projected by Π( · ) onto the quantization levels.

Original: We denote Q ( α, b ) for a set of quantization levels, where b is the bit-width.
Revised: We denote Q ( α, b ) for a set of quantization levels, where b is the bit-width.

Original: For uniform quantization, the quantization levels are deﬁned as
Revised: For uniform quantization, the quantization levels are deﬁned as

Original: [Equation]
Revised: [Equation]

Original: For every ﬂoating-point number, uniform quantization maps it to a b -bit ﬁxed-point representation (quantization levels) in Q u ( α, b ) .
Revised: For every ﬂoating-point number, uniform quantization maps it to a b -bit ﬁxed-point representation (quantization levels) in Q u ( α, b ) .

Original: Note that α is stored separately as a full-precision ﬂoating-point
Revised: Note that α is stored separately as a full-precision ﬂoating-point

Original: [Figure]
Revised: [Figure]

Original: number for each whole W .
Revised: number for each whole W .

Original: Convolution is done against the quantization levels ﬁrst and the results are then multiplied by α .
Revised: Convolution is done against the quantization levels ﬁrst and the results are then multiplied by α .

Original: Arithmetical computation, e.g., convolution, can be implemented using low-precision ﬁxed point operations on hardware, which are substantially cheaper than their ﬂoating-point contradictory (Goldberg, 1991).
Revised: Arithmetical computation, e.g., convolution, can be implemented using low-precision ﬁxed point operations on hardware, which are substantially cheaper than their ﬂoating-point contradictory (Goldberg, 1991).

Original: Nevertheless, uniform quantization does not match the distribution of weights (and activations), which is typically bell-shaped (Han et al., 2015).
Revised: Nevertheless, uniform quantization does not match the distribution of weights (and activations), which is typically bell-shaped (Han et al., 2015).

Original: A straightforward solution is to assign more quantization levels (higher resolution) for the peak of the distribution and fewer levels (lower resolution) for the tails.
Revised: A straightforward solution is to assign more quantization levels (higher resolution) for the peak of the distribution and fewer levels (lower resolution) for the tails.

Original: However, it is difﬁcult to implement the arithmetical operations for the non-uniform quantization levels efﬁciently.
Revised: However, it is difﬁcult to implement the arithmetical operations for the non-uniform quantization levels efﬁciently.

Original: 2. A DDITIVE P OWERS - OF -T WO Q UANTIZATION
Revised: 2. A DDITIVE P OWERS - OF -T WO Q UANTIZATION

Original: To solve the contradiction between non-uniform resolution and hardware efﬁciency, Powers-ofTwo (PoT) quantization (Miyashita et al., 2016; Zhou et al., 2017) is proposed by constraining quantization levels to be powers-of-two values or zero, i.e.,
Revised: To solve the contradiction between non-uniform resolution and hardware efﬁciency, Powers-ofTwo (PoT) quantization (Miyashita et al., 2016; Zhou et al., 2017) is proposed by constraining quantization levels to be powers-of-two values or zero, i.e.,

Original: [Equation]
Revised: [Equation]

Original: Apparently, as a non-uniform quantizer, PoT has a higher resolution for the value range with denser weights because of its exponential property.
Revised: Apparently, as a non-uniform quantizer, PoT has a higher resolution for the value range with denser weights because of its exponential property.

Original: Furthermore, multiplication between a Powers-of-two number 2 x and the other operand r can be implemented by bit-wise shift instead of bulky digital multipliers, i.e.,
Revised: Furthermore, multiplication between a Powers-of-two number 2 x and the other operand r can be implemented by bit-wise shift instead of bulky digital multipliers, i.e.,

Original: [Equation]
Revised: [Equation]

Original: where >> denotes the right shift operation and is computationally cheap, which only takes 1 clock cycle in modern CPU architectures.
Revised: where >> denotes the right shift operation and is computationally cheap, which only takes 1 clock cycle in modern CPU architectures.

Original: However, we ﬁnd thatin PoT quantization does not beneﬁt from more bits.
Revised: However, we ﬁnd that PoT quantization does not beneﬁt from more bits.

Original: Assume α is 1, as shown in Equation (3), when we increase the bit-width from b to b + 1 , the interval [0 ,± 2 − 2 b − 1 +1 ] will be split into 2 b − 1 − 1 sub-intervals, whereas all other intervals remain unchanged.
Revised: Assume α is 1, as shown in Equation (3), when we increase the bit-width from b to b + 1 , the interval [ − 2 − 2 b − 1 +1 , 2 − 2 b − 1 +1 ] will be split into 2 b − 1 − 1 sub-intervals, whereas all other intervals remain unchanged.

Original: In other words, by increasing the bit-width, the resolution will increase only for [ − 2 − 2 b − 1 +1 , 2 − 2 b − 1 +1 ] .
Revised: In other words, by increasing the bit-width, the resolution will increase only for [ − 2 − 2 b − 1 +1 , 2 − 2 b − 1 +1 ] .

Original: We refer this phenomenon as the rigid resolution of PoT quantization.
Revised: We refer this phenomenon as the rigid resolution of PoT quantization.

Original: Take Q p (1 , 5) as an example, the two smallest positive levels are 2 − 15 and 2 − 14 , which is excessive ﬁne-grained.
Revised: Take Q p (1 , 5) as an example, the two smallest positive levels are 2 − 15 and 2 − 14 , which is excessively ﬁne-grained.

Original: In contrast, the two largest levels are 2 − 1 and 2 0 , whose interval is large enough to incur high projection error for weights between [2 − 1 , 2 0 ] , e.g., 0.75.
Revised: In contrast, the two largest levels are 2 − 1 and 2 0 , whose interval is large enough to incur high projection error for weights between [2 − 1 , 2 0 ] , e.g., 0.75.

Original: The rigid resolution is demonstrated in Figure 2(b), where the new levels from 3-bit to 4-bit all  concentrateat around 0 and  cannot bolster the model expressiveness.
Revised: The rigid resolution is demonstrated in Figure 2(b). When we change from from 3-bit to 4-bit, all new quantization levels concentrate around 0 and thus cannot increase the model’s expressiveness effectively.

Original: [Figure]
Revised: [Figure]

Original: (k=
Revised: Uniform

Original: [Figure]
Revised: [Figure]

Revised: PoT (k=1) (k=2) (k=b)

Original: [Figure]
Revised: [Figure]

Original: =
Revised: Buffer Weights Buffer

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: +

Original: [Figure]
Revised: Accumulator

Original: Shiftxbit
Revised: Shiftxbit

Original: Output
Revised: Output

Original: Sign α ×
Revised: Sign α ×

Original: To tackle the rigid resolution problem, we propose Additive Powers-of-Two (APoT) quantization.
Revised: To tackle the rigid resolution problem, we propose Additive Powers-of-Two (APoT) quantization.

Original: Without loss of generality, in this section, we only consider unsigned numbers for simplicity 1 .
Revised: Without loss of generality, in this section, we only consider unsigned numbers for simplicity 2 .

Original: In
Revised: In

Original: APoT quantization, levels are viewed as a sum of several PoT terms as shown below,
Revised: APoT quantization, each level is the sum of n PoT terms as shown below,

Original: [Equation]
Revised: [Equation]

Original: where γ is a scaling coefﬁcient to make sure the maximum level in Q a is α .
Revised: where γ is a scaling coefﬁcient to make sure the maximum level in Q a is α .

Original: k is called the base bit-width, which is the bit-width for each additive term, and n is the number of additive terms.
Revised: k is called the base bit-width, which is the bit-width for each additive term, and n is the number of additive terms.

Original: When the bit-width b and the base bit-width k is set, n can be calculated by n = bk .
Revised: When the bit-width b and the base bit-width k is set, n can be calculated by n = bk .

Revised: There are 2 kn = 2 b levels in total.

Original: The number of additive terms in APoT quantization can increase with bit-width b , which provides ﬂexible resolution for the non-uniform levels.
Revised: The number of additive terms in APoT quantization can increase with bit-width b , which provides a higher resolution for the non-uniform levels.

Original: We use b = 4 and k = 2 as an example to illustrate how APoT resolves the rigid resolution problem.
Revised: We use b = 4 and k = 2 as an example to illustrate how APoT resolves the rigid resolution problem.

Original: For this example, we have p 1 ∈ { 0 , 2 0 , 2 − 2 , 2 − 4 } , p 2 ∈ { 0 , 2 − 1 , 2 − 3 , 2 − 5 } and γ = 2 α/ 3 .
Revised: For this example, we have p 0 ∈ { 0 , 2 0 , 2 − 2 , 2 − 4 } , p 1 ∈ { 0 , 2 − 1 , 2 − 3 , 2 − 5 } , γ = 2 α/ 3 , and Q a ( α, kn ) =

Revised: { γ × ( p 0 + p 1 ) } for all ( 2 b = 16 ) combinations of p 0 and p 1 .

Original: First, we can see the smallest positive quantization level in Q a (1 , 4) is 2 − 4 / 3 .
Revised: First, we can see the smallest positive quantization level in Q a (1 , 4) is 2 − 4 / 3 .

Original: Compared with the original PoT levels, APoT allocates quantization levels prudently for the central area.
Revised: Compared with the original PoT levels, APoT allocates quantization levels prudently for the central area.

Original: Second, APoT generates 3 new quantization levels between 2 0 and 2 − 1 , to properly increase the resolution.
Revised: Second, APoT generates 3 new quantization levels between 2 0 and 2 − 1 , to properly increase the resolution.

Revised: In Figure 2, the second row compares the 3 quantization methods using 4 bits for range [0, 1].

Revised: APoT quantization has a reasonable distribution of quantization levels, with more levels in the peak area (near 0) and relatively higher resolution than the vanilla PoT quantization at the tail (near 1).

Original: Relation to other quantization schemes.
Revised: Relation to other quantization schemes.

Original: On the one hand, the ﬁxed-point number representations used in the uniform quantization is a special case of APoT. When k = 1 in Equation (5), the quantization levels is a sum of b PoT terms or 0.
Revised: On the one hand, the ﬁxed-point number representations used in the uniform quantization is a special case of APoT. When k = 1 in Equation (5), the quantization levels is a sum of b PoT terms or 0.

Original: In the ﬁxed-point representations, each bit indicates one speciﬁc choice of the additive terms.
Revised: In the ﬁxed-point representations, each bit indicates one speciﬁc choice of the additive terms.

Original: On the other hand, when k = b , there is only one PoT term and Q a ( α, b ) becomes Q p ( α, b ) , i.e., PoT quantization.
Revised: On the other hand, when k = b , there is only one PoT term and Q a ( α, b ) becomes Q p ( α, b ) , i.e., PoT quantization.

Original: We can conclude that when k decreases,
Revised: We can conclude that when k decreases,

Original: APoT levels are decomposed into more PoT terms, and the distribution of levels becomes more uniform.
Revised: APoT levels are decomposed into more PoT terms, and the distribution of levels becomes more uniform.

Original: Our experiments use k = 2 , which is an intermediate choice between the uniform case ( k = 1 ) and the vanilla PoT case ( k = b ).
Revised: Our experiments use k = 2 , which is an intermediate choice between the uniform case ( k = 1 ) and the vanilla PoT case ( k = b ).

Original: Computation.
Revised: Computation.

Original: Multiplication for ﬁxed-point numbers can be implemented by shifting the multiplicand (i.e., the activations) and adding the partial product.
Revised: Multiplication for ﬁxed-point numbers can be implemented by shifting the multiplicand (i.e., the activations) and adding the partial product.

Original: The n in Equation (5) denotes the number of additive PoT terms in the multiplier (weights), and control the speed of computation.
Revised: The n in Equation (5) denotes the number of additive PoT terms in the multiplier (weights), and control the speed of computation.

Original: Since n = bk , either decreasing b or increasing k can accelerate the multiplication.
Revised: Since n = bk , either decreasing b or increasing k can accelerate the multiplication.

Original: Compared with uniform quantization ( k = 1 ), our method ( k = 2 ) is approximately 2 × faster in multiplication.
Revised: Compared with uniform quantization ( k = 1 ), our method ( k = 2 ) is approximately 2 × faster in multiplication.

Original: As for the full precision α , it is a coefﬁcient for all weights in a layer and can be multiplied only once after the multiply-accumulate operation is ﬁnished.
Revised: As for the full precision α , it is a coefﬁcient for all weights in a layer and can be multiplied only once after the multiply-accumulate operation is ﬁnished.

Original: Figure 3 shows the hardware accelerator, the weights buffer takes k -bit as a PoT term and shift-adds the activations.
Revised: Figure 3 shows the hardware accelerator, the weights buffer takes k -bit as a PoT term and shift-adds the activations.

Original: Generalizing to 2 n + 1 bits.
Revised: Generalizing to 2 n + 1 bits.

Original: When k = 2 , APoT quantization can only leverages 2 n -bit width for quantization.
Revised: When k = 2 , APoT quantization can only leverages 2 n -bit width for quantization.

Original: To deal with 2 n + 1 -bit quantization, we choose to add n + 1 PoT terms, one of which only contains 2 levels.
Revised: To deal with 2 n + 1 -bit quantization, we choose to add n + 1 PoT terms, one of which only contains 2 levels.

Original: The formulation is given by
Revised: The formulation is given by

Original: [Equation]
Revised: Q a ( α, 2 n + 1)

Original: [Figure]
Revised: = γ × { n − 1 (cid:88) i = p i + ˜ p } where p i ∈ { 0 , 1 2 i , 2 i + n , 2 i +2 n +1 } , ˜ p ∈ { 0 , 2 i +2 n } .

Original: Take 3-bit APoT quantization as an example, the levels are a sum of  p 0 and  ˜ p , where p 0 ∈ { 0 , 2 − 1 , 2 − 2 , 2 − 4 } and ˜ p ∈ { 0 , 2 − 3 } .
Revised: Take 3-bit APoT quantization as an example, every level is a sum of one p 0 and one ˜ p , where p 0 ∈ { 0 , 2 − 1 , 2 − 2 , 2 − 4 } and ˜ p ∈ { 0 , 2 − 3 } .

Original: The forward function is plotted in Figure 2(c).
Revised: The forward function is plotted in Figure 2(c).

Original: 2. R EPARAMETERIZED C LIPPING F UNCTION
Revised: 2. R EPARAMETERIZED C LIPPING F UNCTION

Original: Besides the projection operation, the clipping operation (cid:98)W , α (cid:101) is also important for quantization.
Revised: Besides the projection operation, the clipping operation (cid:98)W , α (cid:101) is also important for quantization.

Original: α is a threshold that determines the value range of weights in a quantized layer.
Revised: α is a threshold that determines the value range of weights in a quantized layer.

Original: Tuning the clipping threshold α is a key challenge because of the long-tail distribution of the weights.
Revised: Tuning the clipping threshold α is a key challenge because of the long-tail distribution of the weights.

Original: Particularly, if α is too large (e.g., the maximum absolute value of W ), Q ( α, b ) would have a wide range and then the projection will lead to large error as a result of insufﬁcient resolution for the weights in the central area; if α is too small, more outliers will be clipped slipshodly.
Revised: Particularly, if α is too large (e.g., the maximum absolute value of W ), Q ( α, b ) would have a wide range and then the projection will lead to large error as a result of insufﬁcient resolution for the weights in the central area; if α is too small, more outliers will be clipped slipshodly.

Original: Considering the distribution of weights can be complex and differs across layers and training steps, a static clipping threshold α for all layers is not optimal.
Revised: Considering the distribution of weights can be complex and differs across layers and training steps, a static clipping threshold α for all layers is not optimal.

Original: To jointly optimize the clipping threshold α and weights via SGD during training, Choi et al.
Revised: To jointly optimize the clipping threshold α and weights via SGD during training, Choi et al.

Original: (2018b) apply the Straight-Through Estimator (STE) (Bengio et al., 2013) to do the backward propagation for the projection operation.
Revised: (2018b) apply the Straight-Through Estimator (STE) (Bengio et al., 2013) to do the backward propagation for the projection operation.

Original: According to STE, the gradient to α is computed by ∂ ˆ W ∂α ≈ 
Revised: According to STE, the gradient to α is computed by ∂ ˆ W ∂α ≈ ∂ (cid:98)W ,α (cid:101)

Original: [Equation]
Revised: ∂α

Original:  sign ( W ) when |W| >
Revised: = sign ( W ) when |W| >

Original: α otherwise 0 , where the weights outside of the range cannot contribute to the gradients, which results in inaccurate gradient approximation.
Revised: α otherwise 0 , where the weights outside of the range cannot contribute to the gradients, which results in inaccurate gradient approximation.

Original: To provide a reﬁned gradient for the clipping threshold, we design a Reparameterized Clipping Function (RCF) as
Revised: To provide a reﬁned gradient for the clipping threshold, we design a Reparameterized Clipping Function (RCF) as

Original: [Equation]
Revised: [Equation]

Original: Instead of directly clipping them to [ − α, α ] , RCF outputs a constant clipping range and re-scales weights back after the projection, which is mathematically equivalent to Equation (1) during forward.
Revised: Instead of directly clipping them to [ − α, α ] , RCF outputs a constant clipping range and re-scales weights back after the projection, which is mathematically equivalent to Equation (1) during forward.

Original: In backpropagation, STE is adopted for the projection operation and the gradients of α are calculated by
Revised: In backpropagation, STE is adopted for the projection operation and the gradients of α are calculated by

Original: [Equation]
Revised: [Equation]

Original: The detail derivation of the gradients is shown in Appendix A. Compared with the normal clipping function, RCF provides more accurate gradient signals for the optimization because both weights inside ( |W| ≤ α ) and out of ( |W| > α ) the range can contribute to the gradient for the clipping threshold.
Revised: The detail derivation of the gradients is shown in Appendix A. Compared with the normal clipping function, RCF provides more accurate gradient signals for the optimization because both weights inside ( |W| ≤ α ) and out of ( |W| > α ) the range can contribute to the gradient for the clipping threshold.

Original: Particularly, the outliers are responsible for the clipping and the weights in [ − α, α ] are for projection.
Revised: Particularly, the outliers are responsible for the clipping, and the weights in [ − α, α ] are for projection.

Original: Therefore, the update of α considers both clipping and projection and ﬁnds a sweet spot between them.
Revised: Therefore, the update of α considers both clipping and projection, and tries to ﬁnd a balance between them.

Original: In experiments, we observe that the clipping threshold will become universally smaller when  bit-width is reduced to guarantee sufﬁcient resolution, which further validates the efﬁcaciousness of the gradient in RCF.
Revised: In experiments, we observe that the clipping threshold will become universally smaller when the bit-width is reduced to guarantee sufﬁcient resolution, which further validates the efﬁcaciousness of the gradient in RCF.

Original: 2. W EIGHT N ORMALIZATION
Revised: 2. W EIGHT N ORMALIZATION

Original: In practice, we ﬁnd that learning α for weights is quite arduous because the distribution of weights is pretty steep and changes frequently during training.
Revised: In practice, we ﬁnd that learning α for weights is quite arduous because the distribution of weights is pretty steep and changes frequently during training.

Original: As a result, jointly training the clipping threshold and weights parameters is hard to converge.
Revised: As a result, jointly training the clipping threshold and weights parameters is hard to converge.

Original: Inspired by the crucial role of batch normalization (BN) (Ioffe & Szegedy, 2015) in activation quantization (Cai et al., 2017), we propose weight normalization (WN) to reﬁne the distribution of weights with zero mean and unit variance, ˜ W = W − µ σ + (cid:15) , where µ = 1 I
Revised: Inspired by the crucial role of batch normalization (BN) (Ioffe & Szegedy, 2015) in activation quantization (Cai et al., 2017), we propose weight normalization (WN) to reﬁne the distribution of weights with zero mean and unit variance, [Equation] σ + (cid:15) , where µ = 1 I

Original: I (cid:88) i=
Revised: I (cid:88) i

Original: W i , σ = (cid:118)(cid:117)(cid:117)(cid:116)

Original: [Equation]
Revised: [Equation]

Original: where (cid:15) is a small number (typically 10 − 5 ) for numerical stability, and I denotes the number of weights in one layer.
Revised: where (cid:15) is a small number (typically 10 − 5 ) for numerical stability, and I denotes the number of weights in one layer.

Original: Note that quantization of weights is applied right after this normalization.
Revised: Note that quantization of weights is applied right after this normalization.

Original:  Normalization is important to provide a relatively consistent and stable input distribution to both clipping and projection functions for smoother optimization of α over different layers and iterations during training.
Revised: [Figure] with learning rate η W , η α W , η α X Normalization is important to provide a relatively consistent and stable input distribution to both clipping and projection functions for smoother optimization of α over different layers and iterations during training.

Original: Besides, making the mean of weights to be zero can reap the beneﬁts of the symmetric design of the quantization levels.
Revised: Besides, making the mean of weights to be zero can reap the beneﬁts of the symmetric design of the quantization levels.

Original: Here, we conduct a case study of ResNet-20 on CIFAR10 to illustrate how normalization for weights can help quantization.
Revised: Here, we conduct a case study of ResNet-20 on CIFAR10 to illustrate how normalization for weights can help quantization.

Original: For a certain layer (at a certain training step) in ResNet-18, We ﬁrstly ﬁx the weights, and let α go from 0 to max |W| to plot the curve of the clipping ratio (i.e. the proportion of clipped weights).
Revised: For a certain layer (at a certain training step) in ResNet-18, We ﬁrstly ﬁx the weights, and let α go from 0 to max |W| to plot the curve of the clipping ratio (i.e. the proportion of clipped weights).

Original: As shown in Figure 4a, the change of clipping ratio is much smoother after quantization.
Revised: As shown in Figure 4a, the change of clipping ratio is much smoother after quantization.

Original: As a result, the optimization of α will be signiﬁcantly smoother.
Revised: As a result, the optimization of α will be signiﬁcantly smoother.

Original: In addition, normalization also makes the distribution of weights quite more consistent over training iterations.
Revised: In addition, normalization also makes the distribution of weights quite more consistent over training iterations.

Original: We ﬁx the value of α , and visualize clipping ratio over training iterations in Figure 4b.
Revised: We ﬁx the value of α , and visualize clipping ratio over training iterations in Figure 4b.

Original: After normalization, the same α will result in almost the same clipping ratio, which improves the consistency of optimization goal for α .
Revised: After normalization, the same α will result in almost the same clipping ratio, which improves the consistency of optimization goal for α .

Original: More experimental analysis demonstrating the effectiveness of the normalization on weights can be found in Appendix B.
Revised: More experimental analysis demonstrating the effectiveness of the normalization on weights can be found in Appendix B.

Original: 2. T RAINING AND D EPLOYING
Revised: 2. T RAINING AND D EPLOYING

Original: We adopt APoT quantization for both weights and activations.
Revised: We adopt APoT quantization for both weights and activations.

Original: Notwithstanding the effect in activations is not conspicuous, we adopt APoT quantization for consistency.
Revised: Notwithstanding the effect in activations is not conspicuous, we adopt APoT quantization for consistency.

Original: During backpropagation, we use STE when computing the gradients of weights, i.e. ∂ ˆ W ∂ ˜ W = 1 .
Revised: During backpropagation, we use STE when computing the gradients of weights, i.e. ∂ ˆ W ∂ ˜ W = 1 .

Original: The detailed training procedure is shown in Algorithm 1.
Revised: The detailed training procedure is shown in Algorithm 1.

Original: For efﬁcient inference, we discard the full precision weights W and only store the quantized weights ˆ W .
Revised: To save memory cost during inference, we discard the full precision weights W and only store the quantized weights ˆ W .

Original: Which means our proposed normalization on weights does not occupy any memory or computation resources during inference.

Original: Compared with other uniform quantization methods, APoT quantization is more efﬁcient and effective during inference.
Revised: Compared with other uniform quantization methods, APoT quantization is more efﬁcient and effective during inference.

Original:  R ELATED W ORKS
Revised:  R ELATED W ORKS

Original: Non-Uniform Quantization.
Revised: Non-Uniform Quantization.

Original: Several methods are proposed to adapt to the non-uniform distribution of weights.
Revised: Several methods are proposed for the non-uniform distribution of weights.

Original: LQ-Nets(Zhang et al., 2018) learns quantization levels based on the quantization error minimization (QEM) algorithm.
Revised: LQ-Nets(Zhang et al., 2018) learns quantization levels based on the quantization error minimization (QEM) algorithm.

Original: Distillation (Polino et al., 2018) optimizes the quantization levels directly to minimize the task loss which reﬂects the behavior of their teacher network.
Revised: Distillation (Polino et al., 2018) optimizes the quantization levels directly to minimize the task loss which reﬂects the behavior of their teacher network.

Original: These methods use ﬁnite ﬂoating-point numbers to quantize weights (and activations), bringing extra computation overhead compared with linear quantization.
Revised: These methods use ﬁnite ﬂoating-point numbers to quantize weights (and activations), bringing extra computation overhead compared with linear quantization.

Original: Logarithmic quantizers (Zhou et al., 2017;
Revised: Logarithmic quantizers (Zhou et al., 2017;

Original: Miyashita et al., 2016) leverage powers-of-2 values to accelerate the computation by shift operations; however, they suffer from the rigid resolution problem.
Revised: Miyashita et al., 2016) leverage powers-of-2 values to accelerate the computation by shift operations; however, they suffer from the rigid resolution problem.

Original: Jointly Training.
Revised: Jointly Training.

Original: Many works havebeen explored to optimize the quantization parameters (e.g., α ) and the weights parameters simultaneously.
Revised: Many works have explored to optimize the quantization parameters (e.g., α ) and the weights parameters simultaneously.

Original: Zhu et al.
Revised: Zhu et al.

Original: (2016) learns positive and negative scaling coefﬁcients respectively.
Revised: (2016) learns positive and negative scaling coefﬁcients respectively.

Original: LQ-Nets jointly train these parameters to minimize the quantization error.
Revised: LQ-Nets jointly train these parameters to minimize the quantization error.

Original: QIL (Jung et al., 2019) introduces a learnable transformer to change the quantization intervals and optimize them based on the task loss.
Revised: QIL (Jung et al., 2019) introduces a learnable transformer to change the quantization intervals and optimize them based on the task loss.

Original: PACT (Choi et al., 2018b) parameterizes the clipping threshold in activations and optimize it through gradient descent.
Revised: PACT (Choi et al., 2018b) parameterizes the clipping threshold in activations and optimize it through gradient descent.

Original: However, in PACT, the gradient of α is not accurate, which only includes the contribution from outliers and ignores the contribution from other weights.
Revised: However, in PACT, the gradient of α is not accurate, which only includes the contribution from outliers and ignores the contribution from other weights.

Original: Weight Normalization.
Revised: Weight Normalization.

Original: Previous works on weight normalization mainly focus on addressing the limitations of BatchNorm (Ioffe & Szegedy, 2015).
Revised: Previous works on weight normalization mainly focus on addressing the limitations of BatchNorm (Ioffe & Szegedy, 2015).

Original: Salimans & Kingma (2016); Hoffer et al.
Revised: Salimans & Kingma (2016); Hoffer et al.

Original: (2018) decouple direction from magnitude to accelerate the training procedure.
Revised: (2018) decouple direction from magnitude to accelerate the training procedure.

Original: Weight Standardization (Qiao et al., 2019) normalizes weights to zero mean and unit variance during the forward pass.
Revised: Weight Standardization (Qiao et al., 2019) normalizes weights to zero mean and unit variance during the forward pass.

Original: However, there is limited literature that studies the normalization of weights for neural network quantization.
Revised: However, there is limited literature that studies the normalization of weights for neural network quantization.

Original: (Zhu et al., 2016) uses feature-scaling to normalize weights by dividing the maximum absolute value.
Revised: (Zhu et al., 2016) uses feature-scaling to normalize weights by dividing the maximum absolute value.

Original: Weight Normalization based Quantization (Cai & Li, 2019)
Revised: Weight Normalization based Quantization (Cai & Li, 2019)

Original: also uses this feature scaling and derive the gradient to eliminate the outliers in the weights tensor.
Revised: also uses this feature scaling and derive the gradient to eliminate the outliers in the weights tensor.

Original:  E XPERIMENT
Revised:  E XPERIMENT

Original: In this section, we validate our proposed method on ImageNet-ILSVRC

Revised: In this section, we validate our proposed method on ImageNet-ILSVRC

Original: (Russakovsky et al., 2015)
Revised: (Russakovsky et al., 2015)

Original: and CIFAR10 (Krizhevsky et al., 2009).
Revised: and CIFAR10 (Krizhevsky et al., 2009).

Original: We also conduct ablation studies investigating different quantizers and our proposed RCF as well as Weight Normalization.
Revised: We also conduct ablation study for each component of our algorithm.

Original: 4. E VALUATION ON I MAGE N ET
Revised: 4. E VALUATION ON I MAGE N ET

Original: We compare our methods with several strong state-of-the-art methods on ResNet architectures (He et al., 2016), including ABC-Net (Lin et al., 2017), DoReFa-Net (Zhou et al., 2016), PACT (Choi et al., 2018b), LQ-Net (Zhang et al., 2018), DSQ
Revised: We compare our methods with several strong baselines on ResNet architectures (He et al., 2016), including ABC-Net (Lin et al., 2017), DoReFa-Net (Zhou et al., 2016), PACT (Choi et al., 2018b), LQ-Net (Zhang et al., 2018), DSQ

Original: (Gong et al., 2019), QIL (Jung et al., 2019).
Revised: (Gong et al., 2019), QIL (Jung et al., 2019).

Original: Both weights and activations of the networks are quantized for comparisons.
Revised: Both weights and activations of the networks are quantized for comparisons.

Original: All  state-of-the-art methods use full precision (32 bits) for the ﬁrst and the last layer, which may introduce more memory cost.
Revised: All the state-of-the-art methods use full precision (32 bits) for the ﬁrst and the last layer, which incur more memory cost.

Original: In our implementation, we employ 8-bit quantization for them to balance the accuracy drop and the hardware overhead.
Revised: In our implementation, we employ 8-bit quantization for them to balance the accuracy drop and the hardware overhead.

Original: For our proposed APoT quantization algorithm, four conﬁgurations of the bit-width, i.e., 2,3,4, and 5 ( k = 2 and n = 1 or 2 in Equation (5) and (6)), where one bit is used for the sign of the weights but not for activations, are tested.
Revised: For our proposed APoT quantization algorithm, four conﬁgurations of the bit-width, i.e., 2,3,4, and 5 ( k = 2 and n = 1 or 2 in Equation (5) and (6)) are tested, where one bit is used for the sign of the weights but not for activations.

Original: Note that for the 2-bit symmetric  quantization of weights, Q ( α, 2) can only be {± α, 0 } , therefore only RCF and WN are used in this setting.
Revised: Note that for the 2-bit symmetric weight quantization method, Q ( α, 2) can only be {± α, 0 } , therefore only RCF and WN are used in this setting.

Original: To obtain a reasonable initialization, we follow Lin et al.
Revised: To obtain a reasonable initialization, we follow Lin et al.

Original: ; Jung et al.
Revised: ; Jung et al.

Original: (2019) touse a progressive way to initialize our model.
Revised: (2019) to initialize our model.

Original: For instance, the 5-bit quantized model is initialized from the pre-trained full precision one 2 , while the 4-bit network is initialized from the trained 5-bit model.
Revised: Speciﬁcally, the 5-bit quantized model is initialized from the pre-trained full precision one 3 , while the 4-bit network is initialized from the trained 5-bit model.

Original: We compare the accuracy, memory cost, and the ﬁxed point operations under different bit-width.
Revised: We compare the accuracy, memory cost, and the ﬁxed point operations under different bit-width.

Original: For the operation count, we use the bit-op computation scheme introduced in DoReFa (Zhou et al., 2016) and assume the one
Revised: To compare the operations with different bit-width, we use the bit-op computation scheme introduced in Zhou et al.

Original: FixOP is one operation between 8-bit weights and activations. An operation of k 1 n 1 -bitweights and k 2 n 2 -bit [-activations is counted as n 1 × n 
 FixOP.-]
Revised: (2016) where the multiplication between a m -bit and a l -bit [-activations is counted as n 1 × n 
 FixOP.-]uniform quantized number costs ml binary operation.

Original: One full precision operation is considered as one FixOP. Meanwhile, we omit the operations produced by Batch Normalization, as they are usually html
Revised: We deﬁne one FixOP as one operation between an 8-bit weight and an 8-bit activation which takesbinary operations if uniform quantization scheme is applied. In APoT scheme, the multiplication html

Original: [Table]
Revised: [Table]

Original: folded into convolution in hardware deployment.
Revised: between a m -bit activation and a l = kn -bit weight only needs mn shift-adds operations, i.e., n × m FixOPs.

Original: More details of the implementation are in the Appendices
Revised: More details of the implementation are in the Appendix C.2.

Original: [Table]

Original: Overall results are shown in Table 1.
Revised: Overall results are shown in Table 1.

Original: The results of DoReFa-Net are taken from Choi et al.
Revised: The results of DoReFa-Net are taken from Choi et al.

Original: (2018b), and the other results are quoted from the original papers.
Revised: (2018b), and the other results are quoted from the original papers.

Original: It can be observed that our 5-bit quantized network achieves even higher accuracy than the full precision baselines (0.7% Top-1 improvement on ResNet-18 and 0.2% Top-1 improvement on ResNet-34 and ResNet-50), which means quantization may serve the purpose of regularization.
Revised: It can be observed that our 5-bit quantized network achieves even higher accuracy than the full precision baselines (0.7% Top-1 improvement on ResNet-18 and 0.2% Top-1 improvement on ResNet-34 and ResNet-50), which means quantization may serve the purpose of regularization.

Original: Along with the accuracy performance, our APoT quantization can achieve better hardware performance on model size and FixOP when k is set to 2.
Revised: Along with the accuracy performance, our APoT quantization can achieve better hardware performance on model size and inference speed. For full precision models, the number in the column of FixOPs indicates FLOPs.

Original: 4-bit and 3-bit quantized networks are also preserving (or approaching) the full-precision accuracy  and  only drop 0.5% and 0.3% accuracy on 3-bit quantized ResNet-18 and ResNet-34.
Revised: 4-bit and 3-bit quantized networks are also preserving (or approaching) the full-precision accuracy except for the 3-bit quantized ResNet-18 and ResNet-34, which only drops 0.5% and 0.3% accuracy respectively.

Original: When b is further reduced to 2, our model still outperforms  baselines, which demonstrates the effectiveness of RCF and WN.
Revised: When b is further reduced to 2, our model still outperforms the baselines, which demonstrates the effectiveness of RCF and WN.

Original: Note that Choi et al.
Revised: Note that Choi et al.

Original: (2018a) use a full precision shortcut in the model, reaching higher accuracy on ResNet-50 however suffering from the hardware performance, especially the different precision between the main path and the residual path may result in greater latency in a pipelined implementation.
Revised: (2018a) use a full precision shortcut in the model, reaching higher accuracy on ResNet-50 however suffering from the hardware performance. In speciﬁc, the different precision between the main path and the residual path may result in greater latency in a pipelined implementation.

Original: 4. E VALUATION ON CIFAR 
Revised: 4. E VALUATION ON CIFAR

Original: We quantize ResNet-20 and ResNet-56 (He et al., 2016) on CIFAR10 for evaluation.
Revised: We quantize ResNet-20 and ResNet-56 (He et al., 2016) on CIFAR10 for evaluation.

Original: We adopt progressive initialization and choose the quantization bit as 2, 3 and 4.
Revised: We adopt progressive initialization and choose the quantization bit as 2, 3 and 4.

Original: More implementations can be found in the Appendix.
Revised: More implementations can be found in the Appendix C.2.

Original: [Table]
Revised: [Table]

Original: Table.
Revised: Table.

Original: 2 summarizes the accuracy of our APoT in comparison with baselines.
Revised: 2 summarizes the accuracy of our APoT in comparison with baselines.

Original: For 3-bit and 4-bit models, APoT quantization has reached comparable results with the full precision baselines.
Revised: For 3-bit and 4-bit models, APoT quantization has reached comparable results with the full precision baselines.

Original: It is worthwhile to note that all state-of-the-arts methods in the table use 4 levels to quantize weights into 2-bit.
Revised: It is worthwhile to note that all state-of-the-arts methods in the table use 4 levels to quantize weights into 2-bit.

Original: Our model only employs ternary weights for 2-bit representation and still outstrips existing quantization methods.
Revised: Our model only employs ternary weights for 2-bit representation and still outstrips existing quantization methods.

Original: 4. A BLATION S TUDY
Revised: 4. A BLATION S TUDY

Original: [Table]
Revised: [Table]

Original: The proposed algorithm consists of three techniques, APoT quantization levels to ﬁt the bell-shaped distribution, RCF to learn the clipping threshold and WN to avoid the perturbation of the distribution of weights during training.
Revised: The proposed algorithm consists of three techniques, APoT quantization levels to ﬁt the bell-shaped distribution, RCF to learn the clipping threshold and WN to avoid the perturbation of the distribution of weights during training.

Original: In this section, we conduct an ablation study for these three techniques
Revised: In this section, we conduct an ablation study for these three techniques

Original: [Table]
Revised: [Table]

Original: We compare the APoT quantizer, the vanilla PoT quantizer, uniform quantizer and a non-uniform quantizer using Lloyd algorithm
Revised: We compare the APoT quantizer, the vanilla PoT quantizer, uniform quantizer and a non-uniform quantizer using Lloyd algorithm

Original: (Cai et al., 2017) to quantize the weights.
Revised: (Cai et al., 2017) to quantize the weights.

Original: And we either apply
Revised: And we either apply

Original: RCF to learn the optimal clipping range or do not clip any weights (i
Revised: RCF to learn the optimal clipping range or do not clip any weights (i

Original: [Table]
Revised: [Table]

Original: e. α = max |W| ).
Revised: e. α = max |W| ).

Original: Weight
Revised: Weight

Original: Normalization is also adopted or discarded to justify the effectiveness of these techniques.
Revised: Normalization is also adopted or discarded to justify the effectiveness of these techniques.

Original: Table 3 summarizes the results of ResNet-18 using different techniques.
Revised: Table 3 summarizes the results of ResNet-18 using different techniques.

Original: Quantizer using Lloyd achieves the highest accuracy, however, the irregular non-uniform quantized weights cannot utilize the ﬁxed point arithmetic to accelerate the inference time.
Revised: Quantizer using Lloyd achieves the highest accuracy, however, the irregular non-uniform quantized weights cannot utilize the ﬁxed point arithmetic to accelerate the inference time.

Original: APoT quantization attends to the distribution of weights, which reaches the same accuracy in 5-bit and only decreases 0.2% accuracy in 3-bit quantization compared with Lloyd, and shares a better tradeoff between task performance and hardware performance.
Revised: APoT quantization attends to the distribution of weights, which reaches the same accuracy in 5-bit and only decreases 0.2% accuracy in 3-bit quantization compared with Lloyd, and shares a better tradeoff between task performance and hardware performance.

Original: We also observe that the vanilla PoT quantization suffers from the rigid resolution , and has the lowest accuracy in the 5-bit model.
Revised: We also observe that the vanilla PoT quantization suffers from the rigid resolution , and has the lowest accuracy in the 5-bit model.

Original: Clipping range also matters in quantization, the comparison in Table 3 shows that a proper clipping range can help improve the robustness of the network.
Revised: Clipping range also matters in quantization, the comparison in Table 3 shows that a proper clipping range can help improve the robustness of the network.

Original: Especially when the network is quantized to 3-bit, the accuracy will drop signiﬁcantly because of the quantization interval increases.
Revised: Especially when the network is quantized to 3-bit, the accuracy will drop signiﬁcantly because of the quantization interval increases.

Original: Applying
Revised: Applying

Original: RCF to learn the optimal clipping range could improve at most 1.6% accuracy.
Revised: RCF to learn the optimal clipping range could improve at most 1.6% accuracy.

Original: As we mentioned before, normalization of weight is important to learn the clipping range, and the network diverges if RCF is applied without WN.
Revised: As we mentioned before, normalization of weight is important to learn the clipping range, and the network diverges if RCF is applied without WN.

Original: We refer to the Appendix  for more details of weight normalization during training.
Revised: We refer to the Appendix B for more details of weight normalization during training.

Original:  [Figure] 4. R EVISITING Q UANTIZATION E RROR
Revised:  C ONCLUSION

Original: Typically, quantization error ( ∆ ) is deﬁned as the mean squared error between weights˜ W and ˆ W before and after quantization respectively, deﬁned as ∆ = E [ ˜ W − ˆ W ] 2 . This quantization error is composed of two errors, the clipping error ∆ clip produced by (cid:98)· , α (cid:101) and the projection error ∆ proj produced by Π Q .
Revised: In this paper, we have introduced the additive powers-of-two (APoT) quantization algorithm for quantizing weights and activations in neural networks, which typically exhibit a bell-shaped and long-tailed distribution. Each quantization level of APoT is the sum of a set of powers-of-two terms, bringing roughly 2x speed-up in multiplication compared with uniform quantization.

Original: I.e. [Equation] Previous methods (Zhang et al., 2018; Cai et al., 2017) seek to minimize the  quantization error to obtain theoptimal clipping threshold (i.e. α = arg min α (∆ clip + ∆ proj ) ), while RCF is directly optimized by the ﬁnal training loss to balance projection error and  clipping error.
Revised: The distribution of the quantization levels matches that of the weights and activations better than existing quantization schemes. In addition, we propose to reparameterize the clipping function and normalize the weights to get a more stable and better-deﬁned gradient for optimizing the clipping threshold.

Original: We compare the Quantization Error Minimization (QEM) method with our RCF on the quantized ResNet-18 model.
Revised: We reach state-of-the-art accuracy on ImageNet and CIFAR10 dataset compared to uniform or PoT quantization.

Original: Figure 5 gives an overview of the clipping error and projection error using RCF or QEM. For the 5-bit quantized model, RCF has a much higher quantization error. The projection error obtained by RCF is lower than QEM and QEM signiﬁcantly reduces the clipping error. Therefore, we can infer that projection error has a higher priority in RCF.
Revised: A CKNOWLEDGEMENT

Original: When quantizing to 3-bit, the clipping error in RCF still exceeds QEM except for the ﬁrst quantized layer. This means RCF can identify whether the projection is more important than the clipping over different layers and bit-width.
Revised: This work is supported by National University of Singapore FY2017 SUG Grant and Singapore Ministry of Education Academic Research Fund Tier 3 under MOEs ofﬁcial grant number

Original: Generally, the insight behind is that simply minimizing the quantization error may not be the best choice and it is more direct to optimize threshold with respect to training loss.
Revised: MOE2017-T3-1-007.

Original: APPENDICES A G RADIENT D ERIVATION
Revised: APPENDICES A G RADIENT D ERIVATION

Original: In this section, we derive the gradient estimation of PACT (Choi et al., 2018b) and our proposed Reparameterized Clipping Function and show the distinction of these two estimation.
Revised: In this section, we derive the gradient estimation of PACT (Choi et al., 2018b) along with our proposed Reparameterized Clipping Function and show the distinction of these two estimation.

Original: A. PACT
Revised: A. PACT

Original: Equation (1) shows the forward of PACT.
Revised: Equation (1) shows the forward of PACT.

Original: In backpropagation, PACT applies the Straight-Through
Revised: In backpropagation, PACT applies the Straight-Through

Original: Estimator for the projection operation.
Revised: Estimator for the projection operation.

Original: In particular, the STE assumes that
Revised: In particular, the STE assumes that

Original: [Equation]
Revised: [Equation]

Original:  which means the variable before and after projection are treated the same in backpropagation.
Revised: (10) which means the variable before and after projection are treated the same in backpropagation.

Original: Therefore, the gradients of α in PACT is computed by:
Revised: Therefore, the gradients of α in PACT is computed by:

Original: [Equation]
Revised: [Equation]

Original: where the ﬁrst term is computed by STE and the second term is because the clip operation (cid:98)· , α (cid:101) returns sign ( · ) α when | · | > α .
Revised: where the ﬁrst term is computed by STE and the second term is because the clip operation (cid:98)· , α (cid:101) returns sign ( · ) α when | · | > α .

Original: In this gradient estimation, the effect of α in the levels set Q ( α, b ) is eliminated by the STE, leading to an inaccurate approximation.
Revised: In this gradient estimation, the effect of α in the levels set Q ( α, b ) is ignored by the STE, leading to an inaccurate approximation.

Original: A. RCF
Revised: A. RCF

Original: To avoid the elimination of STE, we reparameterize the clipping function so that the output clipping range before projection is settled and the range is re-scaled after the projection.
Revised: To avoid the elimination of STE, we reparameterize the clipping function so that the output clipping range before projection is settled and the range is re-scaled after the projection.

Original: We can deﬁne a general formation of RCF by
Revised: We can deﬁne a general formation of RCF by

Original: [Equation]
Revised: [Equation]

Original: (13) where c > 0 is a constant.
Revised: (12) where c > 0 is a constant.

Original: This function clips the weights to [ − c, c ] before projection and re-scaled to [ − α, α ] after projection.
Revised: This function clips the weights to [ − c, c ] before projection and re-scaled to [ − α, α ] after projection.

Original: Thus, the backpropagation is given by:
Revised: Thus, the backpropagation is given by:

Original: [Equation]
Revised: [Equation]

Original: Since the levels set Q is not parameterized by α , the gradients will ﬂow to two parts in RCF: the re-scale coefﬁcient and the scale in clipping function.
Revised: Since the levels set Q is not parameterized by α , the gradients will ﬂow to two parts in RCF: the re-scale coefﬁcient and the scale in clipping function.

Original: The constant c here do not impact the gradient estimation, therefore we choose 1 for simplicity in the implementation.
Revised: The constant c here do not impact the gradient estimation, therefore we choose 1 for simplicity in the implementation.

Revised: Note that in uniform quantization scheme, this function is equivalent to the Learned Step Size Quantization (Esser et al., 2020), where the setp size is the same for all levels while RCF provides a more general formation for any levels set Q .

Original: B H OW D OES N ORMALIZATION H ELP Q UANTIZATION
Revised: B H OW D OES N ORMALIZATION H ELP Q UANTIZATION

Original: In this section, we show some experimental results to illustrate the effect of our weights normalization in quantization neural networks. 
Revised: In this section, we show some experimental results to illustrate the effect of our weights normalization in quantization neural networks. [Figure]

Original: B. W EIGHTS D ISTRIBUTION
Revised: B. W EIGHTS D ISTRIBUTION

Original: We visualize the density distribution of weights before normalization W and after normalization ˜ W during training to demonstrate its effectiveness.
Revised: We visualize the density distribution of weights before normalization W and after normalization ˜ W during training to demonstrate its effectiveness.

Original: Figure 6a demonstrates the density distribution of the ﬁfth layer of the 5-bit quantized ResNet-18, from which we can see that the density of the unnormalized weights could be extensive high ( > 8) in the centered area.
Revised: Figure 5a demonstrates the density distribution of the ﬁfth layer of the 5-bit quantized ResNet-18, from which we can see that the density of the unnormalized weights could be extensive high ( > 8) in the centered area.

Original: Such distribution indicates that even a tiny change of clipping threshold would bring a signiﬁcant effect on clipping when α is small, as shown in Figure 4a. , which means a small learning rate for α is needed.
Revised: Such distribution indicates that even a tiny change of clipping threshold would bring a signiﬁcant effect on clipping when α is small, as shown in Figure 4a. , which means a small learning rate for α is needed.

Original: However, if the learning rate is too small, the change of α cannot follow the change of weights distribution because weights are also updated according to Figure 6a.
Revised: However, if the learning rate is too small, the change of α cannot follow the change of weights distribution because weights are also updated according to Figure 5a.

Original: Thus it is unfavorable to train the clipping threshold for unnormalized weights, while Figure 6b shows that the normalized weights can have a stable distribution.
Revised: Thus it is unfavorable to train the clipping threshold for unnormalized weights, while Figure 5b shows that the normalized weights can have a stable distribution.

Original: Furthermore, the dashed line in the ﬁgure indicates W usually do not have zero mean, which may not utilize the symmetric design of quantization levels.[Figure]
Revised: Furthermore, the dashed line in the ﬁgure indicates W usually do not have zero mean, which may not utilize the symmetric design of quantization levels.

Original: B. T RAINING B EHAVIOR
Revised: B. T RAINING B EHAVIOR

Original: The above experiments use normalization during training to compare the distribution of weights.
Revised: The above experiments use normalization during training to compare the distribution of weights.

Original: In this section, we compare the training of quantization neural networks with and without normalization to investigate the real effect of WN.
Revised: In this section, we compare the training of quantization neural networks with and without normalization to investigate the real effect of WN.

Original: Here, we train a 3-bit quantized (full precision for activations)
Revised: Here, we train a 3-bit quantized (full precision for activations)

Original: ResNet-20 from scratch, and compare the results under different learning rate for α .
Revised: ResNet-20 from scratch, and compare the results under different learning rate for α .

Original: The results are shown in Table 4, from which we can ﬁnd that if weights are normalized during training, the network can converge to descent performances and is robust to the learning rate of clipping threshold.
Revised: The results are shown in Table 4, from which we can ﬁnd that if weights are normalized during training, the network can converge to descent performances and is robust to the learning rate of clipping threshold.

Original: However, if the weights are not normalized, the network would diverge if the learning rate for α is too high.
Revised: However, if the weights are not normalized, the network would diverge if the learning rate for α is too high.

Original: Even if the learning rate is set to a lower value, the network does not outperform the normalized one.
Revised: Even if the learning rate is set to a lower value, the network does not outperform the normalized one.

Original: Based on the training behaviors, the learning rate for clipping threshold without
Revised: Based on the training behaviors, the learning rate for clipping threshold without

Original: WN in QNNs need a careful choice.
Revised: WN in QNNs need a careful choice.

Revised: [Table]

Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: C E XPERIMENTS D ETAILS C. I MPLEMENTATIONS D ETAILS
Revised: C E XPERIMENTAL D ETAILS C. R EVISITING Q UANTIZATION E RROR

Revised: Typically, quantization error ( ∆ ) is deﬁned as the mean squared error between weights ˜ W and ˆ W before and after quantization respectively, deﬁned as ∆ =

Revised: E [ ˜ W − ˆ W ] 2 .

Revised: This quantization error is composed of two errors, the clipping error ∆ clip produced by (cid:98)· , α (cid:101) and the projection error ∆ proj produced by Π Q .

Revised: I.e.

Revised: [Equation]

Revised: Previous methods (Zhang et al., 2018; Cai et al., 2017) seek to minimize the quantization error to obtain the optimal clipping threshold (i.e. α = arg min α (∆ clip + ∆ proj ) ), while RCF is directly optimized by the ﬁnal training loss to balance projection error and clipping error.

Revised: We compare the

Revised: Quantization Error Minimization (QEM) method with our RCF on the quantized ResNet-18 model.

Revised: Figure 6 gives an overview of the clipping error and projection error using RCF or QEM.

Revised: For the 5-bit quantized model, RCF has a much higher quantization error.

Revised: The projection error obtained by RCF is lower than QEM and QEM signiﬁcantly reduces the clipping error.

Revised: Therefore, we can infer that projection error has a higher priority in RCF.

Revised: When quantizing to 3-bit, the clipping error in RCF still exceeds QEM except for the ﬁrst quantized layer.

Revised: This means RCF can identify whether the projection is more important than the clipping over different layers and bit-width.

Revised: Generally, the insight behind is that simply minimizing the quantization error may not be the best choice and it is more direct to optimize threshold with respect to training loss.

Revised: C. I MPLEMENTATIONS D ETAILS

Original: The ImageNet dataset consists of 1.2M training and 50K validation images.
Revised: The ImageNet dataset consists of 1.2M training and 50K validation images.

Original: We use a standard data preprocess in the original paper (He et al., 2016).
Revised: We use a standard data preprocess in the original paper (He et al., 2016).

Original: For training images, they are randomly cropped and resized to 224 × 224 .
Revised: For training images, they are randomly cropped and resized to 224 × 224 .

Original: Validation images are center-cropped to the same size.
Revised: Validation images are center-cropped to the same size.

Original: We use the Pytorch ofﬁcial code 3 to construct ResNets, and they are initialized from the released pre-trained model.
Revised: We use the Pytorch ofﬁcial code 4 to construct ResNets, and they are initialized from the released pre-trained model.

Original: We use stochastic gradient descent (SGD) with the momentum of 0.9 to optimize both weight parameters and the clipping threshold simultaneously.
Revised: We use stochastic gradient descent (SGD) with the momentum of 0.9 to optimize both weight parameters and the clipping threshold simultaneously.

Original: Batch size is set to 1024 and the learning rate starts from 0.1 with a decay factor of 0.1 at epoch 30,60,80,100.
Revised: Batch size is set to 1024 and the learning rate starts from 0.1 with a decay factor of 0.1 at epoch 30,60,80,100.

Original: The network is trained up to 120 epochs and weight decay is set to 10 − 4 for 3-bit quantized models or higher and 2 × 10 − 5 for 2-bit model.
Revised: The network is trained up to 120 epochs and weight decay is set to 10 − 4 for 3-bit quantized models or higher and 2 × 10 − 5 for 2-bit model.

Original: The CIFAR10 dataset contains 50K training and 10K test images with 32 × 32 pixels.
Revised: The CIFAR10 dataset contains 50K training and 10K test images with 32 × 32 pixels.

Original: The ResNet architectures for CIFAR

Revised: The ResNet architectures for CIFAR

Original: (He et al., 2016) contains a convolutional layer followed by 3 residual blocks and a ﬁnal FC layer.
Revised: (He et al., 2016) contains a convolutional layer followed by 3 residual blocks and a ﬁnal FC layer.

Original: We train full precision ResNet-20 and ResNet-56 ﬁrstly and use them as initialization for quantized models.
Revised: We train full precision ResNet-20 and ResNet-56 ﬁrstly and use them as initialization for quantized models.

Original: All networks were trained for 200 epochs with a mini-batch size of 128.
Revised: All networks were trained for 200 epochs with a mini-batch size of 128.

Original: SGD with momentum of 0.9 was adopted to optimize the parameters.
Revised: SGD with momentum of 0.9 was adopted to optimize the parameters.

Original: Learning rate started at 0.1 and was scaled by 0.1 at epoch 80,120.
Revised: Learning rate started at 0.04 and was scaled by 0.1 at epoch 80,120.

Original: Weight decay was set to 10 − 4 .
Revised: Weight decay was set to 10 − 4 .

Original: For clipping threshold α , we set 8.0 for activations and 3.0 for weights as initial value when training a 5-bit quantized model.
Revised: For clipping threshold α , we set 8.0 for activations and 3.0 for weights as initial value when training a 5-bit quantized model.

Original: The learning rate of α is set to 0.01 and 0.03 for weights and activations, respectively.
Revised: The learning rate of α is set to 0.01 and 0.03 for weights and activations, respectively.

Original: During practice, we found that the learning rate of α merely does not inﬂuence network performance.
Revised: During practice, we found that the learning rate of α merely does not inﬂuence network performance.

Original: Different from PACT (Choi et al., 2018b), the update of α in our works already consider the projection error, so we do not require a relatively large L2-regularization.
Revised: Different from PACT (Choi et al., 2018b), the update of α in our works already consider the projection error, so we do not require a relatively large L2-regularization.

Original: In practice, the network works ﬁne when the weight decay for α is set to 10 − 5 and may increase to 10 − 4 when bit-width is reduced.
Revised: In practice, the network works ﬁne when the weight decay for α is set to 10 − 5 and may increase to 10 − 4 when bit-width is reduced.