Snelle Matrixvermenigvuldigingen voor Lookup Table-gekwantiseerde LLM's

Fast Matrix Multiplications for Lookup Table-Quantized LLMs

July 15, 2024

Auteurs: Han Guo, William Brandon, Radostin Cholakov, Jonathan Ragan-Kelley, Eric P. Xing, Yoon Kim

cs.AI

Samenvatting

De inzet van grote taalmodellen (LLMs) wordt vaak beperkt door het geheugenbandbreedte, waarbij de belangrijkste bottleneck de kosten zijn van het overbrengen van modelparameters van het globale geheugen van de GPU naar zijn registers. Wanneer dit wordt gecombineerd met aangepaste kernels die de dequantisatie- en matmul-bewerkingen samenvoegen, kan gewichtsgerichte quantisatie dus snellere inferentie mogelijk maken door de hoeveelheid geheugenverplaatsing te verminderen. Het ontwikkelen van hoogwaardige kernels voor gewichtsgequantiseerde LLMs brengt echter aanzienlijke uitdagingen met zich mee, vooral wanneer de gewichten worden gecomprimeerd tot niet-evenredig verdeelde bitbreedtes (bijvoorbeeld 3 bits) met niet-uniforme, lookup table (LUT)-quantisatie. Dit artikel beschrijft FLUTE, een flexibele lookup table-engine voor LUT-gequantiseerde LLMs, die gebruikmaakt van offline herstructurering van de gequantiseerde gewichtsmatrix om bitmanipulaties geassocieerd met uitpakken te minimaliseren, en vectorisatie en duplicatie van de lookup table om beperkingen in de gedeelde geheugenbandbreedte te verminderen. Bij batchgroottes < 32 en een quantisatiegroepgrootte van 128 (typisch in LLM-inferentie), kan de FLUTE-kernel 2-4x sneller zijn dan bestaande GEMM-kernels. Als een toepassing van FLUTE verkennen we een eenvoudige uitbreiding van lookup table-gebaseerde NormalFloat-quantisatie en passen we deze toe om LLaMA3 te quantiseren naar verschillende configuraties, waarbij we competitieve quantisatieprestaties behalen ten opzichte van sterke baselines en tegelijkertijd een end-to-end doorvoerverhoging van 1,5 tot 2 keer realiseren.

English

The deployment of large language models (LLMs) is often constrained by memory bandwidth, where the primary bottleneck is the cost of transferring model parameters from the GPU's global memory to its registers. When coupled with custom kernels that fuse the dequantization and matmul operations, weight-only quantization can thus enable faster inference by reducing the amount of memory movement. However, developing high-performance kernels for weight-quantized LLMs presents substantial challenges, especially when the weights are compressed to non-evenly-divisible bit widths (e.g., 3 bits) with non-uniform, lookup table (LUT) quantization. This paper describes FLUTE, a flexible lookup table engine for LUT-quantized LLMs, which uses offline restructuring of the quantized weight matrix to minimize bit manipulations associated with unpacking, and vectorization and duplication of the lookup table to mitigate shared memory bandwidth constraints. At batch sizes < 32 and quantization group size of 128 (typical in LLM inference), the FLUTE kernel can be 2-4x faster than existing GEMM kernels. As an application of FLUTE, we explore a simple extension to lookup table-based NormalFloat quantization and apply it to quantize LLaMA3 to various configurations, obtaining competitive quantization performance against strong baselines while obtaining an end-to-end throughput increase of 1.5 to 2 times.