diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..2f77e919
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+*.ipynb linguist-documentation
diff --git a/README.md b/README.md
index 04c0760d..7c6e2bba 100644
--- a/README.md
+++ b/README.md
@@ -64,6 +64,10 @@ For a detailed list of existing KV cache compression methods, check [Awesome-KV-
## Evaluation
+See the [speed_and_memory.ipynb](notebooks/speed_and_memory.ipynb) notebook on how to measure peak memory usage and total time gain.
+
+
+
We provide a simple CLI to evaluate the performance of the different presses on several long-context datasets.
_Average performance on the RULER dataset with 4k context length and Loogle Short Dependency QA task for 3 models and 7 presses_
diff --git a/evaluation/README.md b/evaluation/README.md
index 7eb0b97c..c826381e 100644
--- a/evaluation/README.md
+++ b/evaluation/README.md
@@ -7,7 +7,7 @@ This directory contains a set of scripts to evaluate the performance of differen
- [Infinitebench](infinite_bench/README.md) ([hf link](https://huggingface.co/datasets/MaxJeblick/InfiniteBench))
-Please refer to the README of each dataset for more information on how the huggingface dataset was generated.
+Please refer to the README of each dataset for more information on how the Hugging Face dataset was generated.
## Usage
@@ -99,7 +99,7 @@ $dataset
```
Where:
-- `create_huggingface_dataset.py` is a script that generates the huggingface dataset from the original dataset. Each dataset is associated with a set of parquet files with the following structure:
+- `create_huggingface_dataset.py` is a script that generates the Hugging Face dataset from the original dataset. Each dataset is associated with a set of parquet files with the following structure:
- `context`: ...
- `question`: ...
- `answer_prefix`: ...
diff --git a/evaluation/assets/peak_memory_consumption.png b/evaluation/assets/peak_memory_consumption.png
new file mode 100644
index 00000000..d2838909
Binary files /dev/null and b/evaluation/assets/peak_memory_consumption.png differ
diff --git a/evaluation/infinite_bench/README.md b/evaluation/infinite_bench/README.md
index eea45e01..241ad613 100644
--- a/evaluation/infinite_bench/README.md
+++ b/evaluation/infinite_bench/README.md
@@ -2,6 +2,6 @@
[Infinitebench](https://github.com/OpenBMB/InfiniteBench) is composed of 12 major tasks.
-## Create huggingface dataset
+## Create Hugging Face dataset
-The processed huggingface dataset for Infinitebench can be found [here](https://huggingface.co/datasets/MaxJeblick/InfiniteBench). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script.
\ No newline at end of file
+The processed Hugging Face dataset for Infinitebench can be found [here](https://huggingface.co/datasets/MaxJeblick/InfiniteBench). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script.
\ No newline at end of file
diff --git a/evaluation/loogle/README.md b/evaluation/loogle/README.md
index e3165de9..658cfa62 100644
--- a/evaluation/loogle/README.md
+++ b/evaluation/loogle/README.md
@@ -2,6 +2,6 @@
[Loogle](https://github.com/bigai-nlco/LooGLE/tree/main) is composed of 7 major tasks to evaluate LLMs' ability to understand both short and long dependency content.
-## Create huggingface dataset
+## Create Hugging Face dataset
-The huggingface dataset for Loogle can be found [here](https://huggingface.co/datasets/simonjegou/loogle). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script.
\ No newline at end of file
+The Hugging Face dataset for Loogle can be found [here](https://huggingface.co/datasets/simonjegou/loogle). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script.
\ No newline at end of file
diff --git a/evaluation/ruler/README.md b/evaluation/ruler/README.md
index 4e34caa6..85eaf351 100644
--- a/evaluation/ruler/README.md
+++ b/evaluation/ruler/README.md
@@ -2,9 +2,9 @@
[RULER](https://arxiv.org/abs/2404.06654) generates synthetic examples to evaluate long-context language models with configurable sequence length (from 4k tokens to 128k tokens) and task complexity. It contains a set of 13 tasks grouped in 4 categories (needle in the haystack, question answering, multi-hop tracing and aggregation).
-## Huggingface dataset
+## Hugging Face dataset
-The huggingface dataset for RULER can be found [here](https://huggingface.co/datasets/simonjegou/ruler). To reproduce this dataset,
+The Hugging Face dataset for RULER can be found [here](https://huggingface.co/datasets/simonjegou/ruler). To reproduce this dataset,
1. Install the [RULER repository](https://github.com/hsiehjackson/RULER) and download the necessary data files (see 1. Download data in the README)
2. Copy paste the `generate.sh` from this repository to `$RULER/scripts`, set the `DATA_DIR` variable to your desired location of the RULER data files and run the script
diff --git a/evaluation/ruler/generate.sh b/evaluation/ruler/generate.sh
index aafa915a..d5488c93 100644
--- a/evaluation/ruler/generate.sh
+++ b/evaluation/ruler/generate.sh
@@ -1,4 +1,4 @@
-# The following script prepares the synthetic data benchmark for a given huggingface tokenizer and without template
+# The following script prepares the synthetic data benchmark for a given Hugging Face tokenizer and without template
# Before running this script, make sure you downloaded the data as explained in the README:
# cd scripts/data/synthetic/json/
# python download_paulgraham_essay.py
diff --git a/evaluation/zero_scrolls/README.md b/evaluation/zero_scrolls/README.md
index af7b745a..73aba0ad 100644
--- a/evaluation/zero_scrolls/README.md
+++ b/evaluation/zero_scrolls/README.md
@@ -2,9 +2,9 @@
[Zero scrolls](https://www.zero.scrolls-benchmark.com/) includes ten natural language tasks across multiple domains, including summarization, question answering, aggregated sentiment classification and information reordering.
-## Hugginface dataset
+## Hugging Face dataset
-The huggingface dataset for Zero Scrolls can be found [here](https://huggingface.co/datasets/simonjegou/zero_scroll). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script.
+The Hugging Face dataset for Zero Scrolls can be found [here](https://huggingface.co/datasets/simonjegou/zero_scroll). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script.
## Evaluation
diff --git a/notebooks/speed_and_memory.ipynb b/notebooks/speed_and_memory.ipynb
index 98f9be65..4c9210eb 100644
--- a/notebooks/speed_and_memory.ipynb
+++ b/notebooks/speed_and_memory.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "In this notebook, we showcase the memory and speed improvement obtained using the KV press pipeline (tested using A100 with 80GB memory)."
+ "**In this notebook, we showcase the memory and speed improvement obtained using the KV press pipeline (tested using A100 with 80GB memory).**"
]
},
{
@@ -12,176 +12,441 @@
"execution_count": 1,
"metadata": {},
"outputs": [],
+ "source": [
+ "# Run these below to be able to use quantized cache \n",
+ "# See also: https://huggingface.co/blog/kv-cache-quantization#how-to-use-quantized-kv-cache-in-%F0%9F%A4%97-transformers\n",
+ "#!pip install git+https://github.com/huggingface/transformers.git --upgrade\n",
+ "#!pip install -U optimum-quanto"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
"source": [
"import warnings\n",
- "warnings.filterwarnings(\"ignore\")\n",
"from time import time\n",
+ "from tqdm import tqdm\n",
"\n",
+ "import numpy as np\n",
"import torch\n",
- "from transformers import AutoModelForCausalLM\n",
+ "from transformers import AutoModelForCausalLM, pipeline\n",
+ "from transformers import QuantizedCacheConfig, QuantoQuantizedCache, DynamicCache, QuantizedCache\n",
+ "from transformers.utils.logging import disable_progress_bar\n",
+ "import transformers\n",
"\n",
- "from kvpress import ExpectedAttentionPress"
+ "from kvpress import KnormPress"
]
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "warnings.filterwarnings(\"ignore\")\n",
+ "transformers.logging.set_verbosity_error()\n",
+ "disable_progress_bar()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "device = \"cuda:0\"\n",
+ "ckpt = \"meta-llama/Meta-Llama-3.1-8B-Instruct\"\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def get_size_of_cache(cache):\n",
+ " if isinstance(cache, QuantoQuantizedCache):\n",
+ " value_cache = cache._quantized_value_cache\n",
+ " key_cache = cache._quantized_key_cache\n",
+ " size_in_bytes = 0\n",
+ " for value in value_cache:\n",
+ " size_in_bytes += value._data.nelement() * value._data.element_size()\n",
+ " size_in_bytes += value._scale.nelement() * value._scale.element_size()\n",
+ " size_in_bytes += value._shift.nelement() * value._shift.element_size()\n",
+ "\n",
+ " for key in key_cache:\n",
+ " size_in_bytes += key._data.nelement() * key._data.element_size()\n",
+ " size_in_bytes += key._scale.nelement() * key._scale.element_size()\n",
+ " size_in_bytes += key._shift.nelement() * key._shift.element_size()\n",
+ " return size_in_bytes\n",
+ "\n",
+ " elif isinstance(cache, DynamicCache):\n",
+ " value_cache = cache.value_cache\n",
+ " key_cache = cache.key_cache\n",
+ " size_in_bytes = 0\n",
+ " for value in value_cache:\n",
+ " size_in_bytes += value.element_size() * value.nelement()\n",
+ " for key in key_cache:\n",
+ " size_in_bytes += key.element_size() * key.nelement()\n",
+ " return size_in_bytes\n",
+ " else:\n",
+ " raise NotimplementedError(f\"{type(cache)} is not supported yet.\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# The model is loaded each time inside the function to avoid potential GPU leakage\n",
+ "\n",
+ "def get_prefilling_stats(press, n_tokens, cache_implementation=\"dynamic\"):\n",
+ " torch.cuda.reset_peak_memory_stats()\n",
+ " torch.cuda.empty_cache()\n",
+ " idle_peak_memory = torch.cuda.max_memory_allocated()\n",
+ " model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=\"auto\", attn_implementation=\"flash_attention_2\").to(device)\n",
+ " initial_peak_memory = torch.cuda.max_memory_allocated()\n",
+ "\n",
+ " inputs =torch.arange(n_tokens).reshape([1, n_tokens]).to(device)\n",
+ " # Model warmup (for better prefilling time estimation)\n",
+ " with torch.no_grad():\n",
+ " model(inputs[:, :100])\n",
+ " torch.cuda.synchronize()\n",
+ " torch.cuda.empty_cache()\n",
+ "\n",
+ " # Compute cache size and prefilling time\n",
+ " start = time()\n",
+ " with torch.no_grad(), press(model):\n",
+ " if cache_implementation == \"dynamic\":\n",
+ " cache = DynamicCache()\n",
+ " elif cache_implementation == \"quantized\":\n",
+ " config = QuantizedCacheConfig(nbits=4)\n",
+ " cache = QuantoQuantizedCache(config)\n",
+ " else:\n",
+ " raise NotImplementedError(f\"Cache {cache_impl} not yet implemented\")\n",
+ " \n",
+ " model(inputs, num_logits_to_keep=1, past_key_values=cache)\n",
+ " cache_size = get_size_of_cache(cache)\n",
+ " del cache\n",
+ " \n",
+ " prefilling_time = time() - start\n",
+ " \n",
+ " peak_memory = torch.cuda.max_memory_allocated()\n",
+ " model.cpu()\n",
+ " torch.cuda.empty_cache()\n",
+ " torch.cuda.reset_peak_memory_stats()\n",
+ " return {\"Idle Peak memory\": idle_peak_memory / 1024**3,\n",
+ " \"Initial Peak memory\": initial_peak_memory / 1024**3,\n",
+ " \"Prefilling time\": prefilling_time, \n",
+ " \"Peak memory usage\": peak_memory / 1024**3,\n",
+ " \"Cache Size\": cache_size / 1024**3,\n",
+ " \"Peak memory w/o weights and KV cache (GB)\": (peak_memory - cache_size - initial_peak_memory) / 1024**3\n",
+ " }"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def get_generation_stats(press, n_tokens, max_new_tokens = 100, cache_implementation=\"dynamic\"):\n",
+ " torch.cuda.reset_peak_memory_stats()\n",
+ " torch.cuda.empty_cache()\n",
+ " idle_peak_memory = torch.cuda.max_memory_allocated()\n",
+ " model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=\"auto\", attn_implementation=\"flash_attention_2\").to(device)\n",
+ " # disable EosTokenCriteria stopping criteria\n",
+ " model.generation_config.eos_token_id = None\n",
+ " model.generation_config.stop_strings = None\n",
+ " \n",
+ " model.generation_config.do_sample = False\n",
+ " model.generation_config.temperature = None\n",
+ " model.generation_config.top_p = None\n",
+ "\n",
+ " initial_peak_memory = torch.cuda.max_memory_allocated()\n",
+ " \n",
+ " inputs =torch.arange(n_tokens).reshape([1, n_tokens]).to(device)\n",
+ "\n",
+ " start = time()\n",
+ " with press(model):\n",
+ " kwargs = dict()\n",
+ " if cache_implementation == \"quantized\":\n",
+ " kwargs = dict(cache_implementation=\"quantized\",\n",
+ " cache_config={\"backend\": \"quanto\", \"nbits\": 4})\n",
+ " \n",
+ " outputs = model.generate(inputs, max_new_tokens=max_new_tokens,\n",
+ " generation_config=model.generation_config,\n",
+ " pad_token_id=-1, **kwargs)\n",
+ " assert outputs.shape == (1, n_tokens + max_new_tokens), outputs.shape\n",
+ "\n",
+ " total_time = time() - start\n",
+ " peak_memory = torch.cuda.max_memory_allocated()\n",
+ "\n",
+ " model.cpu()\n",
+ " torch.cuda.empty_cache()\n",
+ " torch.cuda.reset_peak_memory_stats()\n",
+ " return {\"Idle Peak memory\": idle_peak_memory / 1024**3,\n",
+ " \"Initial Peak memory\": initial_peak_memory / 1024**3,\n",
+ " \"Total time\": total_time, \n",
+ " \"Peak memory usage\": peak_memory / 1024**3\n",
+ " }"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def combine_stats(prefilling_stats, generation_stats):\n",
+ " \"\"\"Combines prefilling and generation data, then plots.\"\"\"\n",
+ " combined_stats = {}\n",
+ " for compression_ratio in prefilling_stats:\n",
+ " combined_stats[compression_ratio] = dict()\n",
+ " combined_stats[compression_ratio]['Peak memory usage'] = generation_stats[compression_ratio]['Peak memory usage']\n",
+ " combined_stats[compression_ratio]['Prefilling time'] = prefilling_stats[compression_ratio]['Prefilling time']\n",
+ " combined_stats[compression_ratio]['Cache Size'] = prefilling_stats[compression_ratio]['Cache Size']\n",
+ " combined_stats[compression_ratio]['Total time'] = generation_stats[compression_ratio]['Total time']\n",
+ " combined_stats[compression_ratio]['Generation time'] = generation_stats[compression_ratio]['Total time'] - prefilling_stats[compression_ratio]['Prefilling time']\n",
+ " \n",
+ " return combined_stats"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "You are attempting to use Flash Attention 2.0 with a model not initialized on GPU. Make sure to move the model to GPU after initializing it on CPU with `model.to('cuda')`.\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "65d3b16c204e4537a79ef6f1397f5278",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Loading checkpoint shards: 0%| | 0/4 [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Initial peak memory usage: 14.96 GB\n"
+ "100%|██████████| 8/8 [01:31<00:00, 11.41s/it]\n",
+ "100%|██████████| 8/8 [01:54<00:00, 14.28s/it]\n",
+ "100%|██████████| 8/8 [01:34<00:00, 11.79s/it]\n",
+ "100%|██████████| 8/8 [01:58<00:00, 14.80s/it]\n",
+ "100%|██████████| 8/8 [01:52<00:00, 14.12s/it]\n",
+ "100%|██████████| 8/8 [02:15<00:00, 16.96s/it]\n",
+ "100%|██████████| 8/8 [02:38<00:00, 19.85s/it]\n",
+ "100%|██████████| 8/8 [03:06<00:00, 23.33s/it]\n",
+ "100%|██████████| 8/8 [05:18<00:00, 39.84s/it]\n",
+ "100%|██████████| 8/8 [05:56<00:00, 44.61s/it]\n"
]
}
],
"source": [
- "# Load model\n",
- "\n",
- "device = \"cuda:0\"\n",
- "ckpt = \"meta-llama/Meta-Llama-3.1-8B-Instruct\"\n",
- "n_tokens = 128_000\n",
- "model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=\"auto\", attn_implementation=\"flash_attention_2\").to(device)\n",
+ "stats = {}\n",
"\n",
- "initial_peak_memory = torch.cuda.max_memory_allocated()\n",
- "print(f\"Initial peak memory usage: {initial_peak_memory / 1024**3:.2f} GB\")"
+ "compression_ratios = [0.0, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]\n",
+ "for n_tokens in [8_000, 16_000, 32_000, 64_000, 128_000]:\n",
+ " prefilling_stats = {compression_ratio : get_prefilling_stats(press=KnormPress(compression_ratio), n_tokens=n_tokens)\n",
+ " for compression_ratio in tqdm(compression_ratios)}\n",
+ " generation_stats = {compression_ratio : get_generation_stats(press=KnormPress(compression_ratio), n_tokens=n_tokens)\n",
+ " for compression_ratio in tqdm(compression_ratios)}\n",
+ " \n",
+ " # ensure idle Peak memory is neglibible\n",
+ " for compression_ratio in compression_ratios:\n",
+ " assert prefilling_stats[compression_ratio][\"Idle Peak memory\"] < 0.01\n",
+ " assert generation_stats[compression_ratio][\"Idle Peak memory\"] < 0.01\n",
+ " stats[n_tokens] = combine_stats(prefilling_stats, generation_stats)"
]
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "Starting from v4.46, the `logits` model output will have the same type as the model (except at train time, where it will always be FP32)\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Cache size for 128000 tokens: 15.625 GB\n",
- "Peak memory usage: 44.81 GB\n",
- "Peak memory w/o weights and KV cache: 14.23 GB\n",
- "Prefilling time: 28.56s\n"
+ "100%|██████████| 8/8 [01:29<00:00, 11.22s/it]\n",
+ "100%|██████████| 8/8 [01:58<00:00, 14.77s/it]\n",
+ "100%|██████████| 8/8 [01:36<00:00, 12.02s/it]\n",
+ "100%|██████████| 8/8 [02:05<00:00, 15.70s/it]\n",
+ "100%|██████████| 8/8 [01:52<00:00, 14.05s/it]\n",
+ "100%|██████████| 8/8 [02:27<00:00, 18.41s/it]\n",
+ "100%|██████████| 8/8 [02:40<00:00, 20.05s/it]\n",
+ "100%|██████████| 8/8 [03:31<00:00, 26.41s/it]\n",
+ "100%|██████████| 8/8 [05:23<00:00, 40.43s/it]\n",
+ "100%|██████████| 8/8 [06:53<00:00, 51.64s/it]\n"
]
}
],
"source": [
- "# Compute cache size and prefiling time\n",
- "\n",
- "inputs = torch.randint(0, model.config.vocab_size, (1, n_tokens)).to(device)\n",
- "\n",
- "# Model warmup (for better prefilling time estimation)\n",
- "with torch.no_grad():\n",
- " model(inputs[:, :100])\n",
- "torch.cuda.synchronize()\n",
- "\n",
- "# Compute cache size and prefilling time\n",
- "start = time()\n",
- "with torch.no_grad():\n",
- " cache = model(inputs, num_logits_to_keep=1).past_key_values\n",
- " cache_size = 2 * 2 * len(cache) * cache[0][0].numel() # 2 for keys and values, 2 for float16\n",
- " del cache\n",
- "prefilling_time = time() - start\n",
- "\n",
- "peak_memory = torch.cuda.max_memory_allocated()\n",
- "torch.cuda.empty_cache()\n",
- "print(f\"Cache size for {n_tokens} tokens: {cache_size / 1024**3:.3f} GB\")\n",
- "print(f\"Peak memory usage: {peak_memory / 1024**3:.2f} GB\")\n",
- "print(f\"Peak memory w/o weights and KV cache: {(peak_memory - cache_size - initial_peak_memory) / 1024**3:.2f} GB\")\n",
- "print(f\"Prefilling time: {prefilling_time:.2f}s\")"
+ "stats_quantized = {}\n",
+ "\n",
+ "compression_ratios = [0.0, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]\n",
+ "for n_tokens in [8_000, 16_000, 32_000, 64_000, 128_000]:\n",
+ " prefilling_stats = {compression_ratio : get_prefilling_stats(press=KnormPress(compression_ratio), n_tokens=n_tokens, cache_implementation=\"quantized\")\n",
+ " for compression_ratio in tqdm(compression_ratios)}\n",
+ " generation_stats = {compression_ratio : get_generation_stats(press=KnormPress(compression_ratio), n_tokens=n_tokens, cache_implementation=\"quantized\")\n",
+ " for compression_ratio in tqdm(compression_ratios)}\n",
+ " # ensure idle Peak memory is neglibible\n",
+ " for compression_ratio in compression_ratios:\n",
+ " assert prefilling_stats[compression_ratio][\"Idle Peak memory\"] < 0.01\n",
+ " assert generation_stats[compression_ratio][\"Idle Peak memory\"] < 0.01\n",
+ " stats_quantized[n_tokens] = combine_stats(prefilling_stats, generation_stats)"
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 44,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pylab as plt\n",
+ "from matplotlib.colors import LinearSegmentedColormap\n",
+ "import numpy as np\n",
+ "\n",
+ "def plot_compression_stats(stats, title_suffix='', max_peak_memory=45, max_cache_size=17.5, max_generation_time=20):\n",
+ " gree_color = np.array([118, 185, 0]) / 255\n",
+ " cmap = LinearSegmentedColormap.from_list(\"apple_green_to_black\", [gree_color / 4, gree_color])\n",
+ " \n",
+ " \n",
+ " context_lengths = sorted(stats.keys())\n",
+ " compression_ratios = sorted(stats[context_lengths[0]].keys())\n",
+ " \n",
+ " fig, axes = plt.subplots(1, 3, figsize=(24, 6))\n",
+ " \n",
+ " #Peak Memory Usage\n",
+ " for i, context_length in enumerate(context_lengths):\n",
+ " memory_usages = [stats[context_length][ratio]['Peak memory usage'] for ratio in compression_ratios]\n",
+ " axes[0].plot(compression_ratios, memory_usages, '-o', label=f'{context_length} tokens', color=cmap(i/(len(context_lengths)-1)))\n",
+ " \n",
+ " axes[0].set_xlabel('Compression Ratio')\n",
+ " axes[0].set_ylabel('Peak Memory Usage (GB)')\n",
+ " axes[0].set_title('Peak Memory Usage vs. Compression Ratio' + title_suffix)\n",
+ " axes[0].legend()\n",
+ " axes[0].grid(True)\n",
+ " axes[0].set_ylim(0, max_peak_memory)\n",
+ "\n",
+ " #Cache Size\n",
+ " for i, context_length in enumerate(context_lengths):\n",
+ " memory_usages = [stats[context_length][ratio]['Cache Size'] for ratio in compression_ratios]\n",
+ " axes[1].plot(compression_ratios, memory_usages, '-o', label=f'{context_length} tokens', color=cmap(i/(len(context_lengths)-1)))\n",
+ " \n",
+ " axes[1].set_xlabel('Compression Ratio')\n",
+ " axes[1].set_ylabel('Cache Size (GB)')\n",
+ " axes[1].set_title('Cache Size vs. Compression Ratio' + title_suffix)\n",
+ " axes[1].legend()\n",
+ " axes[1].grid(True)\n",
+ " axes[1].set_ylim(0, max_cache_size)\n",
+ " \n",
+ " #Generation Time\n",
+ " for i, context_length in enumerate(context_lengths):\n",
+ " generation_times = [stats[context_length][ratio]['Generation time'] for ratio in compression_ratios]\n",
+ " axes[2].plot(compression_ratios, generation_times, '-o', label=f'{context_length} tokens', color=cmap(i/(len(context_lengths)-1)))\n",
+ " \n",
+ " axes[2].set_xlabel('Compression Ratio')\n",
+ " axes[2].set_ylabel('Generation Time (seconds)')\n",
+ " axes[2].set_title('Generation Time vs. Compression Ratio'+ title_suffix)\n",
+ " axes[2].legend()\n",
+ " axes[2].grid(True)\n",
+ " axes[2].set_ylim(0, max_generation_time)\n",
+ "\n",
+ " plt.tight_layout()\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
"metadata": {},
"outputs": [
{
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "The `seen_tokens` attribute is deprecated and will be removed in v4.41. Use the `cache_position` model input instead.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\n",
- "Compression ratio: 0.75\n"
- ]
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
},
{
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Total time: 35.04s. Estimated generation time: 6.48s\n",
- "Peak memory usage: 33.10 GB\n",
- "\n",
- "Compression ratio: 0.5\n",
- "Total time: 36.27s. Estimated generation time: 7.71s\n",
- "Peak memory usage: 37.00 GB\n",
- "\n",
- "Compression ratio: 0.25\n",
- "Total time: 37.63s. Estimated generation time: 9.08s\n",
- "Peak memory usage: 40.91 GB\n",
- "\n",
- "Compression ratio: 0.0\n",
- "Total time: 37.92s. Estimated generation time: 9.36s\n",
- "Peak memory usage: 44.82 GB\n"
- ]
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
}
],
"source": [
- "# Compute peak memory usage and generation time for different compression ratios\n",
+ "plot_compression_stats(stats, title_suffix=' (bfloat16)', max_peak_memory=45, max_cache_size=17.5)\n",
+ "plot_compression_stats(stats_quantized, title_suffix=' (4bit)', max_peak_memory=45, max_cache_size=17.5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "from matplotlib.colors import LinearSegmentedColormap\n",
"\n",
- "def timer(press, max_new_tokens = 100):\n",
- " start = time()\n",
- " with press(model):\n",
- " outputs = model.generate(inputs, max_new_tokens=max_new_tokens, do_sample=False, temperature=None, top_p=None, pad_token_id=-1)\n",
- " assert outputs.shape == (1, n_tokens + max_new_tokens)\n",
- " return time() - start\n",
+ "def plot_memory_vs_context_length(stats, stats_quantized, fontsize=13):\n",
+ " gree_color = np.array([118, 185, 0]) / 255\n",
+ " cmap = LinearSegmentedColormap.from_list(\"apple_green_to_black\", [gree_color / 4, gree_color])\n",
+ "\n",
+ " context_lengths = sorted(stats.keys())\n",
+ "\n",
+ " bf16_peak_mem = [stats[cl][0.0]['Peak memory usage'] for cl in context_lengths]\n",
+ " int4_peak_mem = [stats_quantized[cl][0.0]['Peak memory usage'] for cl in context_lengths]\n",
+ " bf16_compressed_peak_mem = [stats[cl][0.5]['Peak memory usage'] for cl in context_lengths]\n",
+ " int4_compressed_peak_mem = [stats_quantized[cl][0.5]['Peak memory usage'] for cl in context_lengths]\n",
" \n",
- "for compression_ratio in [0.75, 0.5, 0.25, 0.0]:\n",
- " print(f\"\\nCompression ratio: {compression_ratio}\")\n",
- " press = ExpectedAttentionPress(compression_ratio)\n",
- " torch.cuda.reset_peak_memory_stats()\n",
- " total_time = timer(press)\n",
- " print(f\"Total time: {total_time:.2f}s. Estimated generation time: {total_time - prefilling_time:.2f}s\")\n",
- " print(f\"Peak memory usage: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB\")"
+ " plt.figure(figsize=(8, 5))\n",
+ " \n",
+ " # Plot data with colormap\n",
+ " plt.plot(context_lengths, bf16_peak_mem, '-o', label='bfloat16 cache', color=cmap(1/4))\n",
+ " plt.plot(context_lengths, int4_peak_mem, '-o', label='int4 cache', color=cmap(2/4))\n",
+ " plt.plot(context_lengths, bf16_compressed_peak_mem, '-o', label='bfloat16 cache + 50% compression', color=cmap(3/4))\n",
+ " plt.plot(context_lengths, int4_compressed_peak_mem, '-o', label='int4 cache + 50% compression', color=cmap(4/4))\n",
+ " \n",
+ " plt.xlabel('Context Length (tokens)', fontsize=fontsize + 2)\n",
+ " plt.ylabel('Peak Memory Usage (GB)', fontsize=fontsize + 2)\n",
+ " plt.title('Peak Memory Usage vs. Context Length (Meta-Llama-3.1-8B-Instruct)', fontsize=fontsize + 2)\n",
+ " plt.legend(fontsize=fontsize)\n",
+ " plt.grid(True)\n",
+ " plt.xticks(fontsize=fontsize)\n",
+ " plt.yticks(fontsize=fontsize)\n",
+ " \n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_memory_vs_context_length(stats, stats_quantized)"
]
}
],
"metadata": {
"kernelspec": {
- "display_name": ".venv",
+ "display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
@@ -195,9 +460,9 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.12"
+ "version": "3.10.15"
}
},
"nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
}