NeUQI: Near-Optimal Uniform Quantization Parameter Initialization

## Abstract

Abstract Large language models (LLMs) achieve impressive performance across domains but face significant challenges when deployed on consumer-grade GPUs or personal devices such as laptops, due to high memory consumption and inference costs. Post-training quantization (PTQ) of LLMs offers a promising solution that reduces their memory footprint and decoding latency. In practice, PTQ with uniform quantization representation is favored for its efficiency and ease of deployment since uniform quantization is widely supported by mainstream hardware and software libraries. Recent studies on ≥ 2 absent 2 \geq 2 ≥ 2 -bit uniform quantization have led to noticeable improvements in post-quantization model performance; however, they primarily focus on quantization methodologies, while the initialization of quantization parameters is underexplored and still relies on the suboptimal Min-Max strategies. In this work, we propose NeUQI , a method devoted to efficiently determining near-optimal initial parameters for uniform quantization. NeUQI is orthogonal to prior quantization methodologies and can seamlessly integrate with them. The experiments with the LLaMA and Qwen families on various tasks demonstrate that our NeUQI consistently outperforms existing methods. Furthermore, when combined with a lightweight distillation strategy, NeUQI can achieve superior performance to PV-tuning, a much more resource-intensive approach.

## 1 Introduction

In recent years, large language models (LLMs) like ChatGPT [1] have rapidly emerged, demonstrating strong capabilities across various tasks, including open-ended writing, knowledge-based question answering, and code generation. Given the high API costs of proprietary LLMs and the growing performance of open-source alternatives like LLaMA [28, 10] and Qwen [32] families, there is a rising preference for deploying open-source LLMs locally. However, the deployment of large-scale models (e.g., LLaMA 3 70B) is often limited by compute resources and inference efficiency, especially on personal devices or consumer-grade GPUs like a single RTX 4090 with 24GB of memory. In this context, post-training quantization (PTQ) [15], particularly using a uniform quantization scheme, offers a practical solution by converting model weights from bfloat16 to low-bit-width integer formats such as int4/3/2, significantly reducing memory usage and inference latency.

Prior work on uniform PTQ mainly focuses on two directions. The first involves weight and activation processing to reduce quantization difficulty, such as smoothing via rotation transformations [5, 29, 3], integrating rotations into model architectures [21, 13], and reducing weight magnitude [34]. The second emphasizes block-wise and global fine-tuning, including multi-block training [7], rotation-based fine-tuning [21, 13], and direct optimization over quantized weights [22].

