Optimal Post-Training Quantization Scales and Where to Find Them

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Hi, I'm Tom.

Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.

Tom: We're looking at the paper: "Optimal Post-Training Quantization Scales and Where to Find Them".

Jane: Here's the gist of the paper. The gist: PiSO, an algorithm that leverages calibration data to compute the optimal channel-wise weight scales exactly and efficiently under round-to-nearest quantization, demonstrates consistent improvements in perplexity and downstream zero-shot accuracy across Llama and Qwen models.

Tom: Optimal Scale Computation PiSO is introduced as an algorithm that "leverages calibration data to compute the optimal channel-wise weight scales exactly and efficiently under round-to-nearest quantization" The core idea is to partition the scale search space into intervals on which the objective admits a closed-form minimizer This is achieved by observing that "q(w; s) is piecewise constant in s, with the breakpoints admitting a closed form" The algorithm sweeps through these intervals, evaluating the closed-form minimizer to find the global optimal scale for each channel The complexity of this sweep is reduced from O(D 3G) to O(D 2G) when exploiting incremental updates, and further reduced to O(DG) when the Hessian H is diagonal.

Jane: Channel-wise Optimization The optimization process begins by recognizing the "Channel-wise separability" of the objective function, which allows each channel's scale to be optimized independently For a fixed grid assignment q, the error function E(s) is shown to be "convex in s with a closed-form minimizer" The optimal scale for a fixed q and its associated error is given by s∗(q) = α(q)/β(q), where α(q):= q⊤G w and β(q):= q⊤H q, which are defined based on matrices H = X˜⊤X˜ and G = X˜⊤X The piecewise-constant structure of the assignment across the scale s yields transition scales ti,l = 2wi/(gl + gl+1) for each weight i and grid level l Group-wise Quantization Approximations When extending PiSO to group-wise quantization, two approximations are proposed 1) Independent groups treat each group in isolation by discarding cross-group interactions induced by the activations, leading to the objective Eind(s1,..., sK) This approach has a total per-channel cost of O(DGG) 2) Sequential groups process groups one at a time, where the scale sk is chosen to minimize the reconstruction error accounting for the quantization error of preceding groups, leading to Eseq(sk) This method remains suboptimal as later groups cannot influence earlier ones.

Tom: Integration with Error Correction PiSO can be integrated with greedy error correction methods like GPTQ or Qronos using three strategies 1) Decoupled optimization optimizes all scales first, then error correction is applied with fixed scales 2) Interleaved layer-wise optimization alternates scale and error correction at the layer level, ensuring the X˜ used for scale optimization matches the activations received by the current layer 3) Interleaved group-wise optimization optimizes each group's scale just before error correction quantizes its weights, requiring a group-aware reordering based on aggregated Hessian importance The interleaved integration strategy, GPTQ ⊙ PiSO† S X˜ -X˜, is shown to achieve the best results in many configurations.

Paper summary: Tom: So we're talking about this paper right now called Optimal Post-Training Quantization Scales and Where to Find Them. What is it trying to do?

Jane: Well, basically, the main idea is that most people just pick a simple rule for how to divide up the weights when they quantize them, but this paper shows that we can use calibration data to find much better scales exactly and efficiently under round-to-nearest quantization.

Lu: It's about PiSO, which is this algorithm that leverages calibration data to compute the optimal channel-wise weight scales exactly and efficiently under round-to-nearest quantization (<ref:2606.10890#pg2>). The core insight is that the grid assignments are piecewise constant in the scale, which means the output reconstruction error becomes piecewise quadratic over finitely many intervals, and each of those intervals has a closed-form optimization.

Meng: So, what does that mean for us practically? It sounds like we can move away from those simple data-free heuristics people usually use to pick scales.

