Awesome

Large Foundation Model Quantization (LMQuant)

LMQuant is an open source large foundation models quantization toolbox based on PyTorch. LMQuant is implemented by QServe, an efficient GPU inference library.

The current release supports:

• SmoothQuant, AWQ, GPTQ-R, and QoQ quantization for large language models

News

• [2024/05] 🔥 Our latest W4A8KV4 LLM quantization work QoQ algorithm and QServe system is publicly released! QoQ is short for quattuor-octō-quattuor which is 4-8-4 in latin. Check our paper!

Contents

• Large Models Quantization (LMQuant)
  • News
  • Installation
  • Highlights
    • QServe: W4A8KV4 Quantization for Efficient LLM Serving
      • Model Zoo
      • Perplexity Evaluation
      • Efficiency Benchmarks
  • Support List
  • Reference
  • Related Projects
  • Acknowledgement

Installation

1. Clone this repository and navigate to lmquant folder

git clone https://github.com/mit-han-lab/lmquant
cd lmquant

2. Install Package

conda env create -f environment.yml -n lmquant
conda activate lmquant
poetry install

Highlights

QServe: W4A8KV4 Quantization for Efficient LLM Serving

[Website][Paper][QoQ Algorithm Code][QServe GPU System]

Quantization can accelerate large language model (LLM) inference. Going beyond INT8 quantization, the research community is actively exploring even lower precision, such as INT4. Nonetheless, state-of-the-art INT4 quantization techniques only accelerate low-batch, edge LLM inference, failing to deliver performance gains in large-batch, cloud-based LLM serving. We uncover a critical issue: existing INT4 quantization methods suffer from significant runtime overhead (20-90%) when dequantizing either weights or partial sums on GPUs. To address this challenge, we introduce QoQ, a W4A8KV4 quantization algorithm with 4-bit weight, 8-bit activation, and 4-bit KV cache. QoQ stands for quattuor-octo-quattuor, which represents 4-8-4 in Latin. QoQ is implemented by the QServe inference library that achieves measured speedup. The key insight driving QServe is that the efficiency of LLM serving on GPUs is critically influenced by operations on low-throughput CUDA cores. Building upon this insight, in QoQ algorithm, we introduce progressive quantization that can allow low dequantization overhead in W4A8 GEMM. Additionally, we develop SmoothAttention to effectively mitigate the accuracy degradation incurred by 4-bit KV quantization. In the QServe system, we perform compute-aware weight reordering and take advantage of register-level parallelism to reduce dequantization latency. We also make fused attention memory-bound, harnessing the performance gain brought by KV4 quantization. As a result, QServe improves the maximum achievable serving throughput of Llama-3-8B by 1.2× on A100, 1.4× on L40S; and Qwen1.5-72B by 2.4× on A100, 3.5× on L40S, compared to TensorRT-LLM.

Model Zoo

We provide QoQ quantized model checkpoints in QServe for your reference.

Perplexity Evaluation

Below is the WikiText2 perplexity evaluated with 2048 sequence length. The lower is the better.

* SmoothQuant is evaluated with per-tensor static KV cache quantization.

Efficiency Benchmarks

When serving the large language models Llama-3-8B and Qwen1.5-72B on L40S and A100 GPUs, QServe demonstrates superior performance, achieving 1.2x-1.4x higher throughput compared to the leading industry solution, TensorRT-LLM, for Llama-3-8B, and a 2.4x-3.5x higher throughput for Qwen1.5-72B.

See more about benchmarking setting in QServe GPU Inference System.

The absolute token generation throughputs of QServe and baseline systems (Unit: tokens/second. -- means unsupported). All experiments were conducted under the same device memory budget. Throughput increase of QServe is calculated with regard to the best baseline in each column.

Support List

Large Language Model Quantization

Reference

If you find lmquant useful or relevant to your research, please kindly cite our paper:

@article{lin2024qserve,
  title={QServe: W4A8KV4 Quantization and System Co-design for Efficient LLM Serving},
  author={Lin*, Yujun and Tang*, Haotian and Yang*, Shang and Zhang, Zhekai and Xiao, Guangxuan and Gan, Chuang and Han, Song},
  journal={arXiv preprint arXiv:2405.04532},
  year={2024}
}

Related Projects

The following projects are highly related to QServe. Our group has developed full-stack application-algorithm-system-hardware support for efficient large models, receiving 9k+ GitHub stars and over 1M Huggingface community downloads.

You are also welcome to check out MIT HAN LAB for other exciting projects on Efficient Generative AI!

• [System] QServe: W4A8KV4 Quantization for Efficient LLM Serving

• [System] TinyChat: Efficient and Lightweight Chatbot with AWQ

• [Application] VILA: On Pretraining of Visual-Language Models

• [Algorithm] AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration

• [Algorithm] SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models

• [Algorithm] StreamingLLM: Efficient Streaming Language Models with Attention Sinks

• [Hardware] SpAtten: Efficient Sparse Attention Architecture with Cascade Token and Head Pruning

Acknowledgement

LMQuant is inspired by many open-source libraries, including (but not limited to) GPTQ, QuaRot and Atom.