AutoAWQ

Implements the AWQ algorithm that identifies and preserves activation-salient weight channels during quantization, using per-channel scaling factors computed from calibration data to maintain model quality. The quantizer analyzes activation patterns across a calibration dataset, applies selective quantization that protects high-impact weights, and stores models in INT4 format while performing FP16 operations during inference, achieving 3x memory reduction and 3x speedup on memory-bound workloads.

Implements a factory pattern (AutoAWQForCausalLM) that maintains a registry mapping 35+ model architectures (Llama, Mistral, MPT, Falcon, Qwen, etc.) to their corresponding quantized implementations. The factory automatically detects model type from HuggingFace config and instantiates the correct BaseAWQForCausalLM subclass, handling architecture-specific quantization logic and optimized inference kernels without requiring users to specify implementation details.

Extends AWQ quantization to vision-language models (e.g., LLaVA, Qwen-VL) by selectively quantizing language model components while preserving vision encoder precision, or applying quantization to both components with architecture-aware scaling. This approach maintains image understanding quality while reducing overall model size and inference latency.

Provides awq-cli command-line tools for quantizing models and running inference without writing Python code. Users can specify model ID, calibration dataset, quantization parameters, and output path via command-line arguments, enabling integration with shell scripts, CI/CD pipelines, and non-Python workflows. The CLI abstracts away Python API complexity while maintaining access to all core functionality.

Allows users to extend AutoAWQ with custom model architectures by subclassing BaseAWQForCausalLM and implementing architecture-specific quantization logic. Provides hooks for custom layer quantization, attention patterns, and inference kernels. Enables quantization of proprietary or research models not in the official registry.

Analyzes activation statistics from a calibration dataset to compute per-channel scaling factors that minimize quantization error for each weight channel independently. The AwqQuantizer processes calibration samples through the model, captures activation magnitudes at each layer, identifies the most important channels based on activation variance, and derives optimal INT4 clipping ranges that preserve high-activation weights at full precision while aggressively quantizing low-activation channels.

Implements specialized WQLinear_* modules (variants for different hardware: GEMM for batch inference, GEMV for single-token generation) that perform INT4 weight dequantization and matrix multiplication in fused CUDA/ROCm kernels. These kernels avoid materializing full FP16 weights in memory, instead keeping weights in INT4 format and dequantizing on-the-fly during computation, reducing memory bandwidth requirements and enabling 3x speedup on memory-bound workloads.

Provides architecture-specific implementations of attention mechanisms and transformer blocks that fuse multiple operations (QKV projection, attention computation, output projection) into single CUDA kernels. These fused blocks reduce kernel launch overhead, improve memory locality, and enable optimizations like in-place operations and reduced intermediate tensor allocations, resulting in 10-20% additional speedup beyond INT4 weight quantization.

Provides from_pretrained() and from_quantized() factory methods that load models from HuggingFace Hub or local paths, automatically detecting model architecture and instantiating the correct quantizer or inference engine. from_pretrained() loads full-precision models for quantization, while from_quantized() loads pre-quantized INT4 checkpoints with scaling factors and metadata, enabling both quantization and inference workflows through a unified API.

Implements save_quantized() method that serializes quantized models with INT4 weights, scaling factors, zero-points, and quantization metadata into HuggingFace-compatible format (safetensors or PyTorch). The serialization preserves all information needed for inference while maintaining compatibility with HuggingFace Hub, enabling users to share quantized models and load them with from_quantized() without re-quantizing.

Provides command-line tools and Python APIs for benchmarking quantized models across different hardware configurations, measuring throughput (tokens/second), latency (ms/token), and memory usage. The benchmark suite compares quantized vs full-precision models, profiles different batch sizes and sequence lengths, and generates performance reports that help users understand trade-offs between compression and speed.

Abstracts hardware-specific implementations (NVIDIA CUDA, AMD ROCm, Intel CPU/XPU) behind a unified Python API that automatically detects available hardware and selects the appropriate backend. The framework compiles optimized kernels for each platform during installation, enabling the same Python code to run on different hardware without modification while maintaining performance characteristics.

Implements architecture-specific quantization and inference optimizations for Llama (1/2/3) and Mistral models, including fused attention blocks, grouped query attention (GQA) support, and RoPE position encoding optimizations. These specializations leverage knowledge of model-specific design patterns to achieve better compression and faster inference than generic implementations.