PARQ: Piecewise-Affine Regularized Quantization
Authors: Lisa Jin
Jianhao Ma
Zechun Liu
Andrey Gromov
Aaron Defazio
Lin Xiao
Venue: ICML 2025 poster (2025)
Keywords: quantization-aware training
proximal gradient method
convex regularization
stochastic gradient method
last-iterate convergence
Primary area: optimization
TL;DR: We propose a principled method for quantization-aware training (QAT) following a convex regularization framework.

Abstract: We develop a novel optimization method for quantization-aware training (QAT). Specifically, we show that convex, piecewise-affine regularization (PAR) can effectively induce neural network weights to cluster towards discrete values. We minimize PAR-regularized loss functions using an aggregate proximal stochastic gradient method (AProx) and prove that it enjoys last-iterate convergence. Our approach provides an interpretation of the straight-through estimator (STE), a widely used heuristic for QAT, as the asymptotic form of PARQ. We conduct experiments to demonstrate that PARQ obtains competitive performance on convolution- and transformer-based vision tasks.

PARQ: Piecewise-Affne Regularized Quantization
Lisa Jin' Jianhao Ma
Zechun Liu
Andrey Gromov
Aaron Defazio'
Lin Xiao
Abstract
for transformer-based models, which are more difficult to quamtize (Bai et al., 2021; Qin et al., 2022) compared to convolutional architectures (Martinez et al., 2019; Qin et al., 2020). On the other hand, QAT integrates quantization into pre-training and/or fine-tuning processes and can produce low-bit (including binary) models with mild performance degradation (e.g. Fan et al., 2021; Liu al., 2022).
We develop a novel optimization method for quantization-awe awwete training (QAT). Specifically, we show that convex, piecewise-affine regular- ization (PAR) can effectively induce the model parameters to cluster towards discrete, quantized values. We minimize PAR- regulaaulr loss func- tions using an aggregate proximal stochastic gra- dient method (AProx) and show that it enjoys last-iterate convergence. Our approach provides an interpretation of the straight-through estima- tor (STE), widely used heuristic for QAT, as the asymptotic form of PARQ. We present nu- merical experiments to demonstrate that PARQ obtains competitive performance convolution- and transformer-based vision tasks.
A key ingredient of QAT is the so-called straight-through estimator (STE), which was proposed as a heuristic (Ben- gio et al., 2013; Courbariaux et al., 2015) and has been extremely successful in practice (e.g., Rastegari et al., 2016; Hubara et al., 2018; Esser et al., 2019). Many efforts have been made to demystify the effectiveness of STE, especially through the lens of optimization algorithms (e.g., Li et al., 2017; Yin et al., 2018; 2019; Bai al., 2019; Ajanthan et al.. 2021; Dockhorn al., 2021; Lu et al., 2023). However, sig- nificant gaps remain between theory and practice.
1. Introduction
In this paper, we develop a principled method for QAT based on conver regularization and interpret STE as the asymptotic form of an aggregate proximal stochastic gradient method. The convex regularization framework admits stronger con- vergence guarantees than previous work and allows to prove the last-iterate convergence of the method.
Modern deep learning models exhibit exceptional vision and language processing capabilities, but often come with excessive sizes and demands on memory and computing. Quantization is an effective approach for model compres- sion, which can significantly reduce their memory footprint, computing cost, as well as the latency for inference (e.g., Han et al., 2016; Sze et al.. 2017). There are two main classes of quantization methods: post-training quantization (PTQ) and quantization-aware training (QAT). Both are widely adopted and receive extensive research; see the re- cent survey papers by Gholami et al. (2022) and Fournarakis et al. (2022) and references therein.
1.1. The Straight-Through Estimator (STE)
We consider training machine learning model with pa- rameters E Rd and let f(w, 2) denote the loss of the model on training example Our goal is to minimize the population loss f(w) = E. [f,, 2)] where a follows some unknown probability distribution. Here, we focus on the classical stochastic gradient descent (SGD) method. During each iteration of SGD, we draw a random training example (or mini-batch) zt and update the model parameter as r wn 1e f (w',z'),
PTQ converts the weights of a pre-trained model directly to lower precision without repeating the training pipeline; thus has less overhead and is relatively easy to apply (Nagel et al., 2020; Cai et al., 2020; Chee et al., 2024). However, is limited mainly to 4 or more bit regimes and can suffer steep performance drops with fewer bits (Yao et al., 2022: Dettmers & Zettlemoyer, 2023). This is especially the case
(1)
where ff( x²) denotes the stochastic gradient with respect to the first argument (here being w²) and m is the step size.
QAT methods modify SGD by adding a quantization step. In particular, the BinaryConnect method (Courbariaux et al., 2015) can be written as
'Meta FAIR, United States. Dept. Industrial and Operational Engineering. University of Michigan, Ann Arbor, MI, United States. 'Meta Reality Labs, United States. Correspondence to: Lisa Jin <Ivj@ <lvj@meta.com>, Lin Xiao <linx @meta.com>. Proceedings of the nddd International Conference on Machine Learning, Vancouver, Canada. PMLR 267, 2025. Copyright 2025 by the author(s).
++ =
(2)
where Q(-) is the coordinate-wise projection onto the set

---

PARQ: Piccewise-Aflie Regularized Quantization
Quu)
Alternatively, we can view (2) as an implicit algorithm for updating w² and analyze its convergence. More explicitly,
Q2
u ++1 = -u- f(w" ,²),
(3)
91
w ++ = =((
(2
Here u' serves as an auxiliary variable that accumulates past gradients evaluated at This formulation allows application of the powerful frame- work of regularization and proximal gradient methods (e.g.. Bai et al., 2019; Dockhorn et al., 2021). And this is the path we take in this paper.
w' (similar to momentum).
2
42
Figure I. A quantization map with Q = {0, Lq,, Lq2).
1.2. Outline and contributions
(+1]4. It readily generalizes to projection onto Qd where Q is a finite set of arbitrary quantization values. Figure shows an example with Q = (0, t --2)-
In Section 2, we review the framework of regularization and introduce family of convex, piecewise-affin regular- izers (PAR). In addition, we derive the first-order optimality conditions for minimizing PAR-regularized functions.
Notice that in Equation (2) we switched the notation from wt to u², because we would like to define w² = Q(u") as the quantized model parameters. This reveals key feature of QAT: the stochastic gradient in (2) is computed at w² instead of u' itself (which would be equivalent to (1)). Here we regard u' as a full-precision latent variable that is used to accumulate the gradient computed at w', and the quan- tization map (-)) is applied to the latent variable w(+1 to generate the next quantized variable w*1
In Section 3, we derive an aggregate proximal gradient method (AProx) for solving PAR-regularized minimization problems and provide its convergence analysis for convex losses, AProx applies soft-quantization map that evolves over the iterations and asymptotically converges to hard quantization, thus giving a principled interpretation of STE.
In Section 4, we present PARQ (Piecewise- Affine Regular- ized Quamtization), a practical implementation of AProx with PAR regularization that does not need to pre-determine the quantization values and regularization strength.
The notion of STE arises from the intent of computing approximate gradient of the loss function with respect to u'.
Let us define the function f(,, 2) == (Q))), 2) f(w, 2)
In Section 5, we conduct QAT experiments on low-bit quan- tization of convolution- and transformer-base vision mod- els and demonstrate that PARQ obtains competitive perfor- mance compared to STTE/BinaryConnee as well as other methods based on nonconvex regularization.
in light of w- Q(u). Then we have for each i = 1,...,d, d,
of 0f dw, of dQ((s). du, ow, du, ow, du,
However, due to the staircase shape of the quantization map, we have dQ(us)/du; = 0 and thus vf(u, =) = 0 almost everywhere, which prevent effective learning. In order to fix this problem, STE tries to "construct" a nontrivial gradient with respect to u, by simply treating Q(-) as the identity map during backpropagation, i.e., replacing dQ(u.)/ du; with in the above equation. This leads to the straight-throughh approximation
We note that Dockhorn et al. (2021) already used the regu- larization framework and proximal optimization to interpret (demystify) BinaryConnect and developed a generalization called ProxConnect. In fact, AProx is equivalent to Prox- Connect albeit following quite different derivations. Never- theless, we make the following novel contributions.
We propose convex PAR to induce quantization. Dockhorn et al. (2021) focused on monotone (non- decreasing) proximal maps, which can correspond to arbitrary regularization. Although they presented con- vergence results for convex regularization, no such example was given demonstrate its relevance. Be- yond closing this gap between theory and practice, our construction of convex PAR is rather surprising coun- tcrintuitive for the purpose of quantization.
vf(u,,)
2)
STE R
Vf(w, 2) V (u)),,,
so that one can interpret Equation (2) as an (approximate) SGD update for minimizing the composite function f()).
There are several issues with this argument. First, we know exactly that dQ(u)//d /du, 0 almost everywhere, so there is no need for "approximation." Second, any approximation that replaces 0 with 1 in this context warrants scrutiny of the resulting bias and the consequences on training stability. Existing works on this are restricted to special cases and weak convergence results (Li et al., 2017; Yin et al., 2019).
We derive first-order optimality conditions for minimiz- ing Pegulaaul functions. They reveal the critical role of nonsmoothness in inducing quantization.
2

---

