exllamav2

Implements custom CUDA kernels for efficient inference of large language models on consumer GPUs using 4-bit quantization, enabling models like Llama 70B to run on single 24GB GPUs. Uses fused attention mechanisms and optimized memory layouts to reduce bandwidth bottlenecks, with dynamic batch sizing and token-by-token generation for low-latency streaming responses.

Manages heterogeneous batch processing where requests have different prompt/completion lengths, using a paged attention mechanism to avoid padding waste. Dynamically schedules GPU compute based on available VRAM and request queue, reordering batches to maximize occupancy without head-of-line blocking.

Accelerates inference using speculative decoding with a smaller draft model that generates multiple token candidates, which are verified by the main model in parallel. Implements efficient batch verification with early exit when draft predictions diverge, reducing main model inference calls by 30-50% on typical workloads.

Loads and composes multiple Low-Rank Adaptation (LoRA) modules on top of a base quantized model, enabling dynamic switching between task-specific adapters without reloading the base weights. Uses rank-decomposed matrix multiplication to apply adapter weights with minimal compute overhead, supporting adapter merging and weighted composition for ensemble-like behavior.

Generates tokens one-at-a-time with support for custom sampling distributions (temperature, top-k, top-p, min-p, typical sampling), enabling real-time streaming responses and fine-grained control over generation behavior. Implements efficient logit filtering and probability normalization in CUDA to avoid CPU bottlenecks, with support for repetition penalties and frequency-based constraints.

Extends model context windows beyond training length using Rotary Position Embedding (RoPE) interpolation, dynamically adjusting position encoding frequencies to fit longer sequences into the same embedding space. Implements linear and NTK-aware interpolation strategies to maintain coherence at extended lengths, with configurable interpolation factors per model.

Converts standard HuggingFace models to ExLlama's optimized quantized format using 4-bit quantization with per-channel scaling, applying layer-wise calibration on representative data to minimize quantization error. Includes automatic layer fusion (e.g., combining linear layers with activation functions) and weight reordering for cache-optimal GPU memory access patterns.

Distributes model inference across multiple GPUs using tensor parallelism, splitting weight matrices horizontally across devices and coordinating all-reduce operations for attention and FFN layers. Implements efficient GPU-to-GPU communication via NVLink or PCIe, with automatic load balancing and pipeline scheduling to minimize synchronization overhead.

Caches computed key-value (KV) cache for prompt prefixes across multiple requests, enabling instant reuse of expensive attention computations when requests share common context. Implements a cache key based on token sequence hash with LRU eviction, supporting both exact-match and approximate-match cache hits for flexible prompt variations.

Provides a high-level Python API wrapping the CUDA inference engine with async/await support for non-blocking inference, streaming token callbacks, and batch request handling. Implements context managers for resource cleanup, type hints for IDE autocomplete, and integration hooks for custom sampling or post-processing logic.

Includes built-in profiling utilities to measure token generation speed, memory usage, and GPU utilization across different batch sizes, sequence lengths, and quantization settings. Generates detailed performance reports with bottleneck identification (compute-bound vs memory-bound) and recommendations for optimization (batch size tuning, context length reduction, etc.).