Although these studies have made notable progress, they still adopt the conventional Min-Max initialization, which merely determines quantization parameters solely based on the extreme values in the weights while ignoring weight distribution and importance. As revealed in LeanQuant [35], such initialization leads to a mismatch with the quantization objective in the commonly adopted GPTQ framework [8].
Even under ideal conditions, specifically a uniform distribution, Min-Max remains suboptimal, as analyzed in Appendix [A](https://arxiv.org/html/2505.17595v2#A1).
However, little research has focused on improving quantization initialization. Only recently has LeanQuant made a preliminary attempt by introducing a loss-aware strategy. But it still inherits a key limitation of Min-Max: restricting the zero-point to integers, which reduces the flexibility of uniform quantization and results in suboptimal initialization.

To address this gap, we propose NeUQI, a novel initialization method for uniform quantization, which removes the integer constraint on the zero-point, thus enabling a more flexible parameter space. We first apply a diagonal approximation to the quantization reconstruction objective and then decompose it into two tractable subproblems: (1) determining the optimal zero-point under a fixed scale and (2) finding the optimal scale given its corresponding zero-point. Both are efficiently solvable by exploiting the objective’s structure. More importantly, NeUQI is plug-and-play and orthogonal to quantization methods used in the calibration and fine-tuning stages. When combined with our NeUQI, the performance of quantized models significantly improves and even surpasses non-quantized models of comparable memory usage, as illustrated in Figure [1](https://arxiv.org/html/2505.17595v2#S1.F1). Furthermore, only applying a lightweight knowledge distillation, NeUQI can outperform PV-tuning [22]—a more sophisticated and resource-intensive fine-tuning method. It underscores the critical role of proper initialization: poor initial conditions are difficult to fix even with heavy fine-tuning, while a well-initialized model can achieve better performance with significantly less effort.

Figure: Figure 1: Perplexity on C4 (left) and average accuracy across five common benchmarks (right) with Qwen 2.5 family, plotted against the base-2 logarithm ($\log_{2}$) of model memory usage on the x-axis. The results include the non-quantized models (BF16) and the quantized models using commonly-used GPTQ, or our proposed NeUQI (both 3-bit). More details and results are shown in Section [5](https://arxiv.org/html/2505.17595v2#S5).
Refer to caption: x1.png

The main contributions of our work are summarized as follows:

- 1.
We revisit the conventionally adopted Min-Max quantization initialization and identify its fundamental limitation: the restriction of the zero-point to integers, which leads to reduced flexibility and suboptimal initialization.
- 2.
We propose NeUQI, a novel initialization method for uniform quantization that relaxes the zero-point to a continuous variable and exploits the structure of the optimization landscape. NeUQI can be directly combined with existing quantization methods to enhance their performance.
- 3.
Experiments with LLaMA and Qwen families of different sizes on various tasks demonstrate that NeUQI consistently outperforms existing methods. When further combined with a lightweight distillation strategy, NeUQI even surpasses relatively more resource-intensive PV-tuning.

## 2 Related Work

##### Uniform Quantization

In the 2-bit to 4-bit quantization regime, prior studies have explored many post-training quantization techniques to mitigate accuracy degradation. Early methods like AWQ [19] and SmoothQuant [31] applied mathematically equivalent transformations using diagonal matrices on activations and their inverses on weights, balancing quantization difficulty and laying the groundwork for later approaches.
Subsequent methods generalized the diagonal matrix to invertible forms for better smoothing, though activation-side transformations require online computation, leading to efficiency-focused designs. For example, QuIP [5] uses Kronecker products of two small rotations; DuQuant [18] adopts block-diagonal matrices with repeated rotation; QuIP# [29] and QuaRot [3] use Hadamard transforms; FrameQuant [2] applies a Fourier-based transformation variant. SpinQuant [21] and OSTQuant [13] introduce learnable rotations integrated into the model to avoid runtime overhead. Alternatively, MagR [34] optimizes weights while preserving model functionality to reduce quantization difficulty. In addition, there are fine-tuning-based approaches such as CBQ [7], which performs block-wise tuning, and PV-tuning [22], which jointly optimizes continuous and discrete parameters.

##### Quantization Parameter Initialization

Most uniform quantization methods rely on the conventional Min-Max initialization, which determines quantization parameters by the extreme weight values. Although Min-Max is straightforward and efficient, this heuristic neglects the impact of initialization on the final model performance. Some methods, such as MagR and OmniQuant [27], introduce shrink-scale variants of Min-Max to suppress outliers and improve precision, but they remain simple extensions of the original method. LeanQuant [35] makes a significant step forward by proposing an optimization-based initialization with grid search. However, its optimization relies on enumerating different Min-Max value pairs, from which the scale and zero-point are computed based on the standard Min-Max formula. As a result, it inherits the core limitations of Min-Max, particularly the constraint of zero-points to integers. In contrast, our NeUQI is proposed to overcome the limitations of the Min-Max paradigm by removing the zero-point constraint and directly optimizing a well-founded initialization objective.

## 3 Background

##### Uniform Quantization

Model quantization is, in essence, the process of mapping floating-point parameters to a finite set of quantized values, allowing each parameter to be represented by a low-bit-width index, thereby reducing memory footprint and memory access latency. In the case of uniform quantization, the finite set $\mathcal{Q}$ is defined by three parameters: the scale $s$, the zero-point $z$, and the bit-width $k$. Formally, this set is given by:

$$ $\mathcal{Q}=\left\{q_{i}=s\cdot(z+i)\,\middle|\,i\in\{0,1,\ldots,2^{k}-1\} \right\},$ (1) $$

where $i$ is the index of quantized values.

To reduce quantization error, each floating-point value is typically mapped to the nearest value in $\mathcal{Q}$. Given a floating-point input $x$, and assuming the parameters $s$, $z$, and $k$ of $\mathcal{Q}$ are known, the uniform quantization function $Q$ is defined as:

$$ $Q_{s,z}(x)=s\cdot\left(\text{clamp}(\lfloor x/s-z\rceil,\,0,\,2^{k}-1)+z\right),$ (2) $$

where $\lfloor\cdot\rceil$ denotes rounding to the nearest integer, and $\text{clamp}(\cdot,a,b)=\text{max}(a,\text{min}(\cdot,b))$ ensures the result lies within $[a,b]$; the subscript $k$ is typically omitted from $Q$ since the bit-width is usually known in advance.

##### Min-Max Initialization

Min-Max is a conventional initialization method that remains widely used in uniform quantization.
Min-Max determines the quantization parameters by mapping the minimum and maximum of the parameter to $s\cdot z$ and $s\cdot(z+2^{k}-1)$, which correspond to the quantized values at indices 0 0 and $2^{k}-1$ in the set $\mathcal{Q}$. Based on the above extremal-value mapping, the scale factor $s$ and the zero point $z$ are directly given by:

$$ $s=\frac{\text{max}(x)-\text{min}(x)}{2^{k}-1},\quad z=\left\lfloor\frac{\text{ min}(x)}{s}\right\rceil.$ (3) $$

Here, $z$ is rounded to the nearest integer.
This is because, under the common assumptions that $\text{max}(x)\geq 0$, $\text{min}(x)\leq 0$, and $s>0$, we have $s\geq-\text{min}(x)/(2^{k}-1)$ and $\text{min}(x)/s\leq 0$, which implies $\text{min}(x)/s\in[-(2^{k}-1),0]$.
Therefore, after rounding, it follows that $z\in[-(2^{k}-1),0]$, and thus $-z$ lies within the range $[0,2^{k}-1]$, making it representable as a $k$-bit unsigned integer.

## 4 Method

In this section, we present NeUQI (Near-Optimal Uniform Quantization Initialization), a novel method designed to improve the parameter initialization of uniform quantization.
Unlike the conventional Min-Max initialization, which directly determines the scale and zero-point from the observed minimum and maximum values of the weights, NeUQI formulates the initialization as an optimization problem to find near-optimal quantization parameters.
We begin by revisiting the quantization loss formulation in Section [4.1](https://arxiv.org/html/2505.17595v2#S4.SS1), which lays the foundation for our initialization strategy. Section [4.2](https://arxiv.org/html/2505.17595v2#S4.SS2) then introduces the NeUQI algorithm, detailing its formulation and practical implementation. Finally, in Section [4.3](https://arxiv.org/html/2505.17595v2#S4.SS3), we introduce a lightweight distillation technique to demonstrate the efficiency of our method, which can further improve the performance of the quantized model with minimal overhead.

### 4.1 Quantization Loss

Following GPTQ [8], the quantization loss function for a single linear layer is given by

$$ $\displaystyle\mathcal{L}(s,z)$ $\displaystyle=\|XW^{\top}-XQ_{s,z}(W)^{\top}\|_{F}^{2}$ (4) $\displaystyle=\operatorname{tr}((W-Q_{s,z}(W))H(W-Q_{s,z}(W))^{\top})$ (5) $\displaystyle=\sum_{i}(W_{i}-Q_{s,z}(W_{i}))H(W_{i}-Q_{s,z}(W_{i}))^{\top},$ (6) $$

where $X\in\mathbb{R}^{T\times\mathrm{In}}$ denotes the input activations, $W\in\mathbb{R}^{\mathrm{Out}\times\mathrm{In}}$ is the weight matrix of the linear layer, with $\mathrm{In}$ and $\mathrm{Out}$ representing the input and output dimensions respectively. $W_{i}\in\mathbb{R}^{1\times\mathrm{In}}$ denotes the $i$-th row of $W$, and $H=X^{\top}X\in\mathbb{R}^{\mathrm{In}\times\mathrm{In}}$ is commonly referred to as the Hessian matrix.
This formulation naturally suggests adopting the row-wise quantization strategy, which aligns with common practices that treat one row as one or multiple groups for quantization.

### 4.2 NeUQI

Although the full Hessian is efficiently computable for a single linear layer, incorporating it into the optimization is nontrivial. To address this, we adopt a diagonal approximation, which is a standard technique in the machine learning literature [17, 14]. This approximation removes cross-weight interactions and results in a structurally simpler loss function that, despite being globally coupled via shared quantization parameters, is significantly easier to optimize. Under this approximation, the loss function reduces to:

$$ $\mathcal{L}(s,z)=\sum_{i}H_{ii}(Q_{s,z}(w_{i})-w_{i})^{2}$ (7) $$

To solve this problem efficiently, we decompose the optimization into two sequential steps. First, we fix the scale $s$ and optimize the zero-point $z$, as discussed in Section [4.2.1](https://arxiv.org/html/2505.17595v2#S4.SS2.SSS1). Then, based on the solution of the first step, we further optimize the scale $s$, as described in Section [4.2.2](https://arxiv.org/html/2505.17595v2#S4.SS2.SSS2).

#### 4.2.1 Optimization of Zero-Point

Following this decomposition, the loss function is further transformed into:

$$ $\mathcal{L}(z)=s^{2}\sum_{i=1}^{n}h_{i}\left(\text{clamp}\left(\lfloor x_{i}-z \rceil,0,2^{k}-1\right)-(x_{i}-z)\right)^{2},$ (8) $$

where $x_{i}=w_{i}/s$, and $h_{i}=H_{ii}$.

Figure: Algorithm 1 Optimal Zero-Point Search over Piecewise Quadratic Function

We first can observe that the single term $\text{clamp}(\lfloor x_{i}-z\rceil,0,2^{k}-1)$ is a piecewise constant function of $z$. The transition points of this function occur at $z=x_{i}-(i+0.5)$, $i\in\{0,1,\cdots,2^{k}-2\}$, which divides the real line into $2^{k}$ intervals.
Now consider the single-term quantization error:
$(\mathrm{clamp}(\lfloor x_{i}-z\rceil,0,2^{k}-1)-(x_{i}-z))^{2}$,
which is a piecewise quadratic function of $z$, also divided into $2^{k}$ intervals. Consequently, the total loss function (aggregated over $n$ samples) consists of $O(n\cdot 2^{k})$ intervals.
To find the minimum of the piecewise quadratic function, we first compute the local minimum in each interval and then select the smallest among them.
This idea reduces the problem to computing the quadratic, linear, and constant coefficients of the piecewise quadratic loss function in each interval. These coefficients can be efficiently calculated by sorting all transition points and accumulating the corresponding increments, a strategy we refer to as the increment-prefix-sum technique. Specifically, when $\text{clamp}(\lfloor x_{i}-z\rceil,0,2^{k}-1)$ changes from $a$ to $b$, the resulting increment in the loss function is $(b-(x_{i}-z))^{2}-(a-(x_{i}-z))^{2}$.
The detailed procedure is described in Algorithm [1](https://arxiv.org/html/2505.17595v2#alg1).

As previously discussed, the total number of transition points is $O(n\cdot 2^{k})$.
Since the coefficient computation involves sorting these points, the overall time complexity is $O(n\cdot 2^{k}\cdot\log(n\cdot 2^{k}))$, which increases overhead substantially as the bit-width $k$ grows.
To alleviate this computational burden, we propose a two-stage efficient approximation strategy, which reduces the overall time complexity to $O(n\log n)$:

- •
Rough Estimation: At this stage, we approximate $x_{i}-z$ within the low-loss interval $[-\frac{1}{2},2^{k}-\frac{1}{2}]$ by its maximum value $(\frac{1}{2})^{2}$, while leaving the quantization loss unchanged outside this interval, resulting in a smoothed objective:
$\text{max}\left(0.25,\left(\text{clamp}\left(\lfloor x_{i}-z\rceil,0,2^{k}-1
\right)-(x_{i}-z)\right)^{2}\right),$
Under this approximation, each sample reduces to exactly two transition points, located at $x_{i}-(2^{k}-0.5)$ and $x_{i}+0.5$. Leveraging the same increment-prefix-sum technique, we can determine an approximate zero-point $z_{\mathrm{rough}}$ in $O(n\log n)$ time. The detailed procedure is described in Algorithm [2](https://arxiv.org/html/2505.17595v2#alg2).
- •
Local Search: The original, non-approximated loss function is then evaluated within a narrow interval $[z_{\mathrm{rough}}-1,z_{\mathrm{rough}}+1]$. As the number of transition points in this interval remains limited to at most two per sample, this local search step also maintains a time complexity of $O(n\log n)$. The detailed procedure is described in Algorithm [3](https://arxiv.org/html/2505.17595v2#alg3).

Figure: Figure 2: Line plots of $\mathcal{L}(s,z^{*}(s))$ versus $s$ for the query projection matrix in the 15^th transformer block. The horizontal axis shows the ratio of $s$ to the baseline value $(\text{max}(x)-\text{min}(x))/(2^{k}-1)$. The left, center, and right plots correspond to the 1st, 1203rd, and 3709th rows of the query projection matrix. Local minima are indicated with red star (★).
Refer to caption: x2.png

#### 4.2.2 Optimization of Scale

After determining the optimal zero-point $z^{*}(s)$ for a given scale $s$ using the above algorithm, the loss function can be simplified into a univariate function that depends only on $s$. Although the loss for a portion of the rows in the weight matrix appears unimodal, many other rows exhibit non-unimodal behavior, as illustrated in Figure [2](https://arxiv.org/html/2505.17595v2#S4.F2). Specifically, as shown in the figure, the loss landscape for the 1st row has a single minimum, indicating unimodal behavior, whereas the 1203rd and 3709th rows each exhibit two local minima, clearly showing non-unimodal patterns.
As a result, it is challenging to apply continuous optimization techniques like gradient descent or even one-dimensional search methods like ternary search(^1^11[https://en.wikipedia.org/wiki/Ternary_search](https://en.wikipedia.org/wiki/Ternary_search)) for selecting the scale $s$.

To address this issue, we perform a uniformly spaced grid search in the parameter space to ensure sufficient scale exploration. Specifically, the grid points for candidate scales are defined as follows:

$$ $\mathcal{G}_{T}=\left\{\frac{\text{max}(x)-\text{min}(x)}{2^{k}-1}\cdot\frac{i }{T}\,\middle|\,i\in\{1,2,\cdots,T-1,T\}\right\},$ (9) $$

where $T$ denotes the total number of grid points.
We evaluate the quantization error at each grid point and select the scale with the minimum error as the optimal solution.

To further enhance the search efficiency, we propose a coarse-to-fine grid search strategy, which consists of the following two phases:

- •
Coarse Grid Search: A preliminary search is conducted using a coarse grid $\mathcal{G}_{T_{c}}$, allowing rapid localization of a promising local region where the optimal solution may reside.
- •
Fine Grid Search: After obtaining the coarse search optimal solution $s_{c}$, we construct a local candidate set by selecting the $\lfloor T/(2T_{c})\rfloor$ nearest neighbors on each side of $s_{c}$ from a finer grid $\mathcal{G}_{T}$, along with $s_{c}$ itself. This results in a total of $2\lfloor T/(2T_{c})\rfloor+1$ scales, enabling more accurate estimation with relatively low overhead.

This strategy effectively reduces the original $T$ expensive error evaluations—each involving the search for the minimum loss and its corresponding zero-point—to approximately $T_{c}+T/T_{c}$. In particular, when $T_{c}$ is set approximately to $\sqrt{T}$, the total number of evaluations further decreases to around $2\sqrt{T}$. As a result, this approach significantly reduces computational overhead while still providing a good approximation to the optimal solution, achieving a favorable trade-off between quantization accuracy and search efficiency.

### 4.3 Lightweight Distillation

To better demonstrate NeUQI’s effectiveness, we incorporate additional lightweight distillation experiments for comparison. Specifically, to enhance the alignment between the behaviors of the quantized model and the original non-quantized model, we perform knowledge distillation on a small set of samples. During distillation, only the continuous parameters of the quantized model—specifically, the scales, zero-points, and the RMSNorm layers—are updated. The language model head and embedding layer, which remain in their original precision, are excluded from optimization to avoid distillation-induced bias and reduce memory overhead. The distillation loss is the mean squared error between the final-layer hidden states of the original and quantized models.

## 5 Experiment

### 5.1 Baselines and Evaluation

We experiment with our proposed NeUQI on three commonly-used LLM families, covering different sizes: LLaMA 2 (7B, 13B, 70B) [28], LLaMA 3 (8B, 70B) [10] and Qwen 2.5 (7B, 14B, 32B, 72B) [32]. Under uniform quantization, we compare against several representative weight-only post-training quantization methods, including GPTQ [8], MagR [34], PV-tuning [22], LeanQuant [35], as well as two initialization strategy baselines, for different analytical purposes. Following the previous work, all the quantized models are evaluated by measuring perplexity on the WikiText2 (Wiki2) [23] and C4 [25] validation sets, and zero-shot accuracy on five benchmarks: ARC-easy (ArcE), ARC-challenge (ArcC) [6], PiQA [4], HellaSwag (HellaS) [33], and WinoGrande (WinoG) [26].

**Table 1: Perplexity on Wiki2 and C4, along with zero-shot accuracy on five benchmarks (averaged as Acc) of different quantized models with channel-wise quantization. Arrows ↑/↓ indicate whether the higher or lower result is better, and Size denotes the original model size before quantization.**
| Size | Bits | Method | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLaMA 2 Family |  |  |  |  |  |  |  |  |  |  |
| 7B | 2 | GPTQ | 6953 | 2592 | 21.93 | 25.63 | 25.89 | 52.23 | 49.72 | 35.08 |
| MagR | 129 | 47.55 | 21.42 | 34.97 | 32.29 | 58.27 | 50.75 | 39.54 |  |  |
| NeUQI | 17.14 | 17.50 | 23.98 | 51.73 | 36.04 | 65.89 | 58.56 | 47.24 |  |  |
| 13B | 2 | GPTQ | 1735 | 433 | 21.76 | 26.52 | 25.85 | 52.56 | 51.30 | 35.60 |
| MagR | 47.98 | 27.94 | 23.21 | 26.68 | 36.70 | 52.99 | 54.14 | 38.74 |  |  |
| NeUQI | 13.72 | 14.39 | 26.19 | 55.18 | 37.37 | 65.94 | 59.12 | 48.76 |  |  |
| 70B | 2 | GPTQ | 60.29 | 46.11 | 19.97 | 28.07 | 27.05 | 53.75 | 50.04 | 35.78 |
| MagR | 68.62 | 13.95 | 39.59 | 71.21 | 52.81 | 76.33 | 69.06 | 61.80 |  |  |
| NeUQI | 7.03 | 8.88 | 44.71 | 75.97 | 53.62 | 77.64 | 73.72 | 65.13 |  |  |
| LLaMA 3 Family |  |  |  |  |  |  |  |  |  |  |
| 8B | 2 | GPTQ | >1e4 | >1e4 | 20.90 | 23.91 | 26.04 | 53.48 | 48.86 | 34.64 |
| MagR | 387 | 140 | 18.43 | 30.09 | 27.60 | 55.98 | 50.12 | 36.45 |  |  |
| NeUQI | 64.47 | 39.41 | 24.83 | 52.10 | 37.50 | 63.00 | 59.04 | 47.30 |  |  |
| 70B | 2 | GPTQ | >1e4 | >1e4 | 20.73 | 25.76 | 25.76 | 52.45 | 48.46 | 34.63 |
| MagR | >1e4 | >1e4 | 21.59 | 25.59 | 25.51 | 52.99 | 48.46 | 34.83 |  |  |
| NeUQI | 56.21 | 42.06 | 25.68 | 53.24 | 36.98 | 61.04 | 55.49 | 46.49 |  |  |
| Qwen 2.5 Family |  |  |  |  |  |  |  |  |  |  |
| 7B | 2 | GPTQ | 2332 | 719 | 21.42 | 26.52 | 25.70 | 50.92 | 48.93 | 34.70 |
| MagR | 25.38 | 24.83 | 23.12 | 42.09 | 37.76 | 60.99 | 51.30 | 43.05 |  |  |
| NeUQI | 37.46 | 28.77 | 22.10 | 47.85 | 39.56 | 60.99 | 58.48 | 45.80 |  |  |
| 14B | 2 | GPTQ | 3852 | 1056 | 23.12 | 25.42 | 25.90 | 50.92 | 51.93 | 35.46 |
| MagR | 18.36 | 19.36 | 23.21 | 44.74 | 38.06 | 63.44 | 52.88 | 44.47 |  |  |
| NeUQI | 23.58 | 18.38 | 37.88 | 69.32 | 46.86 | 72.31 | 67.40 | 58.76 |  |  |
| 32B | 2 | GPTQ | 308 | 141 | 21.42 | 26.09 | 25.11 | 51.20 | 49.41 | 34.65 |
| MagR | 13.16 | 14.72 | 25.94 | 48.91 | 45.25 | 68.06 | 56.51 | 48.93 |  |  |
| NeUQI | 18.17 | 15.77 | 41.55 | 71.63 | 53.38 | 76.01 | 72.77 | 63.07 |  |  |
| 72B | 2 | GPTQ | 1127 | 281 | 22.95 | 25.00 | 25.46 | 51.31 | 48.70 | 34.68 |
| MagR | 19.25 | 13.83 | 31.91 | 59.64 | 51.13 | 72.74 | 59.59 | 55.00 |  |  |
| NeUQI | 10.79 | 11.36 | 48.04 | 78.11 | 56.18 | 78.56 | 75.14 | 67.21 |  |  |

### 5.2 Implementation Settings

We evaluate both channel-wise and group-wise quantization at the 2-bit, 3-bit, and 4-bit quantization, where the group size is set to a common configuration of 128.
Across all experiments, GPTQ is employed as the unified weight transformation method, ensuring consistent quantization quality and fair comparisons among different approaches.
During calibration, 128 samples are drawn from the C4 dataset. Each sample contains 2048 tokens for LLaMA 2, and 4096 tokens for LLaMA 3 and Qwen 2.5, following the previous work. For distillation, 256 samples from the same dataset are used for a single epoch.
Moreover, the grid search over the scale hyperparameter is conducted with $T=2048$ and $T_{c}=64$ in our NeUQI method.
More implementation details are included in Appendix [D](https://arxiv.org/html/2505.17595v2#A4).

### 5.3 Main Results

Under the most challenging 2-bit channel-wise quantization setting, our NeUQI achieves significant improvements over GPTQ and MagR, as shown in Table [1](https://arxiv.org/html/2505.17595v2#S5.T1). Although the recent MagR method delivers acceptable performance on the Qwen 2.5 family, especially on perplexity, it performs poorly on the LLaMA family. In contrast, NeUQI consistently demonstrates strong performance across different model architectures and sizes. Similar conclusions hold under the 2-bit group-wise quantization setting, with detailed results shown in Table [6](https://arxiv.org/html/2505.17595v2#A7.T6).

Moreover, as the bit-width increases, the performance gap between different methods gradually narrows, as shown in Table [7](https://arxiv.org/html/2505.17595v2#A7.T7), Table [8](https://arxiv.org/html/2505.17595v2#A7.T8), and Table [9](https://arxiv.org/html/2505.17595v2#A7.T9). Our NeUQI continues to show stable advantages under the 3-bit setting, maintaining robustness across architectures. As for 4-bit, where all methods closely match the original non-quantized model, further improvements are limited. Nevertheless, NeUQI remains competitive and exhibits slight advantages in certain cases.

### 5.4 Discussion

**Table 2: Results of different initialization methods based on LLaMA 2 family and LLaMA 3 8B with channel-wise quantization. $\dagger$ denotes the results directly extracted from the original paper.**
| Size | Bits | Method | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLaMA 2 Family |  |  |  |  |  |  |  |  |  |  |
| 7B | 2 | Min-Max+ | 498 | 136 | 21.67 | 27.36 | 26.92 | 54.24 | 50.83 | 36.20 |
| LeanQuant^† | 25.69 | 27.11 | 20.99 | 41.08 | 31.94 | 61.64 | 56.51 | 42.43 |  |  |
| NeUQI${}_{\text{int}}$ | 26.26 | 24.15 | 22.70 | 45.50 | 33.06 | 62.51 | 55.49 | 43.85 |  |  |
| NeUQI | 17.14 | 17.50 | 23.98 | 51.73 | 36.04 | 65.89 | 58.56 | 47.24 |  |  |
| 13B | 2 | Min-Max+ | 32.19 | 25.96 | 22.61 | 32.03 | 32.97 | 57.40 | 50.83 | 39.17 |
| LeanQuant^† | 24.43 | 20.92 | 24.32 | 50.88 | 38.01 | 67.19 | 56.91 | 47.46 |  |  |
| NeUQI${}_{\text{int}}$ | 15.67 | 16.69 | 26.11 | 53.32 | 36.48 | 65.51 | 56.59 | 47.60 |  |  |
| NeUQI | 13.72 | 14.39 | 26.19 | 55.18 | 37.37 | 65.94 | 59.12 | 48.76 |  |  |
| 70B | 2 | Min-Max+ | 13.33 | 14.08 | 25.94 | 45.62 | 38.30 | 65.56 | 59.59 | 47.00 |
| LeanQuant^† | 7.92 | 10.84 | - | - | - | - | - | - |  |  |
| NeUQI${}_{\text{int}}$ | 8.71 | 10.49 | 39.85 | 72.18 | 50.82 | 75.84 | 69.38 | 61.61 |  |  |
| NeUQI | 7.03 | 8.88 | 44.71 | 75.97 | 53.62 | 77.64 | 73.72 | 65.13 |  |  |
| LLaMA 3 8B |  |  |  |  |  |  |  |  |  |  |
| 8B | 2 | Min-Max+ | 3016 | 716 | 20.99 | 25.04 | 26.28 | 53.16 | 50.43 | 35.18 |
| LeanQuant^† | - | - | 18.26 | 35.06 | 31.43 | 59.30 | 51.85 | 39.18 |  |  |
| NeUQI${}_{\text{int}}$ | 93.64 | 47.76 | 18.86 | 37.84 | 32.62 | 60.28 | 54.30 | 40.78 |  |  |
| NeUQI | 64.47 | 39.41 | 24.83 | 52.10 | 37.50 | 63.00 | 59.04 | 47.30 |  |  |

##### Integer Constraint

We compare against several improved initialization methods that all keep the integer constraint on the zero-point, including Min-Max+, a variant of Min-Max derived under ideal assumptions (more details included in Appendix [A](https://arxiv.org/html/2505.17595v2#A1)), as well as an optimization-based method, LeanQuant. We also experiment with NeUQI${}_{\text{int}}$, a variant of our NeUQI with an enforced integer zero-point constraint.
The differences between LeanQuant and NeUQI${}_{\text{int}}$ are discussed in Appendix [D.5](https://arxiv.org/html/2505.17595v2#A4.SS5). As shown in Table [2](https://arxiv.org/html/2505.17595v2#S5.T2), although these methods yield performance gains compared with the results in Table [1](https://arxiv.org/html/2505.17595v2#S5.T1), they still underperform NeUQI, which removes the integer constraint and enables a markedly more flexible quantization scheme. These results suggest that the widely adopted integer zero-point assumption may be overly restrictive for optimization-based quantization methods and requires more attention for improvements.

##### Distillation

As shown in Table [3](https://arxiv.org/html/2505.17595v2#S5.T3), augmented with the lightweight distillation training that only uses about 0.5M tokens, NeUQI achieves significantly better results than original PV-tuning. This advantage is more notable considering that PV-tuning requires more memory and incurs longer per-step runtime than standard fine-tuning of the original model, while also demanding substantially more data. When constrained to the same data volume, its performance degrades markedly, falling even below that of the standard GPTQ method. This reveals the importance of proper initialization, since poor initialization seems difficult to fix even with heavy fine-tuning.

**Table 3: Results of distillation based on LLaMA 2 7B with 2-bit quantization and group size of 128. $\dagger$ denotes the results directly extracted from the original paper, and Tokens denotes the total number of training tokens.**
| Method | Tokens | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPTQ | ~0.5M | 14.95 | 13.31 | 25.34 | 49.20 | 39.13 | 67.63 | 58.96 | 48.05 |
| PV-tuning | ~0.5M | 14.09 | 13.95 | 23.21 | 43.35 | 37.38 | 64.80 | 58.17 | 45.38 |
| PV-tuning^† | ~1B | 8.49 | 10.78 | - | - | - | - | - | 52.17 |
| NeUQI | ~0.5M | 8.38 | 9.81 | 32.00 | 66.79 | 47.73 | 73.34 | 64.01 | 56.77 |

##### Comparison with Non-Quantized Models

With comparable memory usages, the quantized models using our NeUQI consistently outperform the non-quantized ones, as shown in Table [4](https://arxiv.org/html/2505.17595v2#S5.T4). Although limited by computational resources and unable to experiment on larger models, these results demonstrate the potential of NeUQI-based low-bit-width quantization when applied to ultra-large models (e.g., DeepsSeek V3 671B [20]). They often lack smaller versions and remain difficult to deploy, particularly in resource-limited environments, even with 8-bit or 4-bit quantization.

**Table 4: Performance comparison between quantized and non-quantized models based on the Qwen 2.5 family with comparable main body memory usages.**
| Method | Memory | Size | Bits | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| - | 2.62GiB | 1.5B | 16 | 8.58 | 12.54 | 41.21 | 75.51 | 50.12 | 75.79 | 63.85 | 61.30 |
| GPTQ | 2.45GiB | 7B | 3 | 10.73 | 13.90 | 39.33 | 71.21 | 50.16 | 73.29 | 60.77 | 58.95 |
| NeUQI | 2.45GiB | 7B | 3 | 8.64 | 11.72 | 44.80 | 76.77 | 55.15 | 77.97 | 70.96 | 65.13 |
| - | 5.55GiB | 3B | 16 | 7.44 | 11.15 | 45.22 | 77.31 | 55.03 | 78.62 | 68.75 | 64.99 |
| GPTQ | 4.96GiB | 14B | 3 | 8.48 | 11.61 | 38.82 | 67.21 | 54.22 | 75.52 | 65.51 | 60.26 |
| NeUQI | 4.96GiB | 14B | 3 | 6.82 | 9.89 | 50.17 | 80.43 | 59.39 | 79.54 | 76.09 | 69.12 |
| - | 13.05GiB | 7B | 16 | 6.39 | 10.02 | 48.29 | 80.56 | 60.00 | 78.67 | 72.69 | 68.04 |
| GPTQ | 11.72GiB | 32B | 3 | 7.21 | 10.36 | 44.03 | 74.96 | 58.75 | 77.97 | 66.22 | 64.38 |
| NeUQI | 11.72GiB | 32B | 3 | 5.85 | 9.31 | 51.19 | 80.98 | 62.30 | 80.14 | 75.14 | 69.95 |
| - | 26.42GiB | 14B | 16 | 4.93 | 8.75 | 55.80 | 82.37 | 63.38 | 81.07 | 74.66 | 71.46 |
| GPTQ | 26.36GiB | 72B | 3 | 6.89 | 9.96 | 46.93 | 78.03 | 61.51 | 78.62 | 71.43 | 67.30 |
| NeUQI | 26.36GiB | 72B | 3 | 4.99 | 8.37 | 56.40 | 83.75 | 64.92 | 81.83 | 78.45 | 73.07 |

##### Quantization Overhead

Table [10](https://arxiv.org/html/2505.17595v2#A7.T10) presents the quantization overhead of GPTQ and NeUQI across different model sizes from the LLaMA 2 family on a single NVIDIA A40. Taking the 7B model as an example, NeUQI requires 5.85 hours with group-wise quantization and 7.10 hours with channel-wise quantization, both without coarse-to-fine search. With the strategy enabled, the overhead dropped to 0.45 and 0.50 hours, respectively, achieving over 10× speedup.

## 6 Conclusion

To the best of our knowledge, our proposed NeUQI is the first work to remove the zero-point integer constraint in parameter initialization for $\geq 2$-bit uniform quantization. It consistently outperforms existing methods and, under the comparable memory footprint, can even surpass non-quantized models from the same model family, improving the practicality of low-bit-width quantization.
A lightweight knowledge distillation experiment further supports the effectiveness of NeUQI and our belief that combining it with other orthogonal techniques could yield additional gains.
In future work, we plan to further optimize the original quantization loss during initialization and explore more efficient low-bit-width quantization methods, especially for ultra-large models.

## References

- Achiam et al. [2023]
Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al.
Gpt-4 technical report.
*arXiv preprint arXiv:2303.08774*, 2023.
- Adepu et al. [2024]
Harshavardhan Adepu, Zhanpeng Zeng, Li Zhang, and Vikas Singh.
Framequant: Flexible low-bit quantization for transformers.
*arXiv preprint arXiv:2403.06082*, 2024.
- Ashkboos et al. [2024]
Saleh Ashkboos, Amirkeivan Mohtashami, Maximilian Croci, Bo Li, Pashmina Cameron, Martin Jaggi, Dan Alistarh, Torsten Hoefler, and James Hensman.
Quarot: Outlier-free 4-bit inference in rotated llms.
*Advances in Neural Information Processing Systems*, 37:100213–100240, 2024.
- Bisk et al. [2020]
Yonatan Bisk, Rowan Zellers, Jianfeng Gao, Yejin Choi, et al.
Piqa: Reasoning about physical commonsense in natural language.
In *Proceedings of the AAAI conference on artificial intelligence*, volume 34, pages 7432–7439, 2020.
- Chee et al. [2023]
Jerry Chee, Yaohui Cai, Volodymyr Kuleshov, and Christopher M De Sa.
Quip: 2-bit quantization of large language models with guarantees.
*Advances in Neural Information Processing Systems*, 36:4396–4429, 2023.
- Clark et al. [2018]
Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord.
Think you have solved question answering? try arc, the ai2 reasoning challenge.
*arXiv preprint arXiv:1803.05457*, 2018.
- Ding et al. [2023]
Xin Ding, Xiaoyu Liu, Zhijun Tu, Yun Zhang, Wei Li, Jie Hu, Hanting Chen, Yehui Tang, Zhiwei Xiong, Baoqun Yin, et al.
Cbq: Cross-block quantization for large language models.
*arXiv preprint arXiv:2312.07950*, 2023.
- Frantar et al. [2022]
Elias Frantar, Saleh Ashkboos, Torsten Hoefler, and Dan Alistarh.
Gptq: Accurate post-training quantization for generative pre-trained transformers.
*arXiv preprint arXiv:2210.17323*, 2022.
- Gao et al. [2024]
Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Golding, Jeffrey Hsu, Alain Le Noac’h, Haonan Li, Kyle McDonell, Niklas Muennighoff, Chris Ociepa, Jason Phang, Laria Reynolds, Hailey Schoelkopf, Aviya Skowron, Lintang Sutawika, Eric Tang, Anish Thite, Ben Wang, Kevin Wang, and Andy Zou.
A framework for few-shot language model evaluation, 07 2024.
URL [https://zenodo.org/records/12608602](https://zenodo.org/records/12608602).
- Grattafiori et al. [2024]
Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al.
The llama 3 herd of models.
*arXiv preprint arXiv:2407.21783*, 2024.
- Guo et al. [2024]
Han Guo, William Brandon, Radostin Cholakov, Jonathan Ragan-Kelley, Eric Xing, and Yoon Kim.
Fast matrix multiplications for lookup table-quantized llms.
In *Findings of the Association for Computational Linguistics: EMNLP 2024*, pages 12419–12433, 2024.
- Hassibi et al. [1993]
Babak Hassibi, David G. Stork, and Gregory J. Wolff.
Optimal brain surgeon and general network pruning.
In *Proceedings of International Conference on Neural Networks (ICNN’88), San Francisco, CA, USA, March 28 - April 1, 1993*, pages 293–299. IEEE, 1993.
doi: 10.1109/ICNN.1993.298572.
URL [https://doi.org/10.1109/ICNN.1993.298572](https://doi.org/10.1109/ICNN.1993.298572).
- Hu et al. [2025]
Xing Hu, Yuan Cheng, Dawei Yang, Zukang Xu, Zhihang Yuan, Jiangyong Yu, Chen Xu, Zhe Jiang, and Sifan Zhou.
Ostquant: Refining large language model quantization with orthogonal and scaling transformations for better distribution fitting.
*arXiv preprint arXiv:2501.13987*, 2025.
- Kingma [2014]
Diederik P Kingma.
Adam: A method for stochastic optimization.
*arXiv preprint arXiv:1412.6980*, 2014.
- Krishnamoorthi [2018]
Raghuraman Krishnamoorthi.
Quantizing deep convolutional networks for efficient inference: A whitepaper.
*arXiv preprint arXiv:1806.08342*, 2018.
- Kwon et al. [2023]
Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica.
Efficient memory management for large language model serving with pagedattention.
In *Proceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles*, 2023.
- LeCun et al. [1989]
Yann LeCun, John S. Denker, and Sara A. Solla.
Optimal brain damage.
In David S. Touretzky, editor, *Advances in Neural Information Processing Systems 2, [NIPS Conference, Denver, Colorado, USA, November 27-30, 1989]*, pages 598–605. Morgan Kaufmann, 1989.
URL [http://papers.nips.cc/paper/250-optimal-brain-damage](http://papers.nips.cc/paper/250-optimal-brain-damage).
- Lin et al. [2024a]
Haokun Lin, Haobo Xu, Yichen Wu, Jingzhi Cui, Yingtao Zhang, Linzhan Mou, Linqi Song, Zhenan Sun, and Ying Wei.
Duquant: Distributing outliers via dual transformation makes stronger quantized llms.
*Advances in Neural Information Processing Systems*, 37:87766–87800, 2024a.
- Lin et al. [2024b]
Ji Lin, Jiaming Tang, Haotian Tang, Shang Yang, Wei-Ming Chen, Wei-Chen Wang, Guangxuan Xiao, Xingyu Dang, Chuang Gan, and Song Han.
Awq: Activation-aware weight quantization for on-device llm compression and acceleration.
*Proceedings of Machine Learning and Systems*, 6:87–100, 2024b.
- Liu et al. [2024a]
Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al.
Deepseek-v3 technical report.
*arXiv preprint arXiv:2412.19437*, 2024a.
- Liu et al. [2024b]
Zechun Liu, Changsheng Zhao, Igor Fedorov, Bilge Soran, Dhruv Choudhary, Raghuraman Krishnamoorthi, Vikas Chandra, Yuandong Tian, and Tijmen Blankevoort.
Spinquant: Llm quantization with learned rotations.
*arXiv preprint arXiv:2405.16406*, 2024b.
- Malinovskii et al. [2024]
Vladimir Malinovskii, Denis Mazur, Ivan Ilin, Denis Kuznedelev, Konstantin Burlachenko, Kai Yi, Dan Alistarh, and Peter Richtarik.
Pv-tuning: Beyond straight-through estimation for extreme llm compression.
*Advances in Neural Information Processing Systems*, 37:5074–5121, 2024.
- Merity et al. [2016]
Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher.
Pointer sentinel mixture models.
*arXiv preprint arXiv:1609.07843*, 2016.
- Park et al. [2024]
Gunho Park, Baeseong Park, Minsub Kim, Sungjae Lee, Jeonghoon Kim, Beomseok Kwon, Se Jung Kwon, Byeongwook Kim, Youngjoo Lee, and Dongsoo Lee.
LUT-GEMM: quantized matrix multiplication based on luts for efficient inference in large-scale generative language models.
In *The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024*. OpenReview.net, 2024.
URL [https://openreview.net/forum?id=gLARhFLE0F](https://openreview.net/forum?id=gLARhFLE0F).
- Raffel et al. [2020]
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu.
Exploring the limits of transfer learning with a unified text-to-text transformer.
*Journal of machine learning research*, 21(140):1–67, 2020.
- Sakaguchi et al. [2021]
Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi.
Winogrande: An adversarial winograd schema challenge at scale.
*Communications of the ACM*, 64(9):99–106, 2021.
- Shao et al. [2023]
Wenqi Shao, Mengzhao Chen, Zhaoyang Zhang, Peng Xu, Lirui Zhao, Zhiqian Li, Kaipeng Zhang, Peng Gao, Yu Qiao, and Ping Luo.
Omniquant: Omnidirectionally calibrated quantization for large language models.
*arXiv preprint arXiv:2308.13137*, 2023.
- Touvron et al. [2023]
Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al.
Llama 2: Open foundation and fine-tuned chat models.
*arXiv preprint arXiv:2307.09288*, 2023.
- Tseng et al. [2024]
Albert Tseng, Jerry Chee, Qingyao Sun, Volodymyr Kuleshov, and Christopher De Sa.
Quip#: Even better llm quantization with hadamard incoherence and lattice codebooks.
*arXiv preprint arXiv:2402.04396*, 2024.
- Wang et al. [2024]
Lei Wang, Lingxiao Ma, Shijie Cao, Quanlu Zhang, Jilong Xue, Yining Shi, Ningxin Zheng, Ziming Miao, Fan Yang, Ting Cao, Yuqing Yang, and Mao Yang.
Ladder: Enabling efficient low-precision deep learning computing through hardware-aware tensor transformation.
In *18th USENIX Symposium on Operating Systems Design and Implementation (OSDI 24)*, pages 307–323, Santa Clara, CA, July 2024. USENIX Association.
ISBN 978-1-939133-40-3.
URL [https://www.usenix.org/conference/osdi24/presentation/wang-lei](https://www.usenix.org/conference/osdi24/presentation/wang-lei).
- Xiao et al. [2023]
Guangxuan Xiao, Ji Lin, Mickael Seznec, Hao Wu, Julien Demouth, and Song Han.
Smoothquant: Accurate and efficient post-training quantization for large language models.
In *International Conference on Machine Learning*, pages 38087–38099. PMLR, 2023.
- Yang et al. [2024]
An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al.
Qwen2. 5 technical report.
*arXiv preprint arXiv:2412.15115*, 2024.
- Zellers et al. [2019]
Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi.
Hellaswag: Can a machine really finish your sentence?
*arXiv preprint arXiv:1905.07830*, 2019.
- Zhang et al. [2024]
Aozhong Zhang, Naigang Wang, Yanxia Deng, Xin Li, Zi Yang, and Penghang Yin.
Magr: Weight magnitude reduction for enhancing post-training quantization.
*arXiv preprint arXiv:2406.00800*, 2024.
- Zhang and Shrivastava [2024]
Tianyi Zhang and Anshumali Shrivastava.
Leanquant: Accurate and scalable large language model quantization with loss-error-aware grid.
*arXiv preprint arXiv:2407.10032*, 2024.

## Appendix A Limitations of Min-Max Initialization

While practitioners widely adopt min-max initialization as a matter of convention, it is not optimal concerning quantization error—even under ideal conditions. To illustrate this, consider the following lemma:

###### Lemma 1 .

If weights are independently and uniformly drawn from an interval $[a,b]$, then the optimal parameters to for $k$-bit uniform quantization to minimize excepted quantization error $\mathbb{E}_{x\sim\mathcal{U}(a,b)}[(Q_{s,z}(x)-x)^{2}]$ are given by

$$ $s=\frac{b-a}{2^{k}},\quad z=\frac{a}{s}+\frac{1}{2}.$ (10) $$

The proof of Lemma [1](https://arxiv.org/html/2505.17595v2#Thmlemma1) is in Appendix [B](https://arxiv.org/html/2505.17595v2#A2). This result leads to a revised understanding of the low-error interval: it was previously defined as $[zs,(2^{k}-1+z)s]$, but is now more accurately characterized as $[(z-\frac{1}{2})s,(z+2^{k}-\frac{1}{2})s]$. Motivated by this observation, we propose an improved initialization strategy, termed Min-Max+, in which the quantization parameters are given by:

$$ $s=\frac{\text{max}(x)-\text{min}(x)}{2^{k}},\quad z=\left\lfloor\frac{\text{ min}(x)}{s}+\frac{1}{2}\right\rceil.$ (11) $$

Interestingly, Min-Max+ closely resembles the shrink-scale technique used in MagR, where a manually defined factor $\beta$ is used to shrink the scale, and the scale is computed as $s=\beta\cdot(\text{max}(x)-\text{min}(x))/(2^{k}-1)$. In contrast, Min-Max+ implicitly sets $\beta=(2^{k}-1)/2^{k}$ and simultaneously adjusts the zero-point to better align the low-error interval with the parameter range.

**Table 5: Comparison of Min-Max and Min-Max+. $\dagger$ indicates that use shrink-scale technique.**
| Method | Min-Max | Min-Max^† | Min-Max+ |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| scale ($s$) | $\frac{\text{max}(x)-\text{min}(x)}{2^{k}-1}$ | $\frac{\text{max}(x)-\text{min}(x)}{2^{k}}$ | $\frac{\text{max}(x)-\text{min}(x)}{2^{k}}$ |  |  |  |  |
| zero-point ($z$) | $\left\lfloor\frac{\text{min}(x)}{s}\right\rceil$ | $\left\lfloor\frac{\text{min}(x)}{s}\right\rceil$ | $\left\lfloor\frac{\text{min}(x)}{s}+\frac{1}{2}\right\rceil$ |  |  |  |  |
| Bits | Group | Wiki2 | C4 | Wiki2 | C4 | Wiki2 | C4 |
| 3 | 128 | 6.34 | 7.86 | 6.40 | 7.89 | 6.32 | 7.72 |
| 3 | - | 8.45 | 9.87 | 7.47 | 8.97 | 7.28 | 8.84 |
| 2 | 128 | 26.31 | 23.52 | 50.34 | 58.33 | 13.64 | 13.64 |
| 2 | - | 6953 | 2592 | 424 | 167 | 497 | 135 |

Empirically, this simple adjustment yields measurable improvements. Under real-world settings—such as GPTQ quantization of the LLaMA 2 7B model—Min-Max+ consistently outperforms both the traditional Min-Max initialization and the variant with only shrink scaling (i.e., without zero-point shifting), achieving lower perplexity. Detailed comparisons are in Table [5](https://arxiv.org/html/2505.17595v2#A1.T5).

###### Lemma 1 .

## Appendix B Proofs of Optimal Quantization Parameter and Lemma 1

We begin by relaxing the uniform quantization constraint that requires equal spacing between adjacent quantized values in the set $\mathcal{Q}$, allowing non-uniform spacing. However, the minimum error in the mean squared error objective is achieved when the spacing is uniform.

The expression for the expected quantization error takes the form

$$ $\mathcal{E}=\frac{1}{b-a}\sum_{i=0}^{N-1}\int_{b_{i}}^{b_{i+1}}(x-q_{i})^{2}\,dx,$ (12) $$

where $N=2^{k}$, $a=b_{0}<\cdots<b_{N}=b$, $q_{i}$ is the $i$-th quantized value and $[b_{i},b_{i+1})$ assumed to be quantized to $q_{i}$. The probability density function is given by $f_{X}(x)=1/(b-a)$.

For fixed interval, minimizing

$$ $\int_{b_{i}}^{b_{i+1}}(x-q_{i})^{2}\,dx$ (13) $$

requires solving

$$ $\frac{d}{dy}\int_{b_{i}}^{b_{i+1}}(x-q_{i})^{2}\,dx=\int_{b_{i}}^{b_{i+1}}-2(x -q_{i})\,dx=0,$ (14) $$

which gives

$$ $q_{i}^{*}=\frac{1}{b_{i+1}-b_{i}}\int_{b_{i}}^{b_{i+1}}x\,dx=\frac{b_{i}+b_{i+ 1}}{2}.$ (15) $$

The corresponding quantization error is

$$ $\int_{b_{i}}^{b_{i+1}}\left(x-\frac{b_{i}+b_{i+1}}{2}\right)^{2}dx=\frac{(b_{i +1}-b_{i})^{3}}{12}.$ (16) $$

Denote $\Delta_{i}=b_{i+1}-b_{i}>0$ with $\sum_{i=0}^{N-1}\Delta_{i}=b-a$. Then

$$ $\mathcal{E}=\frac{1}{12(b-a)}\sum_{i=0}^{N-1}\Delta_{i}^{3}.$ (17) $$

Since $g(\Delta)=\Delta^{3}$ is strictly convex for $\Delta>0$, Jensen’s inequality implies $\sum\Delta_{i}^{3}$ is minimized when all $\Delta_{i}$ are equal, i.e.

$$ $\Delta_{i}=\frac{b-a}{N}=\frac{b-a}{2^{k}}.$ (18) $$

Finally, the optimal uniform quantization parameters can be obtained by:

$$ $s=\Delta_{i}=\frac{b-a}{2^{k}},\quad z=\frac{q^{*}_{0}}{s}=\frac{b_{0}+b_{1}}{ 2s}=\frac{a+(a+s)}{2s}=\frac{a}{s}+\frac{1}{2}.$ (19) $$

## Appendix C Zero-Point Search Algorithms

Figure: Algorithm 2 Optimal Zero-Point Search over Smoothed Objective

Figure: Algorithm 3 Optimal Zero-Point Search over Piecewise Quadratic Function in Limited Interval

## Appendix D Implementation Details

### D.1 Setting

#### D.1.1 Calibration Stage

During the calibration stage, we follow the implementation of the official GPTQ repository,(^2^22[https://github.com/IST-DASLab/gptq](https://github.com/IST-DASLab/gptq)) and draw the same 128 samples from the C4 dataset for quantization calibration. For implementation convenience, we uniformly adopt bfloat16 for all experiments.
The token length of each sample is determined based on the characteristics and design intent of the target family. Especially for the LLaMA 2 family, each sample consists of 2048 tokens, consistent with the configurations adopted in GPTQ and LeanQuant. For the Qwen 2.5 models, each sample comprises 4096 tokens, as indicated in the Qwen 2.5 Technical Report [32], which specifies a 4096-token context length in its base configuration before context expansion. The same token length setting is applied to the LLaMA 3 family to ensure consistency.

#### D.1.2 Distillation Stage

In contrast to the calibration stage, the distillation utilizes 256 samples from the C4 dataset. The token lengths per sample remain consistent with those used during calibration. Furthermore, the computation precision remains bfloat16, identical to that in the calibration phase.

For the broader fine-tuning setup, we employ the AdamW optimizer with zero weight decay and momentum parameters set as $\beta=(0.9,0.95)$. The learning rate is chosen via grid search over five candidate values: 1e-5, 3e-5, 1e-4, 3e-4, and 1e-3. We apply a cosine learning rate scheduler with a 10% warm-up ratio.
In terms of hardware and infrastructure, we fine-tune LLaMA 2 7B in mixed precision using DeepSpeed(^3^33[https://github.com/microsoft/DeepSpeed](https://github.com/microsoft/DeepSpeed)), with batch size of 1 on a single NVIDIA A40 GPU.

#### D.1.3 Evaluation Stage

Regarding perplexity evaluation, we follow the procedure implemented in the official GPTQ repository, specifically the datautils.py(^4^44[https://github.com/IST-DASLab/gptq/blob/main/datautils.py](https://github.com/IST-DASLab/gptq/blob/main/datautils.py)) and
the llama.py(^5^55[https://github.com/IST-DASLab/gptq/blob/main/llama.py](https://github.com/IST-DASLab/gptq/blob/main/llama.py)) script. Perplexity scores are computed on the validation sets of the C4 and WikiText2 datasets, using the dataset identifiers c4 and wikitext2 as specified in the original implementation.

For zero-shot accuracy evaluation, we adopt the lm-evaluation-harness [9](^6^66[https://github.com/EleutherAI/lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness)), a standardized and extensible framework for evaluating language models across diverse tasks. Inference is conducted using vLLM [16] as the backend to ensure high throughput and memory efficiency. We evaluate five benchmark tasks: ARC-Easy, ARC-Challenge, WinoGrande, HellaSwag, and PIQA, whose corresponding identifiers in lm-evaluation-harness are arc_easy, arc_challenge, winogrande, hellaswag, and piqa, respectively.

### D.2 Quantization

We adopt the quantization strategy implemented in the official GPTQ repository.
Specifically, we perform sequential quantization by quantizing layers in the order of the model forward pass. Each layer receives inputs from the already quantized preceding layers rather than from the original model, ensuring that the quantization is based on realistic activation distributions that more closely resemble those encountered during inference.
Furthermore, we conduct the entire quantization process under full-precision settings to ensure numerical stability. For NeUQI, the grid search over the scale hyperparameter is conducted with $T=2048$ and $T_{c}=64$.

### D.3 GPTQ

We implement the GPTQ [8] method using the LDLQ [5] approach. The mathematical proof of their equivalence is in Appendix [D.3.3](https://arxiv.org/html/2505.17595v2#A4.SS3.SSS3).
Moreover, LDLQ is computationally more efficient, as it requires fewer matrix operations and avoids the numerically unstable process of matrix inversion.

#### D.3.1 GPTQ Implementation

GPTQ builds upon the principle of Optimal Brain Surgeon (OBS) [12], designed for pruning. OBS applies a Taylor expansion of the loss function around the original weight $w$. Under the assumption that the model has reached convergence, the first-order term vanishes as a result of the stationarity condition, and higher-order terms of order three and above are considered negligible. Therefore, the dominant contribution is given by:

$$ $\mathcal{L}(\hat{w})\approx\frac{1}{2}(\hat{w}-w)^{\top}\frac{\partial^{2} \mathcal{L}}{\partial\hat{w}^{2}}(\hat{w}-w)+\mathcal{L}(w)$ (20) $$

The quantization loss for a single-row in linear layer is the squared $\ell_{2}$-norm between the quantized output and the original output:

$$ $\mathcal{L}(\hat{w})=\frac{1}{2}\|X\hat{w}-Xw\|_{2}^{2},$ (21) $$

where $\hat{w}$ denotes the quantized weight vector and $w$ represents the original weight vector. This formulation follows a standard least-squares loss structure. The Hessian matrix of this loss with respect to $\hat{w}$ is computed as:

$$ $\nabla^{2}_{\hat{w}}\mathcal{L}(\hat{w})=\frac{\partial^{2}}{\partial\hat{w}^{ 2}}\frac{1}{2}\|X\hat{w}-Xw\|_{2}^{2}=X^{\top}X.$ (22) $$

Thus, the matrix $H$, representing the Hessian matrix, is given by:

$$ $H=\nabla^{2}_{\hat{w}}\mathcal{L}(\hat{w})=X^{\top}X.$ (23) $$

To ensure that the Hessian matrix $H$ is positive definite, it is common practice to add a small scalar $\lambda>0$ to its diagonal entries. This modification is equivalent to augmenting the quantization loss with a regularization term $\frac{\lambda}{2}\|\hat{w}-w\|^{2}$, which penalizes large deviations between the quantized weights $\hat{w}$ and the original weights $w$. In practice, $\lambda$ is set to $0.01$ times the mean of the diagonal entries of $H$, following GPTQ.

Given this formulation, we consider the problem of quantizing a single column vector $w$ from the weight matrix. Specifically, let us focus on quantizing the element at a particular position $p$ within the vector $w$. In other words, $w_{p}$ denotes the scalar entry at the $p$-th position of $w$.
We define a compensation vector $\delta^{p}$, which compensates for the quantization-induced error in $w$ resulting from quantizing $w_{p}$. In this formulation, the update at coordinate $p$ reflects the quantization of $w_{p}$, while changes at other coordinates are to compensate for the loss caused by this quantization. The quantized vector is then given by $\hat{w}=w+\delta^{p}$, with the constraint that the $p$-th coordinate of $\hat{w}$ matches the quantized value. Accordingly, we solve the following optimization problem:

$$ $\displaystyle\text{min}_{\delta^{p}}$ $\displaystyle\quad(\delta^{p})^{\top}H\delta^{p}$ (24) s.t. $\displaystyle\quad e_{p}^{\top}\delta^{p}=\hat{w}_{p}-w_{p}$ $$

Using the method of Lagrange multipliers, we construct the Lagrangian:

$$ $\mathcal{L}(\delta^{p},\lambda)=(\delta^{p})^{\top}H\delta^{p}+\lambda\left(e_ {p}^{\top}\delta^{p}-(\hat{w}_{p}-w_{p})\right)$ (25) $$

Taking the gradient with respect to $\delta^{p}$ and setting it to zero:

$$ $\nabla_{\delta^{p}}\mathcal{L}=2H\delta^{p}+\lambda e_{p}=0\quad\Rightarrow \quad\delta^{p}=-\frac{\lambda}{2}H^{-1}e_{p}$ (26) $$

Substituting back into the constraint:

$$ $e_{p}^{\top}\delta^{p}=-\frac{\lambda}{2}e_{p}^{\top}H^{-1}e_{p}=\hat{w}_{p}-w _{p}\quad\Rightarrow\quad\lambda=-\frac{2(\hat{w}_{p}-w_{p})}{(H^{-1})_{pp}}$ (27) $$

Thus, we obtain:

$$ $\delta^{p}=\frac{(\hat{w}_{p}-w_{p})}{(H^{-1})_{pp}}H^{-1}e_{p},\quad\mathcal{ L}(\delta^{p})=\frac{(\hat{w}_{p}-w_{p})^{2}}{(H^{-1})_{pp}}$ (28) $$

Based on this result, we can adopt a greedy strategy: at each iteration, the position $p$ that results in the minimal increase in quantization loss $\mathcal{L}(\delta^{p})$ is selected, the corresponding update is applied. However, to better utilize GPU parallelism and improve computational efficiency, we follow a heuristic implemented in the GPTQ repository, specifically in the gptq.py script (^7^77[https://github.com/IST-DASLab/gptq/blob/main/gptq.py](https://github.com/IST-DASLab/gptq/blob/main/gptq.py)). In this approach, the indices are sorted and traversed in decreasing order of the Hessian diagonals $H_{pp}$.

Assuming we fix a quantization order $i=0,1,\ldots,n-1$, we define:

$$ $\delta^{i}_{i:}=\frac{(H_{i:,i:})^{-1}e_{i}}{((H_{i:,i:})^{-1})_{ii}},\quad \delta^{i}_{:i}=\textbf{0}$ (29) $$

where, $\delta^{i}$ denotes the update basis vector for position $i$, satisfying $(\delta^{i})_{i}=1$. The actual update applied to the weight vector is $(\hat{w}_{i}-w_{i})\delta^{i}$.

For any $j\geq i$, we have:

$$ $H_{j,:}\delta^{i}=e_{j}^{\top}H_{i:,i:}\left(\frac{(H_{i:,i:})^{-1}e_{i}}{((H_ {i:,i:})^{-1})_{ii}}\right)=1_{i=j}\left(((H_{i:,i:})^{-1})_{ii}\right)^{-1}$ (30) $$

Therefore, the update matrix satisfies:

$$ $H\Delta=U,$ (31) $$

where $\Delta=[\delta^{0},\delta^{1},\ldots,\delta^{n-1}]$ is a unit lower-triangular matrix, and the resulting matrix $U$ is upper-triangular because for $j>i$, $U_{j,i}=0$.

This relation implies that $H$ can be factorized as

$$ $H=U\Delta^{-1},$ (32) $$

which corresponds to a UL decomposition of $H$, where $\Delta^{-1}$ is unit lower-triangular. On the other hand, the Hessian matrix $H$ is positive-definite and thus admits a unique LDL decomposition of the form

$$ $H=(L^{\top}D)L,$ (33) $$

where $L$ is also a unit lower-triangular matrix and $D$ is diagonal matrix.

Since both ([32](https://arxiv.org/html/2505.17595v2#A4.E32)) and ([33](https://arxiv.org/html/2505.17595v2#A4.E33)) represent decompositions of the same matrix $H$ with a unit lower-triangular factor on the right, and the unit lower-triangular factor in such factorizations is unique for positive-definite matrices, we conclude that $\Delta=L^{-1}$.

Finally, the algorithm is as follows:

Figure: Algorithm 4 GPTQ Quantization

#### D.3.2 LDLQ Implementation

LDLQ is a newly proposed method introduced in QuIP [5], which has been empirically validated to be equivalent to GPTQ. It provides an alternative understanding of the GPTQ algorithm through a structurally distinct formulation. Specifically, when quantizing a single row of the weight matrix, LDLQ proceeds coordinate-wise in a fixed order: each coordinate is quantized one at a time, and the unquantized coordinates are adjusted to compensate for the quantization error. This process is captured through a strictly lower-triangular compensation matrix $L$, which defines the final quantized weights via

$$ $\hat{w}=Q(\tilde{w}),\quad\tilde{w}=w-L(\hat{w}-w)$ (34) $$

The quantization-induced error is

$$ $\eta=\hat{w}-\tilde{w}=(I+L)(\hat{w}-w)$ (35) $$

Solving for $\hat{w}-w$ yields

$$ $\hat{w}-w=(I+L)^{-1}\eta$ (36) $$

Substituting into the original quadratic loss function gives

$$ $\mathcal{L}(\hat{w})=\eta^{\top}(I+L)^{-\top}H(I+L)^{-1}\eta$ (37) $$

Given the LDL decomposition $H=L^{\prime\top}DL^{\prime}$, LDLQ claims that the minimal loss is achieved when $I+L=L^{\prime}$, resulting in

$$ $\mathcal{L}(\hat{w})=\eta^{\top}D\eta$ (38) $$

This diagonalization simplifies the loss into a weighted squared norm of the quantization error, enabling an efficient sequential update procedure as described below:

Figure: Algorithm 5 LDLQ Quantization

#### D.3.3 Equivalence between GPTQ and LDLQ

The following interpretation reinforces the equivalence between GPTQ and LDLQ. In particular, we can rewrite the GPTQ formulation as follows:

$$ $\hat{w}=Q(\tilde{w}),\quad\tilde{w}=w+(\Delta-I)(\hat{w}-\tilde{w})$ (39) $$

We can derive a more explicit form of $\tilde{w}$ by manipulating the second equation in ([39](https://arxiv.org/html/2505.17595v2#A4.E39)) as follows:

$$ $\displaystyle\tilde{w}$ $\displaystyle=w+(\Delta-I)(\hat{w}-\tilde{w})$ (40) $\displaystyle\Delta\tilde{w}$ $\displaystyle=w+(\Delta-I)\hat{w}$ (41) $\displaystyle\tilde{w}$ $\displaystyle=\Delta^{-1}w+(I-\Delta^{-1})\hat{w}$ (42) $\displaystyle\tilde{w}$ $\displaystyle=w-(\Delta^{-1}-I)(\hat{w}-w)$ (43) $$

On the other hand, the LDLQ formulation is given by:

$$ $\tilde{w}=w-(L^{\prime}-I)(\hat{w}-w)$ (44) $$

By comparing equations ([43](https://arxiv.org/html/2505.17595v2#A4.E43)) and ([44](https://arxiv.org/html/2505.17595v2#A4.E44)), we observe that the two formulations become equivalent if $\Delta^{-1}=L^{\prime}$. As established in the previous two sections, both $\Delta^{-1}$ and $L^{\prime}$ correspond to the $L$ factor derived from the LDL decomposition. Therefore, LDLQ is mathematically equivalent to GPTQ.

### D.4 MagR

For MagR [34], we strictly follow the original settings, including using the hyperparameter $a$ of 1e-3 for channel-wise quantization and 1e-4 for group-wise quantization, as well as adopting the shrink-scale technique with the same $\beta$ value as in the original paper.

### D.5 Difference between LeanQuant and NeUQI with Integer Constraint

LeanQuant${}_{\textit{aff}}$ [35] and NeUQI${}_{\text{int}}$ adopt a loss formulation of the form

$$ $\mathcal{L}(s,z)=\sum_{i}h_{i}(Q_{s,z}(w_{i})-w_{i})^{2},$ (45) $$

but differ fundamentally in how the weight importance $h_{i}$ is defined and how to find the optimal scale and zero-point.

In LeanQuant${}_{\textit{aff}}$, the definition of $h_{i}$ is inspired by the objective used in the first step of GPTQ, which selects the optimal quantization point by minimizing

$$ $\frac{(Q_{s,z}(w_{i})-w_{i})^{2}}{(H^{-1})_{ii}},$ (46) $$

leading to $h_{i}=((H^{-1})_{ii})^{-1}$, and further generalized to $h_{i}=((H^{-1})_{ii})^{-p}$ with a tunable strength parameter $p$. In contrast, $\text{NeUQI}_{\text{int}}$ adopts a diagonal loss approximation by directly setting $h_{i}=H_{ii}$, avoiding the need to invert the Hessian matrix.

The methods also differ in parameter search strategies.
However, LeanQuant${}_{\textit{aff}}$ still operates within the Min-Max paradigm—its grid search essentially enumerates different min and max values, from which they derive the scale and zero-point using the standard Min-Max formula, with a time complexity of $\mathcal{O}(T^{2}n)$, where $T$ (typically 2048) denotes the number of grid points and $n$ the number of weights.
In contrast, $\text{NeUQI}_{\text{int}}$ employs a grid search over candidate scale values, with the zero-point constrained to be a $k$-bit unsigned integer. A simple implementation of this scale-based search has a time complexity of $\mathcal{O}(Tn2^{k})$.
To further accelerate initialization, we identify a more efficient alternative by switching the search perspective from scale to zero-point. For a fixed zero-point, the objective remains a piecewise quadratic function of the scale, similar to the case discussed in Section [4.2](https://arxiv.org/html/2505.17595v2#S4.SS2), which enables an optimized search using a similar method with total complexity reduced to $\mathcal{O}(2^{k}\cdot n2^{k}\log(n2^{k}))$, which is independent of $T$ and scales better in practice.

### D.6 PV-tuning

For training with uniform quantization, we set the learning rate of the quantization parameters to the optimal value determined in our lightweight distillation experiments. The learning rate for quantized weights is selected via grid search from the set $\{30\times,10\times,3\times\}$ of the learning rate of the quantization parameters, consistent with the approach used in PV-tuning [22]. We also adopted PV-Tuning’s constraint that the L2-norm of each quantization update should not exceed 1% of the corresponding weight’s L2-norm. All other components remained consistent with our lightweight distillation framework.

## Appendix E Broader Impact

Large language models are inherently dual-use technologies, enabling beneficial applications and potential misuse. While our method does not enhance model capabilities, it facilitates broader deployment by reducing quantization-induced errors and improving consistency with the original model. This contributes to more reliable and trustworthy outputs, potentially lowering the risk of unintended behaviors such as hallucinations or misleading responses.

## Appendix F Limitations

Although we do not compare NeUQI with other quantization methods based on weight and activation transformations or fine-tuning, we believe our main experiments are sufficient to validate the effectiveness of our approach. These alternative methods typically require additional training or model modifications and adopt fundamentally different design principles. As such, they are orthogonal to our NeUQI and could be integrated with NeUQI to achieve further improvements, which we leave as an avenue for future work.
Our scheme supports arbitrary zero-points, which may not align with inference kernels such as ExLlamaV2(^8^88[https://github.com/turboderp-org/exllamav2](https://github.com/turboderp-org/exllamav2)). Nonetheless, NeUQI is fully compatible with flexible backends like FLUTE [11], LUT-GEMM [24], and BitBLAS [30], which support mixed precision or lookup-based matrix multiplication.

## Appendix G Supplementary Results

This appendix presents supplementary quantization results.
Detailed results on 2-bit quantization with group size 128 for LLaMA and Qwen families are shown in Table [6](https://arxiv.org/html/2505.17595v2#A7.T6).
Detailed results on 3-bit and 4-bit quantization settings for LLaMA 2, Qwen 2.5 and LLaMA 3 families are shown in Table [7](https://arxiv.org/html/2505.17595v2#A7.T7), Table [8](https://arxiv.org/html/2505.17595v2#A7.T8) and Table [9](https://arxiv.org/html/2505.17595v2#A7.T9), respectively.
Quantization overhead for LLaMA 2 family are shown in Table [10](https://arxiv.org/html/2505.17595v2#A7.T10).

**Table 6: Results of 2-bit group-wise quantization with group size of 128 on the LLaMA 2, LLaMA 3, and Qwen 2.5 families.**
| Size | Bits | Method | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLaMA 2 Family |  |  |  |  |  |  |  |  |  |  |
| 7B | 2 | GPTQ | 26.31 | 23.52 | 22.70 | 36.91 | 34.39 | 60.50 | 54.62 | 41.82 |
| MagR | 15.41 | 15.59 | 24.66 | 47.90 | 39.19 | 65.89 | 58.80 | 47.29 |  |  |
| NeUQI | 12.35 | 13.48 | 25.26 | 59.72 | 40.71 | 69.64 | 61.33 | 51.33 |  |  |
| 13B | 2 | GPTQ | 12.50 | 13.16 | 26.54 | 53.58 | 42.00 | 68.34 | 55.01 | 49.09 |
| MagR | 17.15 | 11.35 | 30.46 | 61.74 | 45.72 | 71.60 | 60.62 | 54.03 |  |  |
| NeUQI | 8.82 | 10.60 | 35.32 | 67.72 | 45.98 | 73.12 | 68.59 | 58.15 |  |  |
| 70B | 2 | GPTQ | 7.04 | 8.62 | 38.48 | 70.20 | 53.00 | 75.14 | 69.93 | 61.35 |
| MagR | 10.87 | 9.21 | 41.89 | 68.64 | 55.13 | 68.50 | 73.64 | 61.56 |  |  |
| NeUQI | 5.60 | 7.51 | 47.53 | 77.86 | 56.90 | 78.24 | 75.53 | 67.21 |  |  |
| LLaMA 3 Family |  |  |  |  |  |  |  |  |  |  |
| 8B | 2 | GPTQ | 210 | 121 | 19.54 | 28.91 | 26.94 | 54.73 | 51.62 | 36.35 |
| MagR | 61.71 | 74.78 | 18.43 | 33.80 | 28.72 | 56.69 | 51.70 | 37.87 |  |  |
| NeUQI | 28.90 | 26.83 | 23.29 | 50.04 | 36.04 | 63.38 | 59.91 | 46.53 |  |  |
| 70B | 2 | GPTQ | 26.25 | 28.59 | 22.27 | 38.80 | 34.61 | 61.04 | 55.41 | 42.43 |
| MagR | 30.86 | 55.42 | 26.71 | 51.56 | 40.78 | 67.74 | 64.56 | 50.27 |  |  |
| NeUQI | 10.75 | 14.40 | 39.68 | 71.30 | 48.66 | 74.05 | 70.56 | 60.85 |  |  |
| Qwen 2.5 Family |  |  |  |  |  |  |  |  |  |  |
| 7B | 2 | GPTQ | 21.66 | 22.77 | 23.72 | 43.43 | 39.32 | 62.02 | 53.75 | 44.45 |
| MagR | 13.65 | 16.56 | 30.46 | 61.95 | 43.88 | 68.50 | 60.30 | 53.02 |  |  |
| NeUQI | 14.43 | 16.65 | 36.26 | 67.76 | 45.56 | 71.55 | 65.04 | 57.23 |  |  |
| 14B | 2 | GPTQ | 18.62 | 19.22 | 22.95 | 42.80 | 38.38 | 61.97 | 51.62 | 43.54 |
| MagR | 12.94 | 14.09 | 28.33 | 56.57 | 44.52 | 70.40 | 60.77 | 52.12 |  |  |
| NeUQI | 10.57 | 13.61 | 43.52 | 75.63 | 50.26 | 74.92 | 72.30 | 63.32 |  |  |
| 32B | 2 | GPTQ | 10.95 | 13.36 | 30.38 | 59.30 | 47.56 | 71.38 | 56.59 | 53.04 |
| MagR | 8.82 | 11.65 | 36.69 | 69.57 | 52.23 | 75.57 | 64.40 | 59.69 |  |  |
| NeUQI | 8.51 | 11.41 | 46.08 | 76.39 | 55.86 | 78.02 | 75.14 | 66.30 |  |  |
| 72B | 2 | GPTQ | 10.35 | 12.27 | 35.49 | 63.51 | 50.11 | 72.36 | 59.35 | 56.17 |
| MagR | 11.00 | 11.22 | 44.37 | 75.88 | 56.58 | 77.31 | 71.59 | 65.15 |  |  |
| NeUQI | 6.63 | 9.97 | 51.88 | 81.61 | 59.23 | 79.87 | 75.69 | 69.66 |  |  |

**Table 7: Results for LLaMA 2 family models at bfloat16 precision, as well as for the 3-bit, 3-bit with a group size of 128, 4-bit, and 4-bit with a group size of 128 quantized models.**
| Size | Bits | Group | Method | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 7B | 16 | - | - | 5.12 | 6.63 | 43.34 | 76.26 | 57.17 | 77.97 | 68.98 | 64.74 |
| 4 | 128 | GPTQ | 5.62 | 7.12 | 43.52 | 75.55 | 56.27 | 77.48 | 69.85 | 64.53 |  |
| NeUQI | 5.60 | 7.09 | 42.92 | 75.17 | 56.19 | 77.64 | 69.46 | 64.27 |  |  |  |
| - | GPTQ | 5.84 | 7.36 | 41.64 | 74.16 | 55.84 | 77.69 | 69.85 | 63.84 |  |  |
| NeUQI | 5.80 | 7.26 | 41.89 | 74.87 | 54.78 | 76.77 | 68.51 | 63.36 |  |  |  |
| 3 | 128 | GPTQ | 6.34 | 7.86 | 39.76 | 73.74 | 53.91 | 77.31 | 67.48 | 62.44 |  |
| NeUQI | 6.07 | 7.58 | 38.57 | 72.35 | 54.19 | 76.44 | 67.48 | 61.81 |  |  |  |
| - | GPTQ | 8.45 | 9.87 | 34.73 | 66.46 | 49.08 | 73.34 | 64.40 | 57.60 |  |  |
| NeUQI | 6.56 | 8.10 | 37.97 | 71.42 | 50.75 | 75.41 | 68.19 | 60.75 |  |  |  |
| 13B | 16 | - | - | 4.57 | 6.05 | 48.21 | 79.46 | 60.09 | 79.11 | 72.30 | 67.83 |
| 4 | 128 | GPTQ | 5.00 | 6.56 | 47.70 | 78.28 | 59.61 | 78.62 | 72.53 | 67.35 |  |
| NeUQI | 4.98 | 6.56 | 47.10 | 79.21 | 59.55 | 79.11 | 72.30 | 67.45 |  |  |  |
| - | GPTQ | 5.15 | 6.71 | 44.97 | 77.44 | 58.88 | 77.91 | 71.27 | 66.09 |  |  |
| NeUQI | 5.09 | 6.67 | 45.31 | 77.86 | 58.64 | 78.13 | 71.19 | 66.23 |  |  |  |
| 3 | 128 | GPTQ | 5.43 | 7.05 | 45.22 | 77.23 | 58.14 | 77.69 | 70.72 | 65.80 |  |
| NeUQI | 5.32 | 6.91 | 45.82 | 78.32 | 57.79 | 78.40 | 72.77 | 66.62 |  |  |  |
| - | GPTQ | 6.46 | 8.03 | 38.91 | 73.48 | 55.18 | 76.39 | 68.35 | 62.46 |  |  |
| NeUQI | 5.70 | 7.25 | 42.75 | 75.84 | 56.06 | 77.64 | 70.72 | 64.60 |  |  |  |
| 70B | 16 | - | - | 3.12 | 4.97 | 54.52 | 82.66 | 64.76 | 82.15 | 77.43 | 72.30 |
| 4 | 128 | GPTQ | 3.42 | 5.58 | 54.69 | 82.74 | 64.45 | 81.83 | 77.19 | 72.18 |  |
| NeUQI | 3.41 | 5.58 | 54.95 | 82.83 | 64.29 | 82.05 | 77.98 | 72.42 |  |  |  |
| - | GPTQ | 3.59 | 5.68 | 54.27 | 81.99 | 64.16 | 82.15 | 77.19 | 71.95 |  |  |
| NeUQI | 3.47 | 5.62 | 54.35 | 83.08 | 64.04 | 81.66 | 78.53 | 72.33 |  |  |  |
| 3 | 128 | GPTQ | 3.87 | 5.86 | 53.24 | 81.57 | 63.16 | 81.61 | 77.43 | 71.40 |  |
| NeUQI | 3.71 | 5.77 | 54.95 | 82.45 | 62.99 | 81.99 | 77.03 | 71.88 |  |  |  |
| - | GPTQ | 4.83 | 6.57 | 49.15 | 79.38 | 60.60 | 80.36 | 74.35 | 68.77 |  |  |
| NeUQI | 3.90 | 5.90 | 53.50 | 83.00 | 62.58 | 81.61 | 76.72 | 71.48 |  |  |  |

**Table 8: Results for LLaMA 3 family models at bfloat16 precision, as well as for the 3-bit, 3-bit with a group size of 128, 4-bit, and 4-bit with a group size of 128 quantized models.**
| Size | Bits | Group | Method | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 8B | 16 | - | - | 5.76 | 8.32 | 50.34 | 80.22 | 60.19 | 79.60 | 73.64 | 68.80 |
| 4 | 128 | GPTQ | 6.19 | 8.99 | 47.61 | 77.86 | 59.06 | 77.75 | 73.88 | 67.23 |  |
| NeUQI | 6.12 | 8.87 | 50.00 | 80.18 | 59.53 | 78.67 | 74.90 | 68.66 |  |  |  |
| - | GPTQ | 6.97 | 9.95 | 44.54 | 77.27 | 57.87 | 77.15 | 73.32 | 66.03 |  |  |
| NeUQI | 6.67 | 9.41 | 47.10 | 77.69 | 58.13 | 79.54 | 74.59 | 67.41 |  |  |  |
| 3 | 128 | GPTQ | 8.30 | 11.50 | 40.19 | 71.84 | 54.43 | 76.22 | 70.72 | 62.68 |  |
| NeUQI | 7.45 | 10.49 | 46.50 | 79.34 | 55.28 | 77.69 | 73.48 | 66.46 |  |  |  |
| - | GPTQ | 19.03 | 29.26 | 25.34 | 46.25 | 43.02 | 62.84 | 59.91 | 47.47 |  |  |
| NeUQI | 9.70 | 11.61 | 43.77 | 76.30 | 53.87 | 77.20 | 71.35 | 64.50 |  |  |  |
| 70B | 16 | - | - | 2.68 | 5.88 | 60.49 | 86.95 | 66.37 | 82.48 | 80.90 | 75.44 |
| 4 | 128 | GPTQ | 3.40 | 6.41 | 57.76 | 85.14 | 66.00 | 82.05 | 80.03 | 74.20 |  |
| NeUQI | 3.17 | 6.25 | 58.02 | 84.76 | 65.82 | 82.43 | 80.90 | 74.39 |  |  |  |
| - | GPTQ | 1486 | 1404 | 19.97 | 25.21 | 30.47 | 52.94 | 50.83 | 35.88 |  |  |
| NeUQI | 4.90 | 10.00 | 51.96 | 80.47 | 62.29 | 79.49 | 63.61 | 67.57 |  |  |  |
| 3 | 128 | GPTQ | 5.30 | 8.33 | 51.37 | 80.93 | 62.73 | 80.90 | 75.53 | 70.29 |  |
| NeUQI | 4.63 | 7.58 | 54.52 | 83.42 | 62.50 | 80.47 | 80.03 | 72.19 |  |  |  |
| - | GPTQ | 2645 | 1111 | 20.82 | 25.04 | 26.16 | 52.18 | 51.22 | 35.08 |  |  |
| NeUQI | 9.04 | 13.36 | 35.84 | 69.11 | 52.97 | 71.82 | 55.80 | 57.11 |  |  |  |

**Table 9: Results for Qwen 2.5 family models at bfloat16 precision, as well as for the 3-bit, 3-bit with a group size of 128, 4-bit, and 4-bit with a group size of 128 quantized models.**
| Size | Bits | Group | Method | Wiki2↓ | C4↓ | ArcC↑ | ArcE↑ | HellaS↑ | PiQA↑ | WinoG↑ | Acc↑ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 7B | 16 | - | - | 6.39 | 10.02 | 48.29 | 80.56 | 60.00 | 78.67 | 72.69 | 68.04 |
| 4 | 128 | GPTQ | 6.61 | 10.19 | 48.21 | 80.35 | 59.24 | 79.05 | 71.35 | 67.64 |  |
| NeUQI | 6.55 | 10.17 | 48.63 | 80.98 | 59.36 | 78.67 | 73.95 | 68.32 |  |  |  |
| - | GPTQ | 7.06 | 10.61 | 46.59 | 79.25 | 58.08 | 78.56 | 68.59 | 66.21 |  |  |
| NeUQI | 6.82 | 10.42 | 48.55 | 79.38 | 58.63 | 78.78 | 71.90 | 67.45 |  |  |  |
| 3 | 128 | GPTQ | 7.42 | 10.94 | 43.77 | 75.63 | 56.71 | 77.37 | 65.75 | 63.85 |  |
| NeUQI | 7.14 | 10.80 | 46.42 | 80.05 | 56.46 | 78.35 | 70.40 | 66.34 |  |  |  |
| - | GPTQ | 10.73 | 13.90 | 39.33 | 71.21 | 50.16 | 73.29 | 60.77 | 58.95 |  |  |
| NeUQI | 8.64 | 11.72 | 44.80 | 76.77 | 55.15 | 77.97 | 70.96 | 65.13 |  |  |  |
| 14B | 16 | - | - | 4.93 | 8.75 | 55.80 | 82.37 | 63.38 | 81.07 | 74.66 | 71.46 |
| 4 | 128 | GPTQ | 5.29 | 8.93 | 54.35 | 81.94 | 62.94 | 80.96 | 74.98 | 71.03 |  |
| NeUQI | 5.20 | 8.89 | 56.40 | 83.25 | 62.78 | 81.01 | 75.61 | 71.81 |  |  |  |
| - | GPTQ | 5.80 | 9.24 | 52.73 | 81.44 | 62.27 | 80.20 | 74.98 | 70.32 |  |  |
| NeUQI | 5.46 | 9.05 | 52.56 | 81.10 | 62.62 | 80.36 | 77.19 | 70.77 |  |  |  |
| 3 | 128 | GPTQ | 6.29 | 9.63 | 48.55 | 79.38 | 60.06 | 79.16 | 72.14 | 67.86 |  |
| NeUQI | 5.91 | 9.42 | 52.90 | 81.02 | 60.71 | 80.90 | 76.72 | 70.45 |  |  |  |
| - | GPTQ | 8.48 | 11.61 | 38.82 | 67.21 | 54.22 | 75.52 | 65.51 | 60.26 |  |  |
| NeUQI | 6.82 | 9.89 | 50.17 | 80.43 | 59.39 | 79.54 | 76.09 | 69.12 |  |  |  |
| 32B | 16 | - | - | 4.67 | 8.59 | 53.16 | 80.51 | 65.00 | 81.99 | 75.69 | 71.27 |
| 4 | 128 | GPTQ | 4.87 | 8.69 | 54.10 | 81.44 | 64.59 | 80.69 | 75.93 | 71.35 |  |
| NeUQI | 4.82 | 8.68 | 53.24 | 80.26 | 64.71 | 81.18 | 76.64 | 71.20 |  |  |  |
| - | GPTQ | 5.23 | 8.89 | 51.19 | 79.29 | 63.96 | 80.41 | 75.45 | 70.06 |  |  |
| NeUQI | 4.98 | 8.77 | 53.07 | 81.48 | 64.46 | 81.77 | 77.35 | 71.63 |  |  |  |
| 3 | 128 | GPTQ | 5.63 | 9.11 | 51.11 | 79.50 | 62.83 | 80.36 | 75.14 | 69.79 |  |
| NeUQI | 5.30 | 8.99 | 51.71 | 82.07 | 62.92 | 80.90 | 76.40 | 70.80 |  |  |  |
| - | GPTQ | 7.21 | 10.36 | 44.03 | 74.96 | 58.75 | 77.97 | 66.22 | 64.38 |  |  |
| NeUQI | 5.85 | 9.31 | 51.19 | 80.98 | 62.30 | 80.14 | 75.14 | 69.95 |  |  |  |
| 72B | 16 | - | - | 3.64 | 7.75 | 58.11 | 84.76 | 67.59 | 82.10 | 77.35 | 73.98 |
| 4 | 128 | GPTQ | 3.82 | 7.85 | 57.51 | 84.60 | 67.14 | 82.26 | 78.06 | 73.91 |  |
| NeUQI | 3.78 | 7.83 | 57.51 | 84.47 | 67.16 | 81.99 | 78.93 | 74.01 |  |  |  |
| - | GPTQ | 4.17 | 8.35 | 55.38 | 84.68 | 66.68 | 81.66 | 77.90 | 73.26 |  |  |
| NeUQI | 3.95 | 7.91 | 58.02 | 84.34 | 66.81 | 82.15 | 77.90 | 73.85 |  |  |  |
| 3 | 128 | GPTQ | 4.55 | 8.53 | 55.97 | 83.92 | 65.66 | 80.79 | 77.74 | 72.82 |  |
| NeUQI | 4.26 | 8.11 | 54.52 | 83.75 | 65.85 | 82.21 | 78.06 | 72.88 |  |  |  |
| - | GPTQ | 6.89 | 9.96 | 46.93 | 78.03 | 61.51 | 78.62 | 71.43 | 67.30 |  |  |
| NeUQI | 4.99 | 8.37 | 56.40 | 83.75 | 64.92 | 81.83 | 78.45 | 73.07 |  |  |  |

**Table 10: Quantization overhead (in hours) for LLaMA 2 family under different configurations in a single NVIDIA A40.**
| Size | 7B | 7B | 13B | 13B | 70B | 70B |
| --- | --- | --- | --- | --- | --- | --- |
| Group | 128 | - | 128 | - | 128 | - |
| GPTQ | 0.21 | 0.15 | 0.30 | 0.26 | 1.42 | 1.28 |
| NeUQI | 0.45 | 0.50 | 0.81 | 0.88 | 4.04 | 4.88 |

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: - Is the lightweight distillation strategy incorporated into NeUQI in Table 3?
- Can the proposed method be extended to MoE-based models?
soundness: 3
strengths: - The paper identifies and tackles an underexplored but critical aspect of post-training quantization: the initialization of quantization parameters (i.e., scaling-factor and zero-point). By moving beyond the traditional Min-Max initialization, the proposed NeUQI method provides a principled and efficient way to find near-optimal initialization, leading to consistent performance gains across multiple LLMs.
- Extensive experiments on LLaMA and Qwen model families demonstrate that NeUQI achieves SOTA results in various settings.
summary: This paper addresses the deployment challenges of large language models (LLMs) on resource-limited devices caused by their high memory and computation demands. It focuses on post-training quantization (PTQ) with uniform quantization, which is hardware-friendly and widely supported. The authors observe that prior work has improved quantization techniques but largely neglected how quantization parameters are initialized, which typically relies on the suboptimal Min–Max strategy. To overcome this, they propose NeUQI, an efficient method for finding near-optimal initialization of uniform quantization parameters. Experiments on LLaMA and Qwen models show that NeUQI consistently outperforms existing PTQ approaches.
weaknesses: - Some methodological details are missing. In Eq. (3), the quantized weights appear not to be explicitly optimized, the loss function only involves the scaling factor and zero-point. In contrast, GPTQ explicitly updates weights through a reconstruction step. Please clarify how the quantized weights are incorporated into the optimization process and whether they are updated similarly. 
- The paper lacks an ablation study evaluating the effect of using a floating-point zero-point. Since this design choice deviates from conventional integer quantization schemes, an analysis of its contribution to performance would strengthen the paper.
- The writing could be improved for clarity and accessibility. In the Abstract and Introduction, the description remains overly high-level. For instance, mentioning the replacement of the Min–Max scheme with a “better initialization” without concrete details. As a result, readers cannot grasp the essence of the proposed method until well into Section 4. It is recommended to summarize the key technical innovations and intuitions earlier to enhance readability and highlight the paper’s novelty.

---

confidence: 3
contribution: 3
initial_rating: 4
presentation: 3
questions: see above.
soundness: 3
strengths: The paper highlights the role of parameter initialization — and convincingly argues that initialization quality strongly affects quantization performance. By systematically reformulating the initialization problem and relaxing integer constraints, the proposed NeUQI provides an efficient and theoretically grounded approach. The experimental results are competitive. The inclusion of lightweight distillation further enhances the practical significance of the method.
summary: This paper presents NeUQI, a parameter initialization algorithm for uniform quantization in post-training quantization (PTQ) of large language models. The authors identify two inherent limitations in the widely used Min–Max initialization strategy — its reliance on extreme values and integer zero-point constraints — and propose a new method that relaxes these assumptions. NeUQI directly optimizes scale and zero-point via a loss-aware formulation and an efficient two-stage approximation algorithm, showing consistent improvements across LLaMA and Qwen model families. The method also integrates effectively with lightweight distillation, surpassing heavier fine-tuning baselines such as PV-tuning.
weaknesses: However, the empirical evidence for the independent importance of initialization remains somewhat ambiguous. Many PTQ methods that incorporate limited fine-tuning (e.g., OmniQuant) already perform a form of implicit re-initialization by adjusting parameters during optimization. It would therefore be more convincing if the paper explicitly compared NeUQI with such fine-tuning-based methods across a wider range of models. Although Table 1 includes some results for OmniQuant and PV-tuning, the current coverage is limited. Additional experiments on more architectures, and under both weight-only and weight-activation quantization, would strengthen the claim that NeUQI surpasses these adaptive methods in a consistent and generalizable way.

---

confidence: 3
contribution: 2
initial_rating: 2
presentation: 1
questions: - When the zero point optimization is simplified by the smoothed objective in Eq. (6), i.e., reducing the candidate solutions of $z$ to $\{1/2 - x_i, 2^k - 1/2 -x_i \}$, the rounded values are in $\{1/2, 2^k - 1/2 \}$. Is it equivalent to falling back to the **integer** zero point model $Q_{s, z}(x) = s\cdot ({\rm clip}(\lfloor x / s \rceil+ z , 0, 2^k - 1) - z)$, as opposed to the floating-point zero point model that is proposed in Section 4.1? I suggest the authors to clarify the advantage of adopting a floating-point $z$ when solving for the optimization in Section 4.3.1.

- In Line 10 of Algorithm 1, which coefficients are initialized and how are they initialized?

- How does Algorithm 1 ensures to find the optimal solution to Eq. (5), which involves the quantization error of a group of weight values $w_i$ (summation over $i = 1, ..., n$), using only a per-sample loss changes in Line 5 of Algorithm 1?

- Can the authors provide the actual time cost of performing NeUQI, and compare it to every baseline methods?
soundness: 1
strengths: - The proposed method shows robustness across different models and tasks in the 2-bit regime, surpassing SOTA performance.
summary: This paper addresses the 2-bit Post-Training Quantization problem for LLMs. The proposed method adopts a floating-point zero point for more precise optimization on the approximated quantization loss of layer-wise outputs. An efficient searching algorithm is proposed to find the optimal zero point and scaling.
weaknesses: - The definition of Min-Max initialization should be mentioned before/at Section 3, e.g., as a reference to Appendix A. I find it difficult to understand Section 3 at first without acknowledging the definition of what is referred to as "Min-Max" initialization.
- In Line 123, the grid search size $T$ is not properly defined/introduced. In particular, the definition in Appendix A does not mention about $T$.
- There is a typo in Eq. (3): $(W_{i,:}) - W_{i,:})^\top$ should be $(Q(W_{i,:}) - W_{i,:})^\top$
- The statement in Line 218 is not clearly written. I assume that stated example is referring to the scenario where $\exists z, z'$ such that ${\rm clip}(\lfloor x_i + z \rceil, 0, 2^k - 1) = a$ and ${\rm clip}(\lfloor x_i + z' \rceil, 0, 2^k - 1) = a+1$. Then, the increment in loss function should be written as $h_i((x_i + z' - (a+1))^2 - (x_i + z - a)^2 )$.

Overall, I think the optimization process in Section 4.3.1 and 4.3.2 should be described more clearly. Judging from the current submission, it is not clear how the proposed algorithm is implemented.

---

confidence: 5
contribution: 2
initial_rating: 6
presentation: 3
questions: The experiments of initialization methods considered is still quite limited. The author’s mentioned approaches, such as clipping-based, quantile-based, and Mean-Std-based methods, were not compared, nor were classical techniques like KL-divergence minimization. These do not conflict with the scale-learnable methods discussed by the author, such as OmniQuant and LearnQuant; combining these classical initialization methods with learnable quantization parameters , would perform worse than the author’s approach?
 

It is generally believed that when using fine-tuned or LoRA fine-tuned models, the advantage of initialization is largely diminished, since the weights adapt to the scale and zero-point. Does this perspective still apply to your proposed quantization initialization method?
soundness: 3
strengths: - Strong theoretical grounding with efficient algorithms (increment-prefix-sum, coarse-to-fine scale search).
- Extensive experiments across multiple LLM families. The experiments discuss the combination of this initialization method with various quantization algorithms, with consistent improvements.
summary: This paper addresses the problem of parameter initialization in uniform post-training quantization (PTQ) of large language models (LLMs). While most prior works rely on the conventional Min-Max strategy, which becomes ineffective at low bit-widths (2–3 bits), the authors identify two key limitations of this rationale: (1) scale and zero-point are tied to extreme values, unnecessarily enlarging the search space, and (2) the integer constraint on zero-point reduces flexibility. To overcome these, they propose NeUQI, a near-optimal initialization method that directly optimizes scale and zero-point using a loss-aware formulation with efficient algorithms. They further combine NeUQI with a lightweight distillation strategy. Experiments on LLaMA and Qwen families show consistent improvements, with NeUQI sometimes even surpassing non-quantized baselines at comparable memory usage.

However, some limitations remain. First, while floating-point zero-points could in principle offer better representational flexibility than integer zero-points, many hardware platforms do not support them, limiting practical applicability. Second, the range of baseline initialization methods evaluated is still limited.
weaknesses: In model quantization, it is natural to expect that using a floating-point zero-point would outperform an integer zero-point, since the representational capability is inherently greater. However, many hardware platforms do not support zero-points in floating-point formats, so such zero-point optimizations do not always hold in practice.


Decision: Reject