PARQ: Piccewise-Affie Regularized Quantization
by
03
100
by
41
b1
(a) (w) = |||] ||
(b) (w)
min
1100
u|l2
ME (=1)
93
92
Q1
0
91
93
Figure 2. Illustration of two nonsmooth regularizers.
Figure 3. Convex PAR: (w) = max [ax((w]] 96) + bu}.
We prove last-iterate convergence of AProx. The con- vergence results of Dockhorn et al. (2021) concern the averaged iterates generated by ProxConnect/ A Arox. While such results are conventional in the stochastic optimization literature, they are far from satisfactory for QAT, because the averaged iterate may not be quan- tized even if every iterate is quantized. Last-iterate convergence gives a much stronger guarantee.
the Li-merric, resulting in (w)) min ||e w w|ll: Figure 2(b) shows a W-shaped example in one dimension.
We argue that the effectiveness of a regularizer for induc- ing quantization largely relies on two critical properties: nonsmoothness and convexity. Smooth regularizers such as dist(w, 2*) == min g4 ||e w|l2 behave like ||wl|3 locally, thus do not induce the other hand, nonsmooth regularizers behave like ||w|| near zero, so they can trap model parameters at the set of nondifferentiable points- mont
or any discrete structure. On
We propose a practical implementation called PARQ that can adaptively choose the quantization values and regularization strength in online fashion.
more suitable for quantization.
Convexity concerns the global behavior of regularization. For example, the popularity of L--regularization for sparse optimization largely attributed its convexity besides being nonsmooth. On the other hand, it is hard for gradient- based algorithm to cross the middle hill in the nonconvex W-shaped regularizer shown in Figure 2(b), if the initial weights are trapped in the wrong valley from the optimal ones. Therefore, ideally we would like to construct a regu- larizer that both nonsmooth and convex.
Our implementation of PARQ in PyTorch is available ht tps://githhb.com fac.bookreeearrcoooooooo rq.
2. Piecewise affine regularization (PAR)
Regularization is a common approach for inducing desired properties of machine learning models, by minimizing weighted sum of the loss function f and regularizer V:
minimize wER*
fww) + (w)),,
(4)
2.1. Definition of PAR
where À R., is parameter to balance the relative strength of regularization. For example, it is well known that L2- regularization helps generalization by preferring smaller model parameters, and L -egelllaaiiztionn illustrated in Fig- ure 2(a), induces sparsity (c.g., Hastie et al., 2009).
To simplify presentation, we assume (w)= (w:) and use the same notation V for the function of vector or one of its coordinates (it should be self-evident from the context). For most of the discussion, we focus on the scalar case and omit the subscript i or simply assume d = 1.
There have been many attempts of using regularization to induce quantization (e.g., Carreira-Perpifaa & Idelbayev, 2017; Yin et al., 2018; Bai al., 2019). An obvious choice is to let v be the indicator function of Q':; in other words,
Suppose that the set of target quantization values is given as Q = {0, =q....... =q with 0 = 4o < 91 < < [m- We define a piecewise-affine regularizer (PAR) as
I (w) = E (w:) where
(w) = max {as([w) 9k) ba). (O.....m)
(6)
if Wa E Q, 6e(w;) = +00 otherwise.
So
where the slopes {ax O an an determined by setting bo 0, qo = 0, and
Im are free parameters that satisfy
(5)
am +0c, and (be )
Then minimizing f(w) + (w) is equivalent to the con- strained optimization problem of minimizing (w) subject to E Qd,, which is combinatorial in nature and very hard to solve in general. Yin et al. (2018) propose to use the Moreau envelope of the indicator function, which under the Euclidean metric gives (w) = min,e [|v - w [3. A nonsmooth version proposed by Bai et (2019) under
be = -a- + ak-1 - y 1);
k 1,..,,,m m.
As shown in Figure 3, (= by) are the reflection points of the piecewise-affin graph. The function & (w) is convex because the maximum of finite linear functions is convex (Boyd & Vandenberghe, 2004, Section 3.2.3).
3

---

We immediately recognize that the sufficient condition for wo 0 (third equation above) is the same as for the L1- regularization (w) = A ao]lw|/1- Further examination reveals that for any weight not clustered at a discrete value in Q, i.e., if w E (4k-1. for some k, the correspond- ing partial derivative V.j(w") must equal the singleton PARQ: Piccewise-Afliee Regularized Quantization
02 +000
92
91
02
d1
93
0
91
0g =0
0gg
91
91
92
91
92
+.00
tb +
+
(a) 1-bit: Q = {+
(b) 2-bit: Q
11 722
10
2h
01 = +000
Figure 5. Graph of prox (u).
Og 0
11
0
(d) Temary: Q {0, +
Figure 4. Three special cases of PAR for low-bit quantization.
Aaa-1- 1. Conversely, almost all values of the partial deriva- tives of f. except for the 2m discrete values, { 1 can be balanced by assigning the model parameters the 2m + 1 discrete values in Q = {0, + +.mm }- Intu- itively, this implies that the model parameters at optimality are more likely to cluster at these discrete values. We will derive an algorithm that manifests this property rigorously in Section 3.
We note that setting Op = 0 effectively removes qo = 0 from the quantization set Q because it is no longer a reflection point of V. Figure 4 illustrates three special cases of PAR for low-bit quantization, where both Figures 4(a) and 4(b) have ao O. Finally, note that the above definition of PAR is symmetric around zero, for the convenience of presentation. It is straightforward to extend to the asymmetric case.
2.2. Optimality conditions
2.3. Proximal mapping of PAR
In order to understand how PAR can induce quantization, we examine the optimality conditions of minimizing PAR- regularized functions. Suppose f is differentiable and w" is a solution to the optimization problem (4). The first-order optimality condition for this problem is (see, e.g.. Wright & Recht, 2022, Theorem 8.18)
A fundamental tool for solving problem (4) the preximal map of the regularizer V, defined as
proxy (u) arg min,, (w(w)) + +//l u 11
See, e.g., Wright & Recht (2022, $8.6) for further details. For the PAR function defined in (6), its proximal map has the following closed-form solution (letting a-1 = 0)
0 E Vf(w"))+ + (w"),
where (ww") denotes the subdifferential of V at w*, and 10 (w*) means multiplying each element of the set 04 (T(w)) by X. For convenience, we rewrite it as fww") E
sgn(u)as if [u] E + 0x + qul:
prox. (u)= (u)
sgn(u)a if |u] E [ax + ak q
-X AV(( (w*), which breaks down into the following cases:
where sgn(-) denotes the sign or signum function.
w = qk:
= v,s(w*) (ak-1,
Figure 5 shows the graph of p (u). which is clearly monotone non-decreasing in u. According to Yu et al. (2015, Proposition 3), a (possibly multi-valued) map is proximal map of some function if and only it is compact-valued, monotone and has a closed graph. For example. the hard- quantization map in Figure 1 is the proximal map of the (nonconvex) indicator function de in (5). Dockhorn et al. (2021) work with monotone proximal maps directly without specifying the regularizer itself. In contrast, we construct a convex regularizer, and show that it can effectively induce quantization and obtain competitive performance in practice, together with stronger convergence guarantees.
w/ E ( The q)-
= v.f(w*) Aap-1
w/ =0
-.f(w*) A( A(-a0, ao)
w E (qa-1, 1, (x))
v.S(w*)- -XAE-1
w/ = Ql:
v.f(w*) E A (-Ok, - ak -1).
Here V. denotes the ith coordinate of the vector VS, the subscript runs from 1 through d, and the piccewise-aftine index & runs from 1 through m. The symbol = (-) means that the expression on the left side is a necessary (sufficient) condition for the expression on the right side.

---

PARQ: Piccewise-Afline Regularized Quantization
42
q1
2/22 an)
A N/
(92
②1)
1
01)
43
93
42
91
91
10+ Aao
th+ unx
db 1
ab 30x
sb Eox
24
1111 Loy
1
3b 11 20x
171 tox
1b
sb
Figure 6. Graph of prox nA (u).
Figure 7, Graph of y (u) with scaled input.
3. The AProx Algorithm
where 7/2 = E 7/- Here prox Av is called an aggre- gate map because X is scaled by the aggregate step size ", In fact, BinaryConned ing the indicator function of Qd given in (5). The indicator function and its proximal map (Figure 1) is invariant under arbitrary scaling, thus hiding the subtlety of aggregation.
The regularization structure of problem (4) can be well exploited by the proximal gradient method
a special case of AProx with v be-
w ++1 = n (w' 1/1 (ww)))
(8)
where x is the proximal map of the scaled function "): V.. Since y effectively scales the slopes [a=] (with
The graph of prox can be obtained by replacing T in Figure 6 with 7t. However, according to (10), we have
Q fixed), we obtain ,v by simply replacing 0g (7) with a,aa and the corresponding map is shown in Figure 6.
Yt E. ?/ - +00;
If f' is convex and V is L-Lipschitz continuous, then using the constant step size = L/L leads to a convergence rate of O(1/t) (e.g., Wright & Recht, 2022, Theorem 9.6).
which implies that the flat segments in the graph, now with lengths >xx(a ak-1), 1), grow larger and larger, which is opposite the Prox-SGD method. (In both cases, the sloped 1k-1-)
In the context of machine learning, we minimize the ex- pected loss over a large amount of data, i.e., f(w)
segments has fixed length qu-
E, (ww, z)]. The Prox-SGD method replaces f(((")
For the ease of visualization, we rescale the input by 7h" and obtain the graph in Figure 7. this scaled graph, the lengths of the flat segments A(ax - ak-1) stay constant but the sloped segments, with lengths % 7--0(p (qk 9k-1), shrink 7t increases. Asymptotically, as 7 - cc, the graph converges to hard quantization, shown in Figure 8.
in (8) with the stochastic gradient g' : [wf(w", ([("("""" 2²):
w +++ ,rox (w' (w"-n:g"))
(9)
However, it is well known that for the (proximal) SGD method to converge, we need diminishing and non- summable step sizes (e.g., Robbins & Monro, 1951), i.e.
3.1. AProx versus Prox-SGD and ProxConnect
1)t 0 and
E Th = to0.
(10)
To better understand the difference between AProx and Prox-SGD, we rewrite Prox-SGD in (9) as
In this case, the flat segments on the graph Aw as shown in Figure 6, with lengths n)a(ax - ag-1), will all shrink zero when T 0 (except the ends because am +oo). Therefore, the graph converges to the identity map clipped flat outside of [-9m, +ym] and we lose the action of quantization. This issue parallels that of using Prox-SGD with L Ie-reuularization, which does not produce sparse solutions because of the shrinking deadzone in the soft- softtthresholdig operator as 17 0 (Xiao, 2010).
a ,+ = =w' - Thg w c+1 = =prox xx
(12)
which differ from AProx in (11) in two places (highlighted in blue). Here we give an intuitive interpretation of these differences. First, notice that the objective in (4) is the sum of f and AW,, and both methods make progress by using the stochastic gradient of (forward step) and the proximal map of X (backward step) - a balanced manner.
To overcome the problem of diminishing regularization, propose AProx, an aggregate proximal stochastic gradient method. Aprox shares a similar form with BinaryConnect (Courbariaux et al., 2015). Specifically, it replaces the hard- quantization Q(-) in (3) with an aggregate proximal map:
In Prox-SGD, n c+1 is combination of w and -ngg But w' already contains contributions from both f and AV, through (-n.9">:= and (prox, )==1 respectively. Therefore, from + to obtain w we should use prox, to balance -r).g.
n ++1 = n'g'
(11)
" prox (1,,
5

---

PARQ: Piccewise-Aflie Regularized Quantization
M(22 a1)
Algorithm PARQ
03
input: w E R number of quantization bits n, step sizes {Te { slope schedule (pr 11" Ji=1
91
Vi lu
initialize: 2 w
for = 2, .,,,. - do u²+1 = u'= Tt V ff(w", (ww,²*)) x²) Q++ LSBQ (t ++1 ..)
Xao A01 A02
w = pROXPARo (utt1 100
end for output: w"
Figure 8. Asymptotic scaled mapping y O.
For AProx, u1+ is used to accumulate Ei= 7,9", solely contributed from f. Thus in computing -+1 we need strike a balance with the contribution from Av with the aggregated strength "/- Σ. 1/s-
Theorem 3.1. Assume that f(w, 2) is convex in w for any z, v is convex, and Fx, is continuous with Lipschitz constant G. Also, let W be the set of minimizers of Fx(w). Then,
(a) If the stepsize TI satisfies (10) and {w, Y are gener- ated by algorithm (11), then the weighted average w² converges in expectation to a point in W*.
While the total contributions from the forward steps (-n.g") and backward steps (proxą²) are balanced in both cases, Prox-SGD spreads the backward steps on every iterate wi so the quantization effect on the last iterate eventually di- minishes. contrast, AProx always applies an aggregate proximal map to generate the last iterate, in order balance the accumulation of pure forward steps in u++1.
(b) Let w be an initial point. R = min eww 11 w and the step size
2G V then
E [[FX(T0'] - FF(w") & GR GR2+ (.1
Vi
The above interpretation highlights the importance of bal- ance between the forward and backward steps in minimizing the sum of ff and Av. With the flexibility of allowing any step size rule that satisfics (10), it can be considered as a more flexible variant, or generalization, of the regularized dual averaging (RDA) method of Xiao (2010).
where the expectation E||] is taken with respect to the sequence of random variables {w² ,..., w'}.
While convergence results on the averaged iterates wf are conventional in the stochastic optimization literature, they are far from satisfactory for QAT. In particular, the aver- aged iterates w' are most likely not quantized even if every iterate w" is quantized. Therefore, only the last iterate is meaningful for QAT in practice.
Dockhorn et al. (2021) used the regularization framework and proximal maps to interpret BinaryConnect/STY TE and developed a generalization called ProxConnect. It is de- rived from the generalized conditional gradient method (Yu et al., 2017), through the machinery of Maachel-Rockafellle duality. We derived AProx as an direct extension of RDA (Xiao, 2010), but realized that it is indeed equivalent to ProxConnect, with some minor differences in setting Y-- Nevertheless, our construction through balancing forward and backward steps provides a more intuitive understanding of the algorithm and may shed light on further development of structure-inducing optimization algorithms.
In general, last-iterate convergence of stochastic/online algo- rithms is crucial for regularized optimization problems aim- ing for a structured solution (such as sparsity and quantiza- tion). Here we establish last-iterate convergence of AProx.
Theorem 3.2 (Last-iterate convergence of AProx for convex optimization). Under the same assumptions as in Theo- rem I, the last iterate wi of AProx satisfies
E [Bx(w")] -F(==)x S GR 2+ I.5
Vt
3.2. Convergence Analysis
To simplify the presentation, we define
The proof of Theorem 3.2 provided Appendix A.2. We note that this convergence rate matches the average-iterate convergence rate established in Theorem 3.1.
(w(w)= == [. =)] + (w)
The following theorem concerns the convergence of AProx in terms of the weighted average v This result appeared in Dockhorn et al. (2021, Cor. 5.2.). We include it here as a basis for proving last-iterate convergence and give its proof in Appendix A.1 for completeness.
We note that AProx updates the variable u' with a simple SGD step. In practice, replacing it with more sophisticated methods such as Adam (Kingma & Ba, 2014) or Adam W (Loshchilov & Hutter, 2018) gives better performance. We leave their convergence analysis for future work.
Th E.= w.
6

---

PARQ: Piccewise-Afline Regularized Quantization
130
Table I. ResNet test accuracy on CIFAR-10. Full Full-precision (FP)
22 2.
91 4:92
accuracy is shown in parentheses under each model depth.
91
91
91
92
Depth
# bits
STE
BinaryRelax
PARQ
2
89.56 10.18
89.98 10.13
90.48
+0.26
20
T
90.94 10.15
91.25
#0.07
91.45 +0.11
2
91.22 10.15
91.57
10.066
91.71 1:003
(91.82)
91.84 10.22
91.77
10.05
91.97 1:004
91.93 10.04
91.92
100116
91.93 1.005
(a) prOxPARO (u, P)
(h) proxgiaal (1, P)
91.55 10.33
91.75
10.37
91.47 10.35
56
92.42 10.09
92.34
10.23
92.97 10.15
Figure 9. Proximal maps of PARQ and BinaryRelax.
92.72 10.27
92.30
10.40
92.77 10.10
(93.08)
3
92.73
#0.44
92.86 +0.40
92.86 +0.25
92.34 +0.23
92.59
+0.10
92.78 +0.30
4. PARQ: A Practical Implementation
A practical issue for implementing AProx with PAR is how to choose the PAR parameters {yx: ) and {ax k=o as well as the regularization strength x; see their roles in the proximal map in Figure 7. In particular, { are the tar- get quantization values for w and A and {ax} determine the quantization thresholds on the scaled input "'" In practice, it is very hard to choose these parameters priori for different models and datasets. Therefore, we propose heuristic approach to estimate the target values {m.} online and at the same time avoid setting X and } explicitly.
Once a set of (exact or approximate) solution {0,] obtained, the resulting quantization values can be written in the form =.j + Uu by choosing either + or between the adjacent operands. For example, the largest and smallest values in Q = ( (
qm are qm iu + ................................ + on and - 9m = U1 ... Un Since there are n binary bits, the total number of target values is | = 2
The selection of {ax} and À is somewhat arbitrary and not consequential. We can choose them so that the asymptotic graph in Figure 8 matches the hard-quantizationn map de- picted in Figure 1. That is, we can let λa (qx- + +k+1)/ but never really use them once Q is found by LSBQ.
Given a vector u' E R we need to quantize it (element- wise) to a vector w² E Qd where w/ E Q for = -,...... d. We use the least-squares binary quantization (LSBQ) ap- proach (Pouransari et al., 2020) to estimate the target quan- tization values in Q. LSBQ employs form of n-bit scaled binary quantization. Specifically, let
While in theory we require = =E- " - + in prac- tice Y does not become very large due to the finite number of iterations we run with diminishing step sizes. Therefore, its effect on scaling the horizontal axis in Figures 7 and 8 is limited and can be absorbed by tuning the step size. On the other hand, we would like the proximal map to be able to converge to nard-quantization by the end of training (so we have fully quantized solutions). For this purpose, we use an independent schedule for growing the slope of the slanted segments. Specifically, we emulate the proximal map in calculated
w. = Σド= (u.),
where the ry's satisfy 01 2 2 Pn 2 0 and each 8y R + 1] is binary function. The optimal {1y, ())) for approximating u E Rd in the least- squares sense can be found by solving the problem:
minimize (., subject to
E (w - Σj. 2)))
Figure 7 with the one in Figure 9(a), where from LSBQ, and p is the slope of the slanted segments. For convenience, we specify a schedule for the inverse slope pT to vary monotonically from 1 to O during T steps of training (so the slope Pt go to infinity). For example,
01 0 U2 2 Un 2 0,
85 R - (11,1), j=
For a= = (1-bit quantization), the solution is well-known:
11 ||u|li/d, and $1 (1:)) sgn(u:);
1
Pt
(13)
1 1 cxp (s(t t2)
see, e.g., Rastegari et al. (2016). Pouransari et al. (2020) derived the solutions for the n = case and the ternary case (n with 21 = U2). For n > 2. there is no closed-form solution, but Pouransari et al. (2020) gives simple greedy algorithm for foldable representations, which satisfy
where > Os the steepness parameter, and t is the tran- sition center (usually fı = T/2).. This schedule changes Pt roughly from I to 0, taking value 0.5 at the transition center 41 The steepness parameter controls how fast the transition from 1 to 0 happens, with larger corresponding to steeper transitions.
sy sy(u) = =sgn(u E r2s)(u)), j == I....,n. n.
This is the scheme that we adopt in PARQ.
Putting everything together, we have PARQ Algorithm 1.
7

---

PARQ: Piccewise-Afline Regularized Quantization
Table 2. Quantized ResNet-50 accuracy on ImageNet.
Table Quantized DeiT' test accuracy on ImageNet.
Depth
# bits
STE
BinaryRelax
PARQ
Size
# bits
STE
BinaryRelax
PARQ
1
66.17
10.04
66.14
10.28
66.71
10.13
51.62 10.18
52.62
10.03
55,43 1:023
50
T
70.94
10.19
71.59
10.11
71.45
10.11
Ti
61.43 10.08
62.18
10.11
62.32 10028
2
72.38
10.10
72.64
10.17
72.71
10.19
64.81 10.15
65.20
10.04
66.60 10.18
(75.60)
(71.91)
3
73.58 10009
74.02
10.09
73.94
10.10
69.02
10.11
69.26
10.03
69.60 10.22
4
74.52
+0.04
74.58 +0.04
74.83
#0.19
4
70.95 #0.11
71.06 +0.09
71.21 +0.11
70.07 10.03
70.69 100007
73.40 1:0.19
S
T
75.83 #0.06
76,02 +0.03
76.74 +0006
5. Experiments
77.40 10.01
77.43 +0.04
77.94 +0.04
(79.80)
79.02 #0.14
79.11 1:0007
79.04 +0.04
We train quantized convolutional and vision-transformer models using QAT on image classification tasks across five bit-widths: ternary (T) and 1-4 bits. For each model and bit-width pair, we compare PARQ with two existing QAT methods: STTE/BinarCConnet (Courbariaux al., 2015)
79.57 20.04
79.55
10012
79.61 +0.04
78.79 +0003
79.02 1:0.33
79.35 10.04
B
80,50 10001
80,61 1:0008
80.62 +0.01
80.73 10.17
80.81 10.14
80,97 +0.20
(81.7))
80.54 #0.20
80.94 #0.05
81.49 +0.13
80.45 10.10
80.76 10.12
81.60 +0.12
and BinaryRelax (Yin et al., 2018).
Specifically, STE/BinaryComnect uses the quantizaatittioon map in Figure 1, PARQ applies the proximal map in Fig- ure 9(a) with slope annealing, and BinaryRelax effectively uses the proximal map in Figure 9(b) where the slope of slanted segments gradually decreases O. We note that prOXpARo is the proximal map of a convex PAR, but STE and BiRe do not correspond to convex regularization.
5.3. DeiT on ImageNet
Applying QAT to a different architecture, we experiment with Data-efficient image Transformers (Touvron et al., 2021, DeiT). Our DeiT experiments include the Ti, S, and B model sizes with 5M, 22M, and 86M parameters, respec- tively. Attention block weights are quantized channel-wise as in Section 5.2. Embeddings, layer normalization parame- ters, and the final projection weights are left at full precision, following the setting of Rastegari et al. (2016).
Each entry in Tables 1-3 shows the mean and standard dev- iation of test accuracies over three randomly seeded runs.
5.1. ResNet on CIFAR-10
We use Adam (Loshchilov & Hutter, 2018) to train for 300 epochs with a 5c-4 learning rate and 0.05 weight decay. We hold the learning rate at 1e-8 for the final 20 epochs (af- ter PARQ and BinaryRelax converge to hard-quantization); this boosts performance relative to the default 1e-5 mini- mum. We apply Rand (Cubuk et al., 2020) and all prior regularization strategies (Zhang et al., 2018; Yun et al., 2019) except repeated augmentation (Berman et al., 2019).
We first evaluate quantized ResNet-20 and ResNet-56 (He et al., 2016) on CIFAR-10. All weights, including those in the final projection layer, are quantized. We train for 200 epochs using SGD with 0.9 momentum and 2e-4 weight decay. Following Zhu et al. (2022), the 0.1 learning rate decays by factor of 10 at epochs 80, 120, and 150.
As shown in Table 1, PARQ performs competitively to STE and BilaryRelax across all bit-widths. For 1-bit ResNet-20, it outperforms STE by nearly one accuracy point. It is the only QAT method for ternary ResNet-56 reaching within 0011 points of full-precision accuracy.
Table 3 reveals that PARQ's performance trends persist across model sizes. For 1-bit DeiT-Ti and DeiT-S, PARQ outperforms BinaryRelax by nearly three accuracy points. PARQ also achieves the best accuracy for ternary and and 2-bit DeiT-S, as well as 3- and 4-bit DeiT-B models.
5.2. ResNet on ImageNet
Figure 11 shows the training loss curves of three different QAT methods along with full precision (FP) training on the DeiT-Ti model. We observe that in the initial phase, PARQ elosely follows the FP curve because the slope of the slanted segments in its proximal map (Figure 9()) is close to 1. Then the training loss of PARQ increases due to the relatively sharp transition of the slope, and it follows the STE curve closely in the second half of the training process as its proximal map converges to hard quantization. The training curve of BinaryRelax has a more gradual transition.
For QAT of ResNet-50 (He et al., 2016) on ImageNet, we quantize all residual block weights per channel by comput- ing Q row-wise over tensors. We use SGD with 0.1 learning rate, 0.9 momentum, and 1 weight decay. The learning rate decays by factor of 10 every 30 epochs.
Similar to the experiments on CIFAR-10, PARQ performs capably against STE and BinaryRelax in Table 2. shows a slight advantage in the most restrictive 1-bit case, achieving a half- half-point margin over the other two methods.
8

---

PARQ: Piecewise-Aflie Regularized Quantization
epoch 6
epoch 150
epoch 300
0.2
0.1
-0.1
0.2
0.4
-0.2
0
0.2
0.4
0.4
-0.2
0.2
0.4
0.4
-0.2
0
0.2
0.4
u
u
Figure PARQ proximal maps during early, middle, and late stages of training 2-bit DeiT-Ti (value weights from an attention layer).
FP
STE
BinRel
PARQ
PARQ
Q1
Q2
train loss
0.1
Ammon " (ww - W H
50
100
150
200
250
300
epoch
Tx
0.5
Figure 12. Evolution of (41:42) estimated by LSBQ.
50
100
150
200
250
epoch
6. Conclusion
Figure Training loss curves for 2-bit DeiT-Ti model (top) and the P. schedule in (13) with 50 and & = 0.57.
We developed a novel optimization method for quantization- aware training (QAT) based the framework of convex, piecewise-affine regularization (PAR). In order to avoid the diminishing regularization effect of the standard proximal SGD method, we propose an aggregate proximal (AProx) algorithm. The asymptotic form AProx with PAR corre- sponds to hard quantization, thus giving principled inter- pretation of the straight- estimator (STE), which is widely successful heuristic for QAT.
Figure 10 gives snapshots of how PAR gradually induces quantization in model parameters: compare the middle stage plot with Figure 9(a) and the late stage plot with Figure Figure 12 shows the evolution of {91, 92) (estimated by LSBQ) during the training of 2-bit DeiT-Ti model. They from the same layer the used in Figure 10 and with the same weight initialization. It shows that both qı and start small from initialization, expand rapidly in the early stage training, then slowly contract in later epochs.
The convex regularization framework of PARQ allows the development of strong convergence guarantees. In partic- ular, for convex loss functions, we are able to prove last- iterate convergence of the AProx method. For future work, we are interested extending the convergence analysis for nonconvex loss functions, as well as for variants of AProx that incorporate stochastic momentum and diagonal scaling.
Our experiments demonstrate that PARQ achieves competi- tive performance compared with QAT methods that corre- spond using nonconvex regularization. Compared with using hard-quante sard-quantization (STE) throughout the training pro- cess, the gradual evolution of PARQ from piecewise-affin soft quantization to hard guantization helps the training pro- cess to be more stable, and often converges to better local minima. This more evident in the most demanding cases of low-bit quantization of smaller models.
We have focused on PAR an effective regularization in an optimization framework. It would also be very interesting to investigate its generalization capability in a statistical learning framework, which will help us better understand the tradeoff between model size and prediction performance.

---

PARQ: Piccewise-Affie Regularized Quantization
Impact Statement
Chen, G. and Teboulle, M. Convergence analysis of proximal-like minimization algorithm using Bregman functions. SIAM Journal Optimization, 3(3):538- 543, 1993. doi: 10. 1 10.1137/0800026.
This paper presents work whose goal is to advance the field of Machine Learning. There are many potential societal consequences of our work, none which we feel must be specifically highlighted here.
URL https:
/ 1. 1 /080302.
Courbariaux, M., Bengio, Y., and David, J.-P. BinaryCon- nect: Training deep neural networks with binary weights during propagations. In Advances Neural Informa- tion Processing Systems, volume 28, Montréal, Canada, December 2015.
References
Ajanthan, T., Gupta, K., Torr, P., Hartley, R., and Dokania, P. Mirror descent view for neural network quantization. In International Conference on Artificial Intelligence and PML- PMLR, 2021.
Statistics, pp. 2809-2817,
Cubuk, E. D., Zoph, B., Shlens, J., and Le, Q. V. Ran- dAugment: Practical automated data augmentation with reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 702-703, 2020.
Bai, H., Zhang, W., Hou, L., Shang. L., Jin, J., Jiang, X., Liu, Q.. Lyu, M., and King, I. BinaryBERT: Pushing the limit of BERT quantization. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 1th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pp. 4334- 4348, 2021.
Dettmers, T. and Zettlemoyer, L.. The case for 4-bit preci- sion: k-bit inference scaling laws. International Con- ference on Machine Learning, pp. 7750-7774. PMLR, 2023.
Bai, Y., Wang, Y.-X., and Liberty, E. ProxQuant: Quantized neural networks via proximal operators. In Proceedings of the 7th International Conference Learning Repre- sentations (ICLR), New Orleans, May 2019.
Dockhorn, T., Yu, Y., Sari, E., Zolnouri, M., and Partovi Nia. V. Demystifying and generalizing binaryconnect. Ad- vances in Neural Information Processing Systems, 34: 13202-13216, 2021.
Bengio, Y., Léonard, N., and Courville, A. Estimating or propagating gradients through stochastic neurons for conditional computation, August 2013. arXiv:1308.3432
Esser, S. K., McKinstry, J. L., Bablani, D., Appuswamy, R., and Modha, D. S. Learned step size quantization. In International Conference on Learning Representations (ICLR), 2019.
Berman, M., Jégou, H., Vedaldi, A., Kokkinos, I., and Douze, M. Multigrain: unified image embedding for classes and instances.
2019.
Fan, A., Stock, P., Graham, B., Grave, E., Gribonval, R., Jegou, H., and Joulin, A. Training with quantization noise for extreme model compression. In International Conference on Learning Representations (ICLR), 2021.
Boyd, S. and Vandenberghe, L. Convex optimization. Can- bridge University Press, 2004.
Bubeck, S. Convex optimization: Algorithms and complex- ity. Foundations and Trends@ in Machine Learning, 8 (3 (3-4):231-33) 2015.
Fournarakis, M., Nagel, M., Amjad, R. A., Bondarenko, Y., van Baalen, M., and Blankevoort, T. Quantizing neural networks. In Thiruvathukal, G. K., Lu, Y.-H., Kim, J., Chen, Y., and Chen, B. (eds.), Low-Power Computer Vision: Improve the Efficiency of Artificial Intelligence, chapter 11, pp. 235-272. CRC Press, 2022.
Cai, Y., Yao, Z.., Dong, Z., Gholami, A., Mahoney, M. W., and Keutzer, K. ZeroQ: A novel zero shot quantization framework. In Proceedings of the IEEE/CVF Conference on Computer Vision and Puttern Recognition, pp. 13169- 13178, 2020.
Gholami, A., Kim, S., Dong, Z., Yao, Z., Mahoney, M. W., and Keutzer, K. survey of quantization methods for ef- ficient neural network inference. In Thiruvathukal, G. K., Lu, Y.-H., Kim, J., Chen, Y., and Chen, B. (eds.), Low- Power Computer Vision: Improve the Efficiency of Arti- ficial Intelligence, chapter 13, pp. 291-326. CRC Press, 2022.
Carreira-Perpine Perpiiinn,,, M. Á. and Idelbayev, Y. Model compres- sion as constrained optimization, with application to neu- ral nets. Part II: Quantization, 2017. arXiv:1707.044 1707.007799199
Chee, J., Cai, Y.. Kuleshov, V., and De Sa, C. M. QulP: 2-bit quantization of large language models with guarantees. Advances in Neural Information Processing Systems, 36, 2024.
Han, S., Mao, H., and Dally, W. J. Deep compression: Compressing deep neural network with pruning, trained quantization and Huffman coding. In Proceedings of
10

---

PARQ: Piccewise-Aflie Regularized Quantization
the 4th International Conference on Learning Repre- sentations (ICLR), San Juan, Puerto Rico, 2016. URL attpp://arxai org/ httgg/bb//ae
Nesterov, Y. Introductory Lectures on Convex Optimization:
A Basic Course. Kluwer Academic Publishers, 2004.
Orabona, F. Last iterate of SGD converges (even in un- bounded domains), 2020. URL https::tppppattee terfree. tert/ee..com/0022///////////1211 f- E-sgdlconvvrrge--even-- wnwpreen-nnnnuuunneeeee omains/
Hastie, T., Tibshirani, R., and Friedman, J. The elements of statistical learning: data mining, inference and predic- tion. Springer, edition, 2009. URL httt:://www- tat. stanford. edu/ -tiss ElemStatLeart/
Pouransari, H., Tu, Z., and Tuzel, O. Least squares binary quantization of neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 698 699, 2020. URL ht tps /toi//oi..///////// org/ 11w.0..11111.11..111 00357.
He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learn- ing for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770-778, 2016.
2020.
Hubara, I., Courbariaux, M., Soudry, D., El-Yaniv, R., and Bengio, Y. Quantized neural networks: Training neu- ral networks with low precision weights and activations. Journal of Machine Learning Research, 18(187):1-30, 2018.
Qin, H., Gong, R., Liu, X., Shen, M., Wei, Z.,, Yu, F., and Song. J. Forward and backward information retention for accurate binary neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2250-2259, 2020.
Kingma, D. P. and Ba, J. Adam: A method for stochastic optimization, 2014. #iXiv:1412.6988
Qin, H., Ding, Y., Zhang, M., Yan, Q., Liu, A., Dang, Q..
Liu, Z., and Liu, X. BiBERT: Accurate fully binarized BERT. In Proceedings of International Conference on Learning Representations (ICLR), 2022.
Li, H., De, S., Xu, Z.. Studer, C., Samet, H., and Goldstein, T. Training quantized nets: A deeper understanding. In Advances in Neural Information Processing Systems, volume 31, pp. 2813-5823, 2017.
Rastegari, M., Ordonez, V., Redmon, J., and Farhadi, A. XNor-net: ImageNet classification using binary convo- lutional neural networks. In European Conference on Computer Vision, pp. 525-542. Springer, 2016.
Liu, Z., Oguz, B., Pappu, A., Xiao, L., Yih, S., Li, M., Krish- namoorthi, R., and Mehdad, Y. BiT: Robustly binarized multi-distilled transformer. In Koyejo, S., Mohamed, S., Agarwal, A., Belgrave, D., Cho, K., and Oh, A. (eds.), Advances in Neural Information Processing Systems, vol- ume 35, pp. 14303-14316. Curran Associates, Inc., 2022. URL https::tt//.oooc..tt /dl. acm. org /tgg/oi////ooooooooooooo////ooor abs / 10.000 55 55/3600270. 3601310.
Robbins, H. and Monro, S. A stochastic approximation method. The Annals of Mathematical Statistics, 22(3): 407, 1951.
Sze, V., Chen, Y.-H., Yang, T.-., and Emer, J. S. Efficient processing of deep neural networks: A tutorial and survey, Proceedings of the IEEE, (5(11)):225-2322) 2017.
Loshchilov, I. and Hutter, F. Decoupled weight decay reg- ularization. In International Conference on Learning Representations (ICLR), 2018
Touvron, H., Cord, M., Douze, M., Massa, F., Sablayrolles, A., and Jégou, H. Training data-efficient image transform- ers & distillation through attention. In International Con- ference on Machine Learning, pp. 10347-10357 PMLR, 2021.
Lu, Y., Yu, Y., X., and Partovi Nia, V. Understanding neural network binarization with forward and backward proximal quantizers. In Oh, A., Naumann, T., Globerson, A., Saenko, K., Hardt, M., and Levine, S.
Wright, S. J. and Recht, B. Optimization for Data Analysis. Cambridge University Press, Cambridge, 2022.
in Neural Information Processing Systems, volume 36, pp. 40468-40486. Curran Associates, Inc., 2023.
Xiao, L. Dual averaging methods for regularized stochastic learning and online optimization. Journal of Machine Learning Research, 11(88):2543-25%6 2010. URL ht html.
Martinez, B., Yang, J., Bulat, A., and Tzimiropoulos, G. Training binary neural networks with real-to- binary con- volutions. In International Conference on Learning Rep- resentations, 2019.
tp: jml
Yao, Z., Yazdani Aminabadi, R., Zhang, M., Wu, X., Li, C., and He, Y. ZeroQuant: Efficient and affordable post- training quantization for large-scale transformers. Ad- vances in Neural Information Processing Systems, 35: 27168-27183, 2022.
Nagel, M., Amjad, R. A., Van Baalen, M., Louizos, C., and Blankevoort, T. Up or down? Adaptive rounding for post-training quantization. In International Conference on Machine Learning, pp. 7197-7206. PMLR, 2020.

---

PARQ: Piccewise-Affine Regularized Quantization
Yin, P., Zhang, S., Lyu, J., Osher, S., Qi, Y., and Xin, J. BinaryRelax: A relaxation approach for training deep neural networks with quantized weights. SIAM Journal on Imaging Sciences. (1(4):205-2222) 2018. https///oi..or//1.. 111///000111111111 137/18M1 10MM1666111 14.
Yin, P., Lyu, J., Zhang, S., Osher, S. J., Qi, Y., and Xin, J. Understanding straight-through estimator in training activation quantized neural nets. In Proceedings of Inter- national Conference on Learning Representations (ICLR), 2019. URL ht https:: http::://pppeeeiieeeee ner/forum ?id=Skh4 jRCKQ.
Yu, Y. Zheng, X., Marchetti-Booickk M., and Xing, E. Minimizing Nonconvex Non-Separable Functions. In Lebanon, G. and Vishwanathan, S. V. N. (eds.), Pro- ceedings of the Eighteenth International Conference on Artificial Intelligence and Statistics, volume of Pro- ceedings of Machine Learning Research, pp. 1107-1115, San Diego, California, USA, 09-12 May 2015. PMLR. URL https:tt//tcmm btttps://proceedingg yu15. yu15.htm. html.
Yu, Y., Zhang, X., and Schuurmans, D. Generalized condi- tional gradient for sparse estimation. Journal of Machine Learning Research, 18(144): 2017. URL http: // //jmmr.. org/ http://pppsssl//// 14-344 html.
Yun, S., Han, D., Oh, S. Chun, S., Choe, J., and Yoo, Y. Cutmix: Regularization strategy to train strong clas- sifiers with localizable features. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 6023-6032, 2019.
Zhang, H., Cisse, M., Dauphin, Y. N., and Lopez-Paz, D. mixup: Beyond empirical risk minimization. In Proceed- ings of International Conference on Learning Represen- tations (ICLR), 2018.
Zhu, C., Han, S., Mao, H., and Dally, W. Trained ternary quantization. In International Conference Learning Representations, 2022.
12

---

PARQ: Piccewise-Aflie Regularized Quantization
A. Convergence analysis
A.1. Proof of Theorem 3.1
We consider the framework online convex optimization, which is more general than stochastic optimization. In particular, let ft f(, 24) be function presented to at each iteration 1,2...., and be regularization function that we use throughout the whole process. The two-step presentation of AProx in (11) can be written in one-step as
1 211 w w0
w
++
arg min
na (o .) + AV(W) +
(14)
WEW
where w the initial weight vector and gf fw("). Moreover, we use a more general distance generating function h to replace (1/2)]| I12, and define the Bregman divergence as
Du w) h(u) h(w) (Vh(w), w).
With Bregman divergence, a more general form of AProx can be written as
wh
arg min wEW
Σ (nolo" w) AV((w) + (oww.w?)
(15)
Assumption A.1. We make the following assumptions:
(a) Each loss function f. is convex and Lipschitz continuous with Lipschitz constant Gy-
(b) The regularizer & is convex and Lipschitz continuous with Lipschitz constant Gv-
(c) The function h is differentiable and strongly convex with convexity parameter p.
It follows from Assumption (c) that D2 (u, w) is strongly convex in w with convexity parameter p.
Theorem A.2 (Regret bound for AProx). Under Assumption A. for any w E R.d, it holds that
Σ no (Ja("))) + - xV(w)) (Gr )G
Σ 2n Dn(w,
(16)
P
Proof. We adapt the proof of Bubeck (2015, Theorem 4.3) by adding the regularizer and replacing the term h(w) h(w") with Dr(w w An advantage of this replacement is that we can use any initial point w while the proof in (Xiao, 2010; Bubeck, 2015) requires w arg min h(w).
Let w Rd be an arbitrary initial point and define (ww) = Du(w, wº). For t 2 1, define
ve( = Σ No (1g", w) + AV)(w) + DD(w, w)).
The AProx algorithm (15) can be expressed as, for t 2 0,
- = arg min (w))
Since (w, w²) is strongly convex in w with convexity parameter p. the same property holds for th for all t > 0. According to basic result on minimizing strongly convex functions (e.g., Chen & Teboulle, 1993, Lemma 3.2) and the fact that +++1 minimizes eit we have
the (1w S vlwww) [ 11
t= 0, 1,2......
(17)
From the definition of vh and 11,1, we have
six (w") the (11 = ri--1 1/- 1 (w0 + ne (e ,
w² w (V(ww) )v(w)+1))
(18)
13

---

PARQ: Piccewise-Afline Regularized Quantization
For the left-hand side of (18), we apply (17) obtain
マ 1 - =011 S ve(w") - she (1
P
2
For the first term the right-hand side of (18), we apply (17) again for die-1 1 to obtain
(w=)(w)) - 1/2 w -
-P
2 (1luet1 w w0'1?
For the second term the right-hamd hand side of (18), we have
gg' - w aof-w(+l + AW - \ $ 1/ wht - w0ll + AV (1
I GGyll || - ww'll + +xG //G///////11 w'll
(Gy AGv)ll ww'l,
(19)
where in the first inequality we used Hölder's inequality, and in the second inequality we used Assumptions A. (a) and A. ((b) respectively. Combining the above three incqualities with (18), we get
pl|u*+1 w²112 S ne GG, + AGv)llu w²ll
which further implies
11 - 1 w'll S nn AGv)/p.
Combining this with (19) yields
(g', w - wt+t) + (w (V S + >²
(20)
Next we prove that the following inequality holds for all w E Rd and all L 2 0:
Σ Eno(to" w (v
no (10 + AV))) (nw,,") w
(21)
We proceed by induction. For the base case t = 0, the desired inequality becomes D2, (w,, wº) 2 0. which is always true by the definition of Dr. Now we suppose (21) holds for L - 1 and apply it with = w(+1 in the first inequality below:
no (60 w w + (v(
nh (l00, (V(()))) + n (1g", w(t1) + (V(
no , + (l + (10t1 "0 + ni (lg', w(th + X (W
no w + +X + w
The ("g"", + (W)))) + Dn(w, V.EW.
In the last inequality above, we recognized the definition of th and used the fact that w++1 is the minimizer of th. This finishes the proof of (21).
Finally we add Ei= 41 (192, w*) + V(w))) to both sides of (21) and rearrange terms to obtain
no (19", w² w) w) + XV((")) (V(w)) no (19", w" w (V(w")) xv( + Du(w, (22)
14

---

PARQ: Piccewise-Aflie Regularized Quantization
For the left-hand side of (22), use convexity of fa obtain
fa(w") )- fa(w) S ( - w).
For the right-hand side of (22), we apply (20) to obtain
(G, + )G
Σ (n :" - w + (V((") (1)
p
8=1
Combining the above three inequalities together, have
+ - AV(w)) - (GG + +G )2
Σ na (
Σ
1/ + Dn(w, w²)
P
This finishes the proof of Theorem A.2.
Now we consider the stochastic optimization problem minimizing f(w) + (V where the loss function f(w) := E, [sw, =)]. We can regard the sequence of loss functions Je in the online optimization setting as f(,,=² and compare with w² arg min f(w) + (w) this case, the regret bound (16) becomes
XV((")) - f(w", -NV(")) < (Gy + AG+)
Σ
Σ n Da w.).
P
Using standard online-to-stochaste conversion argument (e.g., Xiao, 2010, Theorem 3), derive
Σ Ne [E[f(w") + (w)()) - f(ww) xV(ww)) - (G, + AG
t
m + Du w
(23)
8=1
where the expectation E|: is taken with respect the random variables {w ..... wt), which in turn depends on 2'').
For the ease of presentation, we denote 1² min Da(w, w.). Moreover, we define a weighted average of all iterates up to iteration t
w
Σ now.
c saml
1/a
Then by convexity f and V, we obtain
[Gr+AGo]
D 2am1 112 + R82
E[f(w') + AV(( - f(w=)) - (M
(24)
> 17s
Constant stepsize. If the total number of iterations i' known ahead of time, then we can choose an optimal constant stepsize. Let 1/s- = for I,...,22 T. then the bound (24) becomes
(G, (Go+) Tnp + R
(G, - XG
2 + Tn
R²
Tn
In order to minimize the above bound, we take 17 Gs+hGu V H and obtain
R
T
E[f(w") + AV - f(w)) - ANP(w+)) & 2(G, +G
PT
15

---

PARQ: Piccewise-Aflie Regularized Quantization
Diminishing stepsize. The right-hand side of (24) has the same form as the convergence rate bound for the classical stochastic gradient subgradient method (e.g.. Nesterov, 2004, Section 3.2.3). A classical sufficient condition for convergence is
8 7 +00,
2 1s
< +00.
II In particular, if we take 2(G)+)Go))
8 we have
Eff(m') AA - f(w") xV((w)) S (G)+ R (2 + 1.5 1.5l)(t))
Vpt
Finally, Theorem 3.1 obtained with some simplification. In particular, we choose the Bregman divergence as the Euclidean distance 21l I|g, then have p 1. This leads
[[f(w')+ + (m f(w") (V((w)) & GR (2 (2+1.) 121.5t((t)
Vt
where = G + XG This completes the proof.
A.2. Proof of Theorem 3.2
For simplicity, we denote Px (x ((w) (V(w) and = GG + XG where Gy and Gy are the Lipschitz constants of and V, respectively.
To establish the last-iterate convergence of AProx, first introduce the following lemma, which connects the convergence of the last iteration to the convergence of the average iteration.
Lemma A.3 (Lemma in (Orabona, 2020)). Given that (n ) is a non-increasing positive sequence and {4:) is nonegattve sequence, the following inequality holds
T
T-1
T
UT &
The
+
Σ
Σ
Me (4:
uw)
(25)
kikk + 1)
I=
Upon setting q. E[AA(w")] - (w=) in Lemma A.3, we derive that
V/T EE [Fx]]]]] Fx(1))) S
Σ Tt E [Fx(w=)] Fx(w"))
(26)
T
T
Σ (=T-k+1
m [F2(w') Px(===k)]
+
k(k +
For the first term on the right-hand side, we apply Equation 23, which yields
G
Da(w", w
The ( [E[()(w)] - Fx(w"))
m
2
+
(27)
PT
T
t=1
1=1
To control the second term, we note that for any 1 1 5 --
T
T
G2
ThE (Fx(") - Fx(w
Σ
E E Fx(w*) - Fx (w
Σ
nh
(28)
I=T
t=T
t=T-k
Here we apply Equation 23 again for the last inequality upon setting w nT T- and use the fact that Dr w) = 0 for all w E W.
Combining the above two components together, we have
G²
T-1
T
Dn Dnww", w)
E [F)(T)) - Fx(w") <
m
+
(29)
TrP
k(k
+ 1)
k=
t= kk
16

---

PARQ: Piccewise-Affie Regularized Quantization
Constant stepsize. If the total number of iterations i' known ahead of time, then we can choose optimal constant stepsize. Let l/2 17 for all 1,...,? T, then the bound in (29) becomes
G² 1+ E [Fx(w")] Fx(w")) S
n Da(w", w²)
G² (2+1In(T)) Da(w", w²)
(30)
P
1/T
P
1/T
k=1
Here we use the fact that Σk= t S + In(n) for all 2 1. In order to minimize the above bound, we take os
t V [wo 30 and obtain (2+l(TT))2
Du(w", w (2 + In(T)) pT
E [x(w")] Fx(w") s 201
(31)
Diminishing stepsize.
Suppose set the stepsize 1/p
Then, Equation 29 reduces to
Vt
E ( TVT
T
Da(w", wo)
Σ
Σ
+
P
T
1)
nvT
1=1
t=T-k
(32)
NTTG
| (1+1n(T)
(n(
r-1 1
T
1
Du(w", w0)
+
P
T
k(k + 1)
t
nvT
T=
To proceed, note that
Σ
T
T
1
dt
in
T in
1
k
$
k
(33)
T t
T
T -
k
T
t=T k+1
Therefore, we have
T
Σ
1
-
ke
+ 1)
k(k 11
T- k
t=T
(=T-k+1
(34)
T(T-k)
KT
< + IT)
T
Invoking this result into Equation 32, we further have
E [x(")) FX(w") < 3nG (1 + In(T))
Du(w", w0) n/T
(35)
PVT
Hence, upon setting y = @V Dr wp we derive that
3 2 in(T))
V Du(w w0)
E [[X(w=)] ) - Fx(w") S FX
(36)
V2
pf
Specifically, if we choose the Bregman divergence as the Fuclidean distance R = mw I|l0 1|2, we have
| 1|2, then we have p = Upon defining
[Fx(W=]]] Fx(w)) S GR (2 + " In(T))
(37)
VT
17

---

PARQ: Piecewise-Aflne Regularized Quantization
1-bit
Temary
2-bit
80
test accuracy
70
60
50
40
STE
BinRel
PARQ
5
train loss
4.5
4
3.5
0.5
0
50
100
150
200
250
epoch
Figure 13. DeiT-S test accuracy (top row) and train loss (middle row) across several bit-widths (columns). All PARQ curves use p- schedule with s and fı = 0.57 (bottom row).
B. Additional experiment results
Figures 13-14 present accuracy and training loss curves for QAT of DeiT-S. In particular, Figure 13 uses = 1, which is essentially linear during the annealing period. The 1-bit accuracy plots reveal that PARQ trains more stably than STE and BinaryRelax; it does not exhibit any sudden drops in accuracy. performs the most consistently on DeiT-S, suggesting the relative performance of QAT methods may vary by model size.
Ablation study on pT Table 4 shows results of 2-bit DeiT-Ti on ImageNet, trained using different s (rows) and t (columns) values in Equation (13). This sweep reveals that a shallow performs best for the model and dataset setup. later transition center of t 0.75T performs noticeably better for steepness values {10,20) 203.
Table Ablation of parameters in (13) on 2-bit DeiT- Ti test accuracy.
The only option for i is 0.51' for 1 since P. decays linearly.
t
0.25T
0.5T
0.75T
66.60
10
64.11
64.62
66.02
20
63.74
63.88
66.17
64.05
63.89
63,89
64.06
64.28
63.73
18

---

PARQ: Piccewise-Affie Regularized Quantization
1-bit
Ternay
2-bit
80
Test accuracy
70
60
50
40
STE
BinRel
PARQ
5
train loss
4.5
3.5
0.5
0
50
100
150
200
250
epoch
Figure 14. DeiT-S test accuracy (top row) and train loss (middle row) across several bit-widths (columns). All PARQ curves use schedule with 50 and 0.57 (bottom row).
19


Reviews:
[{"review_id": "rCh6wUnmcS", "reviewer": "Reviewer_DkcD", "summary": "This paper presents a principled QAT method PARQ via convex piecewise-affine regularization (PAR). The authors examine that PAR can induce network weights to approach discrete values. Then, the paper proposes an aggregate proximal stochastic gradient method (AProx) and theoretically demonstrates its last-iterate convergence. Experiments conducted on convolutional and transformer-based models show the effectiveness of the proposed method  across five bit-widths.\n\n## update after rebuttal\nI have read the authors' rebuttal and **maintain my assessment and score** for this paper. On one hand, the authors' ​​design of convex regularization is​​ relatively novel, so **I am inclined to accept it**. On the other hand, ​​their experiments suggest that convex regularization may have limited effectiveness for non-convex deep learning loss functions, and thus it still fails to address the generalization issue in high-bit settings.​​ I acknowledge that the performances of STE and PARQ can be similar, ​​as​​ the authors ​derive​​ a generalized form of the heuristic method through theoretical analysis. However, I hope the authors can include more discussion in the final version and focus on the generalization issues of regularization in their​​ research.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for recognizing our main contributions on convex regularization for inducing quantization and the AProx method with last-iterate convergence. Our response will focus on the experiment results and analysis. \n\nWe agree that we can make the discussion on experiments more comprehensive, especially with the one extra page allowed for the final version. In particular, we should emphasize that the main goal of our experiments is to demonstrate that PARQ obtains competitive performance, not necessarily always better than existing approaches such as STE or BinaryRelax (for which we provide novel, principled interpretation). There are several aspects to discuss: \n* The experiment results presented are in TEST accuracy, following the convention of the ML community. We developed PARQ as a rigorous optimization/training framework for QAT, but our work does not yet address the generalization capability of the regularization, which is an interesting topic that we aim to investigate in future work.   \n* The final training losses for different algorithms are also very close, see Figures 10 and 12. Even for training loss, it is hard to guarantee that PARQ is always better than others due to the nonconvex loss functions in deep learning – the results depend on the random initializations and random mini-batches in training. Our convergence guarantees are developed for convex losses, which also imply similar behaviors around a local minimum in the nonconvex case, but in general cannot guarantee a better local minimum. Many relative comparisons in the Tables are statistically insignificant, especially given the small number of runs with random seeds. \n* On the other hand, similar performances of STE and PARQ is somewhat expected, as STE can be interpreted as the asymptotic form of PARQ. We are not contrasting two drastically different approaches, rather to argue that the one with a sound principle is as good as the widely successful heuristic (but the principled approach enables guided further investigation). Similarly, BinaryRelax uses a similar proxmap as for PARQ (see Figure 9), but does not correspond to convex PAR (hence less theory support).\n* We mainly commented on the very-low-bit cases (1 bit or ternary) due to the observed, relatively large, half-point improvements. The low-bit cases have much less freedom compared with more bits so it may be relatively easier to reveal differences between different local minima. The gradual evolution of PARQ from piecewise-affine soft quantization to hard quantization may help the training process to be more stable and more likely to converge to better local minima (See our comments in Section 6). Again there is no guarantee that this happens for every model we try (especially with a small number of trials).\n\nWe agree that our experiment comparisons are limited. However, it is not our intent to give a comprehensive comparison against many recent QAT methods, as many recent methods integrate with small additional tweaks beyond the fundamental ideas in order to boost empirical performance, and it can be unfair if we do not equip every method with similar bells and whistles. We limit our comparison to BinaryConnect (STE) and BinaryRelax because they have direct connections with our method as explained above. In addition, STE is still the de facto standard in practice despite many new methods and variations proposed.\n\n* On \"why the best results under each setting in Tables 1-3 are not all highlighted in bold\"? We only highlight the best results that look to be statistically significant, meaning the difference between the means are apparently larger than their standard deviations. \n\nAnswers to Questions for Authors:\n\n* For Questions 1 and 2, please see our itemized explanations/discussions above. In addition, we conjecture that more bit-widths and more complex networks may have the advantage of being over-parametrized, leading to very small differences between the local minima found by different methods. \n\n* For Question 3, ProxQuant (Bai et al. 2018) proposed to use the W-shaped regularizer (nonconvex) and indeed use the Prox-SGD method. As we explain in Section 3, Prox-SGD will NOT produce a meaningful quantization effect as training evolves over time ($t\\to\\infty$). In order to fix this empirically, as described in their implementation, the regularization parameter $\\lambda$ is changed to be growing linearly $\\lambda_t = \\lambda \\cdot t$, without principle/theory justification. It turns out that it is consistent with our AProx algorithms, where an increasing regularization strength should be applied according to our theory. Then their actual implemented algorithm is similar to PARQ, except that they use a nonconvex PAR of W-shaped. So in the end, it is more close to BinaryRelax, which we included in our experiments.", "claims_and_evidence": "The paper's arguments regarding nonsmoothness and convexity are well-founded and reasonable.", "methods_and_evaluation_criteria": "The algorithms proposed in the paper are well-justified, and the evaluation conducted across multiple datasets for two types of models (convolutional and transformer-based) effectively reflects the models' performance.", "theoretical_claims": "The authors provide a comprehensive proof for Theorems 3.1 and 3.2. I believe the last-iterate convergence of AProx is well-justified.", "experimental_designs_or_analyses": "1. In the experimental analyses, the authors' discussion is not comprehensive, as it primarily emphasizes the performance advantages of the 1-bit case. However, in my view, the performance of PARQ tends to degrade in experiments with more than 1 bit. For instance, in the case of 4-bit ResNet-20, PARQ exhibits a noticeable decline in accuracy. Moreover, PARQ does not achieve the best performance for more complex network. Specifically, for 1-bit ResNet-56, PARQ demonstrates the lowest accuracy and the highest standard deviation.\n\n2. The authors lack comparisons with more recent methods, as the current analysis is limited to BinaryConnect (2015) and BinaryRelax (2018). There are several other quantization methods related to the proximal gradient method, such as Proxquant[1] and BNN++[2]. While the authors emphasize the superior performance of PARQ in the 1-bit setting, it would be more clear to include comparisons with additional methods.\n\nReference\n[1] Bai, Yu, Yu-Xiang Wang, and Edo Liberty. \"Proxquant: Quantized neural networks via proximal operators.\" arXiv preprint arXiv:1810.00861 (2018).\n[2] Lu, Yiwei, et al. \"Understanding neural network binarization with forward and backward proximal quantizers.\" Advances in Neural Information Processing Systems 36 (2023).", "relation_to_broader_scientific_literature": "The paper presents an extension of the proximal gradient method, which ensures discreteness and last-iterate convergence by introducing convex piecewise-affine regularization (PAR) and the aggregate proximal stochastic gradient method (AProx). The authors also emphasize that AProx is equivalent to ProxConnect, and the straight-through estimator (STE) can be regarded as the asymptotic form of PARQ.", "essential_references_not_discussed": "N/A", "other_strengths_and_weaknesses": "This paper primarily introduces a convex regularizer that ensures discrete values and proposes an aggregate proximal map to guarantee last-iterate convergence. In my opinion, the authors' motivation and analysis for these two innovative contributions are clear and well-articulated. They effectively highlight the similarities and differences with ProxConnect, offering a distinct perspective on the problem.", "other_comments_or_suggestions": "Is there a specific reason why the best results under each setting in Tables 1-3 are not all highlighted in bold?", "questions_for_authors": "1. Could the authors please clarify and analyze why PARQ exhibits suboptimal performance at higher bit-widths?\n2. Could the authors please clarify and analyze why PARQ demonstrates suboptimal performance in more complex networks, such as ResNet-50?\n3. In Section 3.1, the title references ProxQuant, but the paragraph lacks any description or comparison related to it. Could the authors revise this section to include relevant details (does ProxQuant utilize Prox-SGD) ?", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "hajRyiHFN3", "reviewer": "Reviewer_Labs", "summary": "The paper proposes PARQ, a convex piecewise-affine regularization method for quantization-aware training. It introduces the AProx algorithm that transitions from soft to hard quantization, interprets STE as its asymptotic case, and proves last-iterate convergence.\n\n## update after rebuttal\n\nI confirm that I have read the author response, and would like to keep my score.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for recognizing our paper’s contributions in advancing QAT by bridging gaps between heuristic approaches and theoretical foundations. We address the reviewers comments and questions as follows:\n\n1. “The baselines in the experiment are too old. Why is PARQ not compared with newer methods such as AdaRound[1] or N2UQ[2]?”\n\n* The baselines we use are indeed some of the early works on QAT, especially BinaryConnet/STE, which is still the de facto standard in practice. Most recent works are extensions of BinaryConnect in different ways, relying on the fundamental interpretation of “Straight-Through Estimator.” As we explained in Section 1.1, STE is a misconception we try to correct through the convex PAR framework, and we provide a more principled interpretation to it.\n* As QAT attracts more attention in recent years, there are tens of new methods proposed and published including AdaRound and N2UQ. Comprehensive comparison with recent QAT methods is not our intent in this paper, as most recent methods integrate various small additional tweaks beyond the fundamental ideas in order to boost empirical performance. And it can be unfair if we do not equip every method with similar bells and whistles. For example:\n  - N2UQ (Nonuniform-to-Uniform Quantization) introduces a particular nonuniform quantizer, it is an alternative scheme for LSBQ we use to generate the quantization targets $Q= \\\\{ q_1,...,q_m \\\\}$, which is independent of the PAR and AProx algorithm. We can replace LSBQ in PARQ (Algorithm 1) with N2UQ and reapply the rest (PAR and AProx) to test the performance, but the results are not indicative of what we care most about the effectiveness of PAR or AProx.   \n  - AdaRound is actually a PTQ (post-training quantization) method, in a quite different category of QAT, see our remarks in Section 1 (second paragraph starting on Lines 39).    \n\n* Among the QAT methods beyond BinaryConnect/STE, we choose to compare with BinaryRelax because it follows a similar proximal gradient approach, and the proximal map is also piecewise affine but corresponding to nonconvex regularization as shown in Figure 9(b). See also the third bullet point in our response to Reviewer DkcD's comments.\n\n2. “Can PARQ be applied to large language models? For example, the llama Family?”\n\n* Yes, PARQ is a generic method that can be applied to train any machine learning models, including LLMs. We will try to include experiments on training a (relatively small) Llama model in the final version to demonstrate its applicability.  \n\n3. “Reiterate the greatest contribution of PARQ.” \n\n* Our main contributions include:\nIntroducing a class of convex, piece-affine regularizations (PAR) that can effectively induce weight quantization;\nDeveloped an aggregate proximal gradient (AProx) method and proved its last-iterate convergence (first of its kind);\nProvides a principled interpretation of the widely successful heuristic of STE.\nIn summary, we developed a principled approach for QAT, “bridging the gaps between heuristic approaches and theoretical foundations.” \n\nAgain, as we state in the paper, the main goal of our experiments is to demonstrate that PARQ has competitive (not necessarily superior) performance against the de facto standard of BinaryConnect/STE. Indeed they become essentially the same algorithm if run for a long time, thanks to our theoretical connection. A comprehensive performance benchmark against recent QAT methods is beyond the scope of this paper, which requires taking care of many additional nuances for a fair comparison.", "claims_and_evidence": "Yes.", "methods_and_evaluation_criteria": "Yes.", "theoretical_claims": "Yes. For more details, please refer to \"Other Strengths And Weaknesses\".", "experimental_designs_or_analyses": "Yes. For more details, please refer to \"Other Strengths And Weaknesses\"", "relation_to_broader_scientific_literature": "The paper's key contributions advance quantization-aware training (QAT) by proposing a principled method using convex, piecewise-affine regularization (PAR). This builds on prior work using regularization for quantization (e.g., L1 regularization for sparsity) and proximal gradient methods. It also provides a new interpretation of the widely-used straight-through estimator (STE) as an asymptotic form of their method, bridging gaps between heuristic approaches and theoretical foundations.", "essential_references_not_discussed": "No essential missing citations.", "other_strengths_and_weaknesses": "Strengths:\n\n1. Principled and Theoretical Foundation: Proposes a principled QAT method with convex regularization and proves last-iterate convergence.\n2. Practical and Competitive Performance: Achieves competitive results on low-bit quantization and adaptively selects quantization values.\n\nWeaknesses:\n\n1. The baselines in the experiment are too old. Why is PARQ not compared with newer methods such as AdaRound[1] or N2UQ[2]?\n2. Can PARQ be applied to large language models? For example, the llama Family?\n3. Judging from the experimental results, the advantage of PARQ is not that great. Could the author reiterate the greatest contribution of PARQ?\n\n[1]Nonuniform-to-Uniform Quantization: Towards Accurate Quantization via  Generalized Straight-Through Estimation\n\n[2]Up or Down? Adaptive Rounding for Post-Training Quantization", "other_comments_or_suggestions": "No.", "questions_for_authors": "See \"Strengths And Weaknesses\".", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "W8yBwIZWJH", "reviewer": "Reviewer_eR92", "summary": "they contribute a new QAT quantizer, specially optimize PAR-regularized loss functions using an aggregate proximal stochastic gradient method (AProx) and prove that it enjoys last-iterate convergence.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for recognizing our main contribution on the PAR regularization, the AProx method and proving its last-iterate convergence. We will work on better readability in revising the paper as suggested by the reviewer. Here are answers to the reviewer’s questions. \n1. Line 160 the definition of $\\text{dist}(w, Q^d)$ is $\\text{dist}(w, Q^d)=\\min_{v\\in Q^d}||w-v||_2^2$, which appears in line 153.\n2. We will add relevant fundamentals on quantization, especially on previous work using piecewise affine functions. \n  - ProxQuant introduced W-shaped regularization, which is piecewise affine but nonconvex, so it is hard to establish interesting convergence properties. \n  - Several other methods (including BinaryRelax) can be reformulated with equivalent piecewise affine regularizations, but the authors did not recognize the connection. In particular, the BinaryRelax equivalently uses the proximal map in Figure 9(b), which corresponds to a nonconvex piecewise affine regularization. \n  - Dockhorn et al (2021) focused on the piecewise affine proximal maps and made the connection with piecewise affine regularizations (PARs). But they did not realize that there exists a class of convex PARs that can lead to much stronger convergence guarantees (which is one of the main contributions of our paper).   \n\n3. We appreciate the reviewer’s comment regarding the regularization overhead. In our method, the regularization overhead is negligible compared to the cost of gradient computation. Specifically, in AProx, the additional computation arises from the proximal update described in Equation (11). However, this update leverages an explicit proximal mapping, as shown in Equation (7), which can be evaluated efficiently. In the practical implementation (PARQ), we apply LSBQ to determine quantization values by solving a constrained least-squares problem. It is important to note that this step is common across many QAT algorithms and therefore does not introduce any additional overhead specific to our method.\n\n4. We thank the reviewer for suggesting to incorporate other quantization schemes such as LSQ+. We agree that adaptive schemes such as LSQ (Learned Step Size Quantization) and the LSQ+ extension provide more flexibility in using trainable quantization scale and offset parameters. It’s possible to replace LSBQ used in PARQ with LSQ+ for potential performance improvement, which does not impact the convex PAR theory and AProx algorithms convergence properties. \n\nWe will incorporate some of the above discussions in preparing for the final submission.", "claims_and_evidence": "convincing", "methods_and_evaluation_criteria": "make sense", "theoretical_claims": "theoretical correctness", "experimental_designs_or_analyses": "experiment soundness.", "relation_to_broader_scientific_literature": "Lack some QAT quantizer", "essential_references_not_discussed": "Lack some QAT quantizer", "other_strengths_and_weaknesses": "This article is interesting enough, but the readability needs improvement. Some formulas lack numbers and need to be supplemented with variable explanations after the formulas.", "other_comments_or_suggestions": "Since most of the current methods are STE for QAT, the current comparative experiments are reasonable, but may not be sufficient.", "questions_for_authors": "1. line 160, dist(w, Q^d) need further explanation.\n2. Readability needs to be enhanced and relevant fundamentals in the field of quantization need to be supplemented, including the previous work introduced piecewise affine.\n3. The regularization overhead needs to be discussed.\n4. Although most existing methods use STE, I hope the authors will consider improved versions such as LSQ+.", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "kFcrglclzf", "reviewer": "Reviewer_kqiu", "summary": "This paper proposed PARQ, a convex, piecewise-affine regularizer (PAR) for training the weights to cluster to a set of quantization points. Also, a practical implementation called PARQ is introduced. Overall, this paper has sufficient motivation, clear writing, grounded citations, and experiment enough to demonstrate their method's effectiveness.\n\n## update after rebuttal\n\nI don't have any further opinions.", "questions": "", "limitations": "", "rating": 4, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for the overall positive feedback to our paper and especially recognizing our main novelty and contributions. Here we mainly address the reviewer’s question on the regularization approach proposed in the following reference, which we call Ref [1] hereafter. \n\n[1] Towards Accurate Network Quantization with Equivalent Smooth Regularizer, ECCV2022\n\nRef [1] proposes smoother regularizers for inducing quantization, more specifically, of sinusoidal shape. It is clearly based on the intuition that such regularizers can help trap the weights to clusters close to a set of (evenly spaced) discrete values. This is similar to using W-shaped regularizers (which are nonsmooth) but with smooth functions in order to have a unique gradient in optimization. Unfortunately, such functions violate both properties we desired for a good regularizer for quantization: nonsmoothness and convexity (see the two paragraphs starting from Line 157 in our paper). More specifically,\n* Smooth curves like sinusoid can trap weights into separate clusters, but does not induce quantization (i.e., concentrate on discrete values). This is due to the fact that locally near the local minima, the sinusoid behaves like the squared Euclidean norm, being flat thus does not induce quantization. In contrast, nonsmooth regularizers such as $L_1$ or W-shaped or PAR are locally sharp and thus can force the weights to concentrate at the local minima. As a result, Ref[1] still needs to use additional rounding or STE steps in order to obtain discrete quantized values. \n* Convexity gives better global properties that help to avoid local minima, which explains the popularity of $L_1$ regularization over nonconvex regularizers. Without convexity (such as W-shaped regularizer), it is very hard to establish any interesting convergence theory as we do in our paper. \n\nIndeed, in the intersection of nonsmoothness and convexity, piece-wise affine function looks to be the only sensible choice. Also notice that using proximal-update of nonsmooth regularizers (instead of gradient update) avoids any problem due to the non-uniqueness of their (sub-)gradients, which is the main motivation to address with smooth regularizers by Ref[1].\n\nFinally, we agree with the reviewer that adding appropriate guidance (explaining the purpose of each section at their beginnings) will make the paper easier to read. We will be able to add them in the final paper with one extra page allowed for the main text.", "claims_and_evidence": "I believe this paper's claims is supported by sufficient evidence.", "methods_and_evaluation_criteria": "Yes.", "theoretical_claims": "No. These mathematical proofs are beyond my expertise. Thus, I only give my rating based on some reason based on some reason such as the clarity of the presentation and the logic of the arguments.", "experimental_designs_or_analyses": "Yes. I believe their experiments are reasonable.", "relation_to_broader_scientific_literature": "The key contributions of the paper mainly focus on the quantization area. It introduced a novel regularizer to avoid the use of STE.", "essential_references_not_discussed": "I would like to see some comparison/discussion with [1], which also applies regularizer to circumvent STE.\n\n\n[1] Towards Accurate Network Quantization with Equivalent Smooth Regularizer, ECCV2022", "other_strengths_and_weaknesses": "This paper is beyond my expertise. Thus, my rating is only based on the motivation, writing, logical flow, and experimental results.\n\n\nI would recommend having this paper reviewed by experts specifically in theory and mathematics.", "other_comments_or_suggestions": "Here, I would like to justify my rating from the following parts and sincerely hope the author could modify their paper accordingly.\n\nMotivation and contribution to the field: STE is a widely used method to avoid the non-differentiable rounding operation in quantization. Also, it does incur some issues such as weak convergence as indicated in this paper. Thus, developing some regularization and proximal gradient methods to avoid the use of STE has been a research point here. This paper introduced a PARQ (Piecewise-Affine Regularized Quantization), which is able to serve as a regularization term to make the parameters converge to the desirable quantization levels. This provides a new contribution to theory and practice.\n\nWriting and logical flow: In section 2, this paper first introduced Piecewise affine regularization (PAR), and then demonstrated its optimality conditions, which induce the parameter to converge to quantization levels. In section 3, this paper introduced the AProx algorithm to solve the PAR to achieve the optimal values. There are also discussions about comparing AProx and other algorithms and convergence Analysis. In section 4, this paper introduced the practical implementation of their method. Overall, a new regularization term, following a new solver algorithm and practical implementation. These make their logical flow clear.\n\nRelated to [1]. [1] is also a regularization term-based method. I consider these two papers to have the same topic. Other than that, these two papers have no similarities in method and theory, according to my understanding. I hope to see some comparison between the performance and the theory behind them.\n\n[1] Towards Accurate Network Quantization with Equivalent Smooth Regularizer\n\nExperimental results: Their experimental results consist of ResNet and DeiT, evaluated on widely used ImageNet. I do consider these results to be sufficient.\n\nNovelty: The idea of convex piecewise affine regularization (PAR) and corresponding AProx solver make their method unique. To the best of my knowledge, this is the first work that proposed the regularization term from not only the practical view but also the theory view.\n\nTheory and formula parts: I think there are two main reasons why I find it difficult to understand: one reason is that I lack professional background knowledge. Thus, I recommend having this paper reviewed by experts specifically in mathematics. The other reason is that this article lacks guidance. For example, the author should explain the purpose of each section at the beginning of each section. I believe that adding guidance will help readers clearly understand the purpose of a certain section.", "questions_for_authors": "No.", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "BztvjQ7V6q", "reviewer": "Reviewer_zbZY", "summary": "The authors propose a convex piecewise regularizer for quantization aware training. They utilize an aggregate proximal stochastic gradient method and prove that it has last-iterate convergence. They denote that their method is equivalent to a previously proposed ProxConnect method, however they derive their method in a different way.\n\n## update after rebuttal\nI would like to keep my score after the rebuttal period.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for recognizing the strength of our paper (sound methodology and being well written) and giving us constructive suggestions on having more benchmark evaluations. We agree that additional empirical evaluations, especially on modern language models, will make the paper stronger. Although we do not have time to finish such experiments during the rebuttal period, we will try to include experiments on some basic language models in the final version to demonstrate its applicability.    \n\nWe agree that ablation study on the choice of $\\rho_t^{-1}$ is very useful for better understanding the behavior of the algorithm. The particular curve in Figure 10 is of the sigmoid family. Specifically,\n\n$\\rho_t^{-1} = \\frac{1}{1 + \\exp(s(t-t_1))}$\n\nwhere $t_1$ is the transition center and $s$ is the transition steepness. This schedule changes $\\rho_t^{-1}$ roughly from 1 to 0 (taking value $1/2$ at the transition center $t_1$). Essentially this changes the slope $\\rho_t$ from 1 to $+\\infty$. Here $s>0$ is the steepness parameter: the larger $s$ is, the steeper transition it has. For example, $s=0.1$ makes the transition almost linear, and the one shown in Figure 10 is with $s=10$.\n\nNotice that the above sigmoid curve for $\\rho_t^{-1}$ is essentially exponentially decaying as the reviewer suggested. Equivalently, we have the slope itself, $\\rho_t$, increases exponentially.\n\nIn our ablation study, we train a 2-bit DeiT-T model with PARQ. We study the choice of transition steepness $s \\in \\\\{0.1, 1, 10, 20, 40, 80\\\\}$ and transition center $t_1 \\in \\\\{0.25, 0.5, 0.75\\\\}$, the fraction of training progress at which transition occurs. This sweep reveals that a shallow $s = 1$ performs best for the model configuration. A later transition of $t = 0.75$ improves QAT performance for shallower steepness values $s \\in \\\\{10, 20\\\\}$, while higher $s \\in \\\\{40, 80\\\\}$ are relatively unaffected. We will add the above description and details of the ablation study to the appendix in the final version of the paper.\n\n| $\\boldsymbol{s}$ | $\\boldsymbol{t_1}$ | prec1 |\n|:---:|:---:|:---:|\n0.1 | 0.5 | 66.48 |\n1 | 0.5 | 66.6 |\n10 | 0.25 | 64.11 |\n10 | 0.5 | 64.62 |\n10 | 0.75 | 66.02 |\n20 | 0.25 | 63.74|\n20 | 0.5 | 63.88 |\n20 | 0.75 | 66.17 |\n40 | 0.25 | 64.05 |\n40 | 0.5 | 63.89 |\n40 | 0.75 | 63.89 |\n80 | 0.25 | 64.06 |\n80 | 0.5 | 64.28 |\n80 | 0.75 | 63.73 |", "claims_and_evidence": "Yes.", "methods_and_evaluation_criteria": "It makes sense. Having more benchmark datasets/tasks would have made the evaluation stronger.", "theoretical_claims": "Didn't check.", "experimental_designs_or_analyses": "Yes, the experimental design is sound.", "relation_to_broader_scientific_literature": "Yes. Quantization aware training is a hot topic since the large language models have become expensive to serve.", "essential_references_not_discussed": "N/A.", "other_strengths_and_weaknesses": "Strengths:\n* The methodology is sound.\n* The paper is well written.\n\nWeaknesses:\n* If the authors trained large language models with the proposed method, its impact would be much greater.\n* Additional datasets/models/tasks would have showed wider applicability of the method.", "other_comments_or_suggestions": "Ablation studies on the choice of the $\\rho_t^{-1}$ would be interesting to see.", "questions_for_authors": "* What is behind the choice of the curve in Figure 10 for the $\\rho_t^{-1}$ schedule? For example, how does an exponentially decaying schedule compare against the schedule used in the experiments?", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: This paper develops a principled method for quantization-aware training (QAT) based on the convex, piecewise-affine regularization. It introduces an aggregate proximal stochastic gradient method (AProx) and theoretically demonstrates its last-iterate convergence. Experiments on convolutional and transformer-based models show its effectiveness.

The main strengths of this paper are:

- the novelty of the convex regularization and the last-iterate convergence
- the connection among AProx, ProxConnect, STE and PARQ
- motivation and analysis are clear and well written

The main weaknesses of this paper are:

- the needs of more applications and comparisons like LLM
- the needs of more comprehensive discussion in the experimental analyses
- some clarification

During the rebuttal phase, all reviewers discussed, acknowledged, and provided justification.  Overall, this paper received a consistent positive recommendation, 4 weak accept and 1 accept from the reviewers.  All the concerns raised during review were addressed in the later rebuttal. 
After reading all the review, the discussion and the rebuttal, the AC agrees its novelty, and its contribution to theory and practice. 
As the authors agree to add more experiments, discussions and clarification based on the reviews, the AC recommend an Accept. The finial version should be revised accordingly.
Decision: Accept (poster)