LLM Compression Benchmark

Made in Vancouver, Canada by Picovoice

This repository is a minimalist and extensible framework for benchmarking LLM compression algorithms.

Table of Contents

• Algorithms
  • GPTQ
  • picoLLM Compression
• Tasks
  • MMLU Score
  • ARC Score
  • Perplexity Loss
• Data
  • MMLU
  • ARC
  • Perplexity (C4)
  • Quantization (C4)
• Models
• Usage
• Results
  • MMLU
  • ARC-Easy
  • ARC-Challenge
  • Perplexity

Algorithms

GPTQ

GPTQ is arguably the most popular quantization algorithm for LLMs. GPTQ fully reconstructs weights so that the quantized version closely mimics the full-precision one.

picoLLM Compression

picoLLM Compression is Picovoice's in-house LLM compression algorithm. Given a target size, picoLLM optimally distributes available bits within and across LLM's weights.

Tasks

MMLU Score

MMLU (Massive Multitask Language Understanding) is a multiple-choice dataset that can measure the models' ability to understand natural language.

ARC Score

ARC (AI2 Reasoning Challenge) is a multiple-choice dataset that measures the models' reasoning ability. The ARC dataset has two partitions: Easy and Challenge. We perform the benchmark on both partitions and report the results separately.

Perplexity Loss

Perplexity measures the models' language modeling capabilities.

Data

The'/res' folder contains all required data for the benchmark. To reproduce it, follow the sections below.

MMLU

Download the MMLU dataset and run the following from the repository's root to extract and format it:

python3 data/mmlu.py --dataset-folder ${DATASET_FOLDER}

ARC

Download the ARC dataset and run the following from the repository's root to extract and format the Challenge portion:

python3 data/arc.py --dataset-folder ${DATASET_FOLDER}

Perform the above for the Easy portion:

python3 data/arc.py --dataset-folder ${DATASET_FOLDER} --easy

Perplexity (C4)

For the perplexity measurement, we use 128 randomly selected text snippets from the validation portion of the C4 dataset. Once you download the dataset, run the following from the root of the repository to extract and normalize the data:

python3 data/c4-normalize.py \
--repository-folder ${REPOSITORY_FOLDER} \
--normalized-folder ${VALIDATION_FOLDER} \
--portion validation

Replace ${REPOSITORY_FOLDER} with the path to the downloaded dataset repository and ${VALIDATION_FOLDER} with a folder to hold onto the normalized data.

Then we sample 128 sequences from the normalized data:

python3 data/c4-sample.py \
--dataset-folder ${VALIDATION_FOLDER} \
--portion valid

Quantization (C4)

We need a sample dataset for quantization algorithms (GPTQ, picoLLM). We use 128 randomly selected text snippets from the train portion of the C4 dataset. Once you download the dataset, run the following from the root of the repository to extract and normalize the data:

python3 data/c4-normalize.py \
--repository-folder ${REPOSITORY_FOLDER} \
--normalized-folder ${TRAIN_FOLDER} \
--portion train

Replace ${REPOSITORY_FOLDER} with the path to the downloaded dataset repository and ${TRAIN_FOLDER} with a folder to hold onto the normalized data.

Then we sample 128 sequences from the normalized data:

python3 data/c4-sample.py \
--dataset-folder ${TRAIN_FOLDER} \
--portion train

Models

We use six models:

• Gemma-2b
• Gemma-7b
• Llama-2-7b
• Llama-3-8b
• Mistral-7b-v0.1
• Phi-2

The corresponding picoLLM compressed models are on Picovoice Console. We create GPTQ models using the package AutoGPTQ. You can quantize the models by running the following:

python3 model/autogptq.py \
--model-uri ${MODEL_URI} \
--quantized-model-folder ${QUANTIZED_MODEL_FOLDER} \
--bits ${BITS}

Usage

To measure the MMLU score for a given model, run the following:

python3 mmlu.py \
--compression ${COMPRESSION} \
--model-uri ${MODEL_URI}

Replace ${COMPRESSION} with the model's compression. i.e., NONE for full-precision models, GPTQ, or picoLLM.

To measure the ARC score for a given model, run the following:

python3 arc.py \
--compression ${COMPRESSION} \
--model-uri ${MODEL_URI}

Replace ${COMPRESSION} with the model's compression. i.e., NONE for full-precision models, GPTQ, or picoLLM.

To measure the perplexity for a given model, run the following:

python3 perplexity.py \
--compression ${COMPRESSION} \
--model-uri ${MODEL_URI}

Replace ${COMPRESSION} with the model's compression. i.e., NONE for full-precision models, GPTQ, or picoLLM.

When running picoLLM Compressed models, you must also provide your Picovoice AccessKey, which is available on Picovoice Console.

... --picollm-access-key ${PICOLLM_ACCESS_KEY}

Results

Below are our benchmark results comparing GPTQ against picoLLM for all models. We perform 2, 3, and 4-bit quantization using GPTQ, then find the model size in GB and set that as the target size for picoLLM Compression. Hence, both models have the same size in terms of the number of bytes. When performing GPTQ, we set the group size parameter to 128, set the damp percent to 0.1 and enabled activation reordering.

MMLU

The table below depicts the MMLU score of the original models.

The table below depicts the MMLU score of the quantized models.

ARC Easy

The table below depicts the ARC Easy score of the original models.

The table below depicts the ARC Easy score of the quantized models.

ARC Challenge

The table below depicts the ARC Challenge score of the original models.

The table below depicts the ARC Challenge score of the quantized models.

Perplexity

The table below depicts the perplexity of the original models.

The table below depicts the perplexity of the quantized models.