Compressing AI Models with GPTQ and AWQ

This article provides a quick overview of how post-training quantization (PTQ) algorithms, specifically GPTQ and Activation-aware Weight Quantization (AWQ), compress large artificial intelligence models without requiring costly retraining. By reducing the numerical precision of a model's parameters from 16-bit floats to 4-bit integers, these methods dramatically shrink memory footprints and accelerate inference speeds. Readers will understand the fundamental mechanics of PTQ and how GPTQ uses mathematical error compensation while AWQ leverages activation distributions to preserve model accuracy during compression.

Understanding Post-Training Quantization

Artificial intelligence models, particularly Large Language Models (LLMs), consist of billions of numerical values known as weights. Normally, these weights are stored in high-precision formats like 16-bit floating-point (FP16). Post-training quantization (PTQ) converts these high-precision numbers into lower-precision formats, such as 4-bit integers (INT4), after the model has already been fully trained.

Because PTQ does not require retraining the model on massive datasets, it can be executed quickly on limited hardware. Instead of retraining, PTQ algorithms use a small, representative "calibration dataset" to observe how the model behaves and determine the safest way to round the weights without destroying the model's intelligence.

How GPTQ Works

GPTQ (Generative Pre-trained Transformer Quantization) is an algorithm rooted in a mathematical approach called Optimal Brain Quantization. Its primary goal is to quantize weights one layer at a time while minimizing the error introduced by rounding.

When a weight is rounded to a lower precision, it creates a slight mathematical error that can degrade the model's output. GPTQ solves this through a two-step loop:

  1. Quantize a single weight: The algorithm takes a specific weight and rounds it to the nearest 4-bit value.
  2. Compensate for the error: Using second-order information (the Hessian matrix, which measures how sensitive the model's output is to changes in specific weights), GPTQ calculates the exact error caused by that rounding. It then slightly adjusts the remaining, unquantized weights in that same layer to cancel out the error.

By continuously adjusting the remaining weights as it compresses a layer, GPTQ ensures that the layer's final output remains nearly identical to the original high-precision output.

How Activation-Aware Weight Quantization (AWQ) Works

Activation-aware Weight Quantization (AWQ) takes a different approach based on a simple observation: not all weights in a neural network are equally important. In fact, roughly 1% of a model's weights are considered "salient," meaning they play a disproportionately large role in determining the model's accuracy.

AWQ identifies these crucial weights not by looking at the weights themselves, but by looking at the "activations"—the actual data flowing through the network during inference. When the calibration dataset is passed through the model, the channels that consistently produce the largest activation magnitudes are connected to the most important weights.

Instead of leaving these salient weights in 16-bit format (which causes hardware inefficiencies due to mixed precision), AWQ protects them through mathematical scaling:

  1. Scale up important weights: AWQ multiplies the salient weights by a scaling factor, making them larger prior to quantization. This reduces their relative rounding error when they are converted to 4-bit integers.
  2. Scale down the inputs: To keep the math balanced so the model's output does not change, AWQ divides the corresponding input activations by the exact same scaling factor.

This scaling trick allows AWQ to compress 100% of the weights to 4-bit precision while mathematically shielding the most critical parameters from quantization damage.

Comparing the Two Approaches

Both algorithms achieve the same result—a drastically smaller AI model that runs faster and requires less video memory—without retraining. However, they achieve this through different philosophies.

GPTQ treats all weights as adjustable variables, actively mutating unquantized weights to absorb the errors of quantized ones. This makes it highly accurate, though it can occasionally overfit to the calibration dataset. AWQ does not alter the values of weights to absorb errors; instead, it observes data flow to identify and protect the most critical pathways via scaling. Consequently, AWQ is often faster to apply and tends to generalize better across different types of data inputs.