Lalam: Exactly. PiSO sweeps through these intervals, evaluating the closed-form minimizer to find the global optimal scale for each channel. The complexity of this sweep goes from O(D cubedG) down to O(D 2G) when you use incremental updates, and further down to O(DG) if you have a diagonal Hessian H (<ref:2606.10890#pg3>).

Tom: That reduction in complexity is huge for us on models like Llama or Qwen. But what about applying this to the whole model structure?

Jane: The paper extends PiSO to group-wise quantization, which means it’s not just optimizing one channel at a time, but looking at groups of weights. They propose two ways to do that: first, independent groups treat each group in isolation by discarding cross-group interactions from the activations (<ref:2606.10890#pg2>).

Lu: Then there's a second way where sequential groups process them one at a time, where the scale for group s k is chosen to minimize reconstruction error accounting for the quantization error of all preceding groups, but they admit that this sequential method isn't always optimal because later groups can’t influence earlier ones.

Paper summary: Meng: From an engineering standpoint, that sequential approach sounds like it might be easier to implement initially than a full cross-group optimization. What are the actual numbers on how much better it gets?

Lalam: The paper validates this with experiments on Llama and Qwen models across multiple sizes and target weight bit-widths, showing consistent improvements in perplexity and downstream zero-shot accuracy, both when PiSO is used by itself or combined with error correction (<ref:2606.10890#pg2>).

Tom: So the performance gains are consistent across different model sizes and different bit-widths? That’s what I need to hear—consistency is key for shipping anything.

Jane: It is, and it's particularly interesting because the benefits increase as the target bit-width narrows, which means quantization gets harder. For example, on Llama-three PiSO reduces the two-bit perplexity of Qronos by up to seven times (<ref:2606.10890#pg2>).

Lu: And they also show that when you go to three bits, PiSO without error correction actually outperforms GPTQ when using absmax scales (<ref:2606.10890#pg3>). That suggests the scale selection alone is powerful.

Meng: But we can't just use PiSO in a vacuum anymore, right? We have to deal with error correction methods like GPTQ or Qronos that try to fix those rounding errors after the fact. How does this paper handle that integration?

Lalam: They proposed three strategies for integrating PiSO with these greedy error correction methods. One is decoupling: you optimize all scales first, and then you apply the error correction with fixed scales (<ref:2606.10890#pg3>).

Tom: And the other two? What are those?

Jane: The second strategy involves interleaved layer-wise optimization, where you alternate between scale optimization and error correction at the layer level, making sure the activations used for scaling match what is actually being seen by that layer.

Lu: The third strategy is group-wise interleaving: you optimize each group's scale just before error correction quantizes its weights, which requires a reordering of groups based on how important their aggregated Hessian importance is (<ref:2606.10890#pg2>).

Meng: So the interleaved integration strategy, GPTQ PiSO† S X˜ - X˜, is what they say gets the best results in many configurations. That sounds like a lot of work to set up during deployment.

Paper summary: Lalam: They also noted that this tight coupling with error correction yields the best end-to-end results (<ref:2606.10890#pg2>).

Tom: So, what’s the big picture here for someone just listening? What does all this mean for how we deploy these massive models?

Jane: It means that instead of guessing the best way to set up the quantization grid, we have a systematic way to use calibration data to find near-optimal scales. It moves scale selection from a simple heuristic choice to an optimized calculation.

Lu: What it changes is how much data you need for accurate quantization too; they found PiSO reduces the calibration data required for accurate quantization, both when using round-to-nearest and when combined with GPTQ (<ref:2606.10890#pg3>).

Meng: That reduction in calibration data is a massive win for production pipelines where you don't want to run huge calibration sets just to get a slightly better model.

Lalam: And they found that RTN plus PiSO reaches near-asymptotic quality from just a single two thousand forty-eight-token calibration sequence (<ref:2606.10890#pg3>). That’s incredibly efficient for training and fine-tuning pipelines.

Tom: So, to wrap up, this paper is about PiSO, an algorithm that finds the optimal channel-wise scales using a piecewise constant structure in the scale search space under round-to-nearest quantization. It shows consistent gains on Llama and Qwen when used alone or with error correction methods like GPTQ.

Jane: And it points toward a future where we use data to guide these complex quantization decisions rather than relying on simple, fixed rules for those scaling factors.

Lu: The limitation they point out is that the exact optimality of PiSO is tied to the channel-wise round-to-nearest regime, and their group-wise variants are still approximations.

Meng: So if you're building a production system right now, you have to decide if you need those complex interleaved strategies or if sticking to the simpler decoupling might be more practical for your current needs.

Lalam: The paper concludes that the tightest coupling with error correction yields the best end-to-end results (<ref:2606.10890#pg2>).

Tom: That’s it for this look at Optimal Post-Training Quantization Scales and Where to Find Them. We'll be back after the break with more deep dives into arXiv papers.

Conclusion: Tom: So we've been talking about PiSO, which is this new algorithm for figuring out the best weights scales when you quantize a large language model post-training.

Jane: Right, so the title is "Optimal Post-Training Quantization Scales and Where to Find Them," and the authors are focusing on how to do that optimally.

Lu: They found that by using calibration data, we can compute those channel-wise scales exactly and efficiently under round-to-nearest quantization.

Meng: Exactly. The core idea is this piecewise constant structure in the scale search space, which lets us find a global optimum for each channel individually with a closed form formula.

Lalam: And they show consistent improvements on models like Llama and Qwen across different sizes and bit-widths, both standalone and when combined with error correction methods.

Tom: So it’s not just theoretical work; they have results showing better perplexity and zero-shot accuracy in real model scenarios.

Jane: That consistency is what’s interesting. They found that the benefits actually grow as the target bit-width gets smaller, which means quantization gets tougher.

Lu: And they even show that this method can reduce the calibration data needed for accurate quantization, both with round-to-nearest and when you mix it with GPTQ error correction.

Meng: That reduction in calibration data is a big deal for production pipelines; we don't want to run huge datasets just to get a tiny bit of improvement on the deployed model.

Lalam: And they even found that round-to-nearest quantization plus PiSO can reach near-asymptotic quality from just one two thousand forty eight token calibration sequence.

Tom: It means you don't need massive amounts of data just to get a solid result from this method.

Jane: Exactly. So, what does this whole thing mean for the world of deploying these huge AI models?

Lu: It shows that we can move away from those simple, guess-and-check heuristics for setting up the quantization grid and use data to guide those complex decisions.