Quantization25 articles

Quantization

Articles

Post-Training Quantization Toolkits in Production: Comparing AutoAWQ, AutoGPTQ, bitsandbytes, and llm-compressor Architecture, Calibration Profiling, Kernel Execution, and Serving Economics
Large language model deployment in high-concurrency production environments is governed primarily by memory bandwidth and hardware economics. In standard autoregressive decoding, memory traffic dominates computation: for every token generated, every parameter of the model must be loaded from GPU High Bandwidth Memory (HBM) into SRAM and tensor cores. Serving a 70-billion parameter model in 16-bit precision requires at least 140 GB of VRAM solely for model weights, necessitating multi-GPU tensor
August 28, 20261 min
Low-Rank Adaptation (LoRA) and QLoRA: Mathematical Foundations, Intrinsic Rank Parameterization, NF4 Quantization, and Double Quantization Mechanics
Low-Rank Adaptation (LoRA) and QLoRA: Mathematical Foundations, Intrinsic Rank Parameterization, NF4 Quantization, and Double Quantization Mechanics Parameter-efficient fine-tuning (PEFT) has become the standard operational methodology for adapting large language models to domain-specific tasks, downstream instruction following, and structured tool use. Full-parameter fine-tuning of frontier architectures requires updating and tracking optimizer states for tens or hundreds of billions of parame
August 27, 20261 min
Post-Training Quantization (PTQ): Mathematical Foundations of Optimal Brain Surgeon, GPTQ Hessian Inversion, AWQ Salient Scaling, and SmoothQuant Outlier Migration
Post-Training Quantization (PTQ): Mathematical Foundations of Optimal Brain Surgeon, GPTQ Hessian Inversion, AWQ Salient Scaling, and SmoothQuant Outlier Migration Serving modern large language models at scale requires addressing severe hardware constraints. In autoregressive generation, decoding is fundamentally bounded by memory bandwidth rather than floating-point computation throughput. Each generated token requires reading every parameter from High Bandwidth Memory (HBM) into SRAM to perfo
August 27, 20261 min
Low-Rank Adaptation (LoRA) and QLoRA: Mathematical Foundations, Intrinsic Rank Dynamics, 4-Bit NormalFloat Quantization, and Memory-Efficient Fine-Tuning
Fine-tuning large language models on custom datasets presents a significant hardware challenge. While running inference on a 70-billion parameter model requires only the model weights in memory, full-parameter fine-tuning (FPFT) demands an order of magnitude more resources. During standard 16-bit mixed-precision training with optimizers such as AdamW, each parameter requires 2 bytes for the static weight, 2 bytes for the gradient, 4 bytes for the 32-bit master weight copy, and 8 bytes for the fi
August 27, 20261 min
Activation-Aware Weight Quantization (AWQ): Mathematical Foundations, Salient Weight Protection, and INT4 Tensor Core Execution
Activation-Aware Weight Quantization (AWQ): Mathematical Foundations, Salient Weight Protection, and INT4 Tensor Core Execution Large language models have transformed AI applications, but their deployment remains constrained by memory and compute barriers. A 70B parameter model in FP16 occupies ~140 GB of VRAM — exceeding even the 192 GB of NVIDIA's flagship B200 GPU, let alone edge devices. Quantization addresses this by reducing weight precision from 16-bit floats to 4-bit integers, shrinking
August 26, 20261 min
Low-Rank Adaptation (LoRA) and QLoRA: Mathematical Foundations, Intrinsic Rank Dynamics, NF4 Quantization, and Parameter-Efficient Fine-Tuning
Full fine-tuning of large language models requires updating every parameter matrix across all transformer blocks. In production architectures spanning tens to hundreds of billions of parameters, the computational and memory footprint of updating billions of weights with first-order and second-order optimizer states becomes prohibitive. Low-Rank Adaptation (LoRA) and its quantized counterpart QLoRA provide mathematically grounded parameter-efficient fine-tuning (PEFT) frameworks. By decomposing
August 26, 20261 min
Activation-Aware Weight Quantization (AWQ): Mathematical Foundations, Salient Weight Protection, and Hardware-Efficient Low-Bit Inference
Large language model inference during autoregressive generation is overwhelmingly memory bandwidth bound. While the prefill phase processes multiple prompt tokens in parallel with high arithmetic intensity, the token generation phase computes matrix-vector multiplications ($M=1$) for each sequential token. In this regime, the GPU spends the vast majority of its cycle budget streaming model parameters from High Bandwidth Memory (HBM) or GDDR into SRAM rather than performing floating-point arithme
August 26, 20261 min
GPTQ: Mathematical Foundations, Optimal Brain Surgeon Inversion, and Second-Order Error Minimization in LLM Quantization
Large language model inference during autoregressive generation is overwhelmingly memory-bandwidth bound. For batch size 1 decoding, each generated token requires streaming every parameter of a model from High Bandwidth Memory (HBM) into GPU SRAM and Tensor Cores. A 70-billion parameter model in 16-bit precision (FP16 or BF16) requires roughly 140 GB of VRAM, exceeding the capacity of a single 80 GB NVIDIA A100 or H100 GPU and demanding multi-GPU tensor parallelism solely to hold the model weigh
August 26, 20261 min
SmoothQuant: Mathematical Foundations, Per-Channel Outlier Migration, and Hardware-Efficient W8A8 Inference in Large Language Models
SmoothQuant: Mathematical Foundations, Per-Channel Outlier Migration, and Hardware-Efficient W8A8 Inference in Large Language Models Serving large language models (LLMs) in production environments presents two distinct hardware bottlenecks. During the autoregressive generation (decode) phase with small batch sizes, inference is memory-bandwidth bound, as billions of parameters must be streamed from High Bandwidth Memory (HBM) to on-chip SRAM for every generated token. Conversely, during the pro
August 26, 20261 min
FP8 Mixed-Precision Serving in Production: Comparing E4M3 vs. E5M2 Formats, Per-Tensor vs. Block-Wise Dynamic Scaling, FP8 KV Cache, and Tensor Core GEMM Economics
FP8 Mixed-Precision Serving in Production: Comparing E4M3 vs. E5M2 Formats, Per-Tensor vs. Block-Wise Dynamic Scaling, FP8 KV Cache, and Tensor Core GEMM Economics Serving large language models at enterprise scale requires balancing computational throughput against high-bandwidth memory (HBM) capacity. While 16-bit floating-point formats (FP16 and BF16) remain the standard for model pre-training and fine-tuning, their memory footprint and arithmetic bandwidth create severe bottlenecks during hi
August 26, 20261 min
QLoRA: Mathematical Foundations of 4-Bit NormalFloat Quantization, Double Quantization, and Paged Optimizers
Fine-tuning large language models in full 16-bit precision requires substantial hardware infrastructure. For a 65-billion parameter model, storing weights in 16-bit brain floating point (BF16) requires 130 GB of VRAM. When optimizing those parameters with 32-bit AdamW, storing gradients (130 GB), first moments (260 GB), second moments (260 GB), and master weights (260 GB) drives the minimum memory footprint beyond 780 GB of VRAM, even before accounting for sequence activations. While Low-Rank A
August 26, 20261 min
BitNet b1.58: Mathematical Foundations of 1.58-Bit Ternary Quantization, Absmean Scaling, and Multiplication-Free LLM Architectures
Standard Large Language Models (LLMs) rely on 16-bit floating-point (FP16 or BF16) matrix multiplications for both pre-training and autoregressive inference. While post-training quantization techniques (such as GPTQ, AWQ, and dynamic FP8/INT4 scaling) compress weights after training, they often introduce perplexity degradation at ultra-low bitwidths ($<4$ bits) or still require floating-point dequantization at runtime. Quantization-aware pre-training architectures directly tackle this computati
August 25, 20261 min
Multiverse Computing Releases Quantization-Aware Healing to Boost 4-Bit Model Accuracy Above Full-Precision Baselines
AI infrastructure firm Multiverse Computing has introduced Quantization-Aware Healing (QAH), a post-compression optimization technique designed to restore model accuracy after structural pruning and extreme quantization. Detailed in research paper 2608.20953, the method allows 4-bit compressed large language models to exceed the benchmark performance of their intermediate 16-bit unquantized counterparts. In standard model optimization workflows, teams apply structural pruning (removing layers,
August 25, 20261 min
Vector Quantization for LLM Weights in Production: Comparing QuIP#, AQLM, and VPTQ Architecture, Dequantization Kernels, and 2-Bit Serving Economics
Vector Quantization for LLM Weights in Production: Comparing QuIP#, AQLM, and VPTQ Architecture, Dequantization Kernels, and 2-Bit Serving Economics Scalar post-training quantization methods such as GPTQ and AWQ have become the standard for compressing large language models to 4-bit integer formats (INT4). At 4 bits per parameter, scalar techniques preserve over 98% of baseline 16-bit floating-point (FP16/BF16) model accuracy across common benchmarks. However, pushing scalar quantization below
August 24, 20261 min
Microscaling Formats in Production LLM Inference: NVFP4 vs. MXFP4 Architecture, Block Quantization, Kernel Scaling, and Perplexity Degradation
As frontier language models scale into hundreds of billions of parameters, memory bandwidth and VRAM capacity remain the primary bottlenecks in production inference serving. While 8-bit floating-point formats (FP8 E4M3 and E5M2) achieved mainstream adoption across Hopper and Ada generation hardware, the industry is transitioning to 4-bit floating-point (FP4) arithmetic to double inference throughput and halve memory footprints. Directly quantizing deep transformer weights and activations into 4
August 23, 20261 min
Low-Precision Quantization Kernels in Production: Comparing Marlin, ExLlamaV2, FlashInfer, and BitBLAS
Low-Precision Quantization Kernels in Production: Comparing Marlin, ExLlamaV2, FlashInfer, and BitBLAS Architecture, Memory Bandwidth, and Decoding Throughput Autoregressive large language model (LLM) serving operates under two distinct compute regimes: a compute-bound prefill phase and a memory-bandwidth-bound decode phase. While processing the initial prompt involves matrix-matrix multiplications (GEMM) with high arithmetic intensity, generating tokens one by one requires matrix-vector multip
August 23, 20261 min
NormalFloat (NF4) and Double Quantization: The Information-Theoretic Foundations of QLoRA
Fine-tuning large language models under full 16-bit precision is governed by strict memory scaling laws. For a standard 65-billion parameter transformer model, storing weights in 16-bit BrainFloat (BF16) or Float16 (FP16) requires 130 GB of GPU memory. During training with standard first-order adaptive optimizers such as AdamW, each parameter requires an additional 2 bytes for gradients and 8 bytes for FP32 optimizer states (4 bytes for first-moment momentum and 4 bytes for second-moment varianc
August 22, 20261 min
Emergent Outlier Features in Large Language Models: Why Hidden Dimension Spikes Arise at Scale and How They Reshape Quantization
Emergent Outlier Features in Large Language Models: Why Hidden Dimension Spikes Arise at Scale and How They Reshape Quantization When language models scale past approximately 6.7 billion parameters, their internal representations undergo a sharp qualitative phase transition. In smaller models (125M to 2.7B parameters), hidden state activations remain relatively compact, bounded within predictable normal distributions across all embedding dimensions. However, as demonstrated by Dettmers et al. (
August 21, 20261 min
Quantization-Aware Training in Large Language Models: How Fake Quantization, STE, and Learned Step Sizes Preserve Low-Bit Accuracy
Quantization-Aware Training (QAT) is a model compression paradigm that integrates precision loss directly into the training or fine-tuning graph. While Post-Training Quantization (PTQ) calibrates fixed floating-point weights without updating underlying network parameters, QAT simulates the numerical discretization of weights, activations, and key-value (KV) caches during both forward and backward passes. This closed-loop optimization forces neural network weights to co-adapt to discrete integer
August 20, 20261 min
Unsloth Releases Dynamic V3.0 GGUFs for Qwen 3.8 27B with 1-Bit Mode and MTP
Unsloth AI has published its Dynamic V3.0 quantization suite for Alibaba's Qwen 3.8 27B model family, releasing optimized GGUF and NVFP4 checkpoints alongside public calibration matrices. The release claims a greater than 10 percent increase in top-1 percent accuracy at identical file sizes compared to standard baseline quantizations, while introducing an ultra-low-bit dynamic tier that operates within 8GB of memory. Qwen 3.8 27B is a dense vision-language model utilizing hybrid attention layer
August 20, 20261 min