Lab4_oohyun.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "39bd00a2",
      "metadata": {},
      "source": [
        "# **Lab 4: LLM Quantization with AWQ**\n",
        "> MIT 6.5940 EfficientML.ai Fall 2023"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0e7d3f94",
      "metadata": {},
      "source": [
        "이번 시간은 LLM Quantization을 실습하는 시간입니다. 데이터셋으로는 wikitext-2-raw-v1를 사용한고 Facebook에서 공개한 1.3 Billion 크기의 LLM 모델을 가지고 Activation Aware Quantization을 실습해볼 것입니다.\n",
        "\n",
        "Top 1%를 FP16으로 유지하면 Weight가 다른 데이터 타입으로 해야하는 데 이는 현실적으로는 힘들다고 하기에, Scaling하는 것 까지 실험할 예정입니다.\n",
        "\n",
        "실습 순서는 다음과 같습니다.\n",
        "\n",
        "1. Setup (Package, Model, Dataset)\n",
        "2. 4bit Quantization LLM\n",
        "3. Keep Top 1% of the activations\n",
        "4. Keep Random 1% of the activations\n",
        "5. Scale Top 1% of the activations\n",
        "6. Scale activation in serach space \n",
        "\n",
        "이번 실습은 길지 않아 순서대로 진행하며, 각 단계별로 실험 결과를 확인해보면 되겠습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e9df27e7",
      "metadata": {
        "id": "e9df27e7"
      },
      "source": [
        "## Introduction\n",
        "\n",
        "This colab notebook provides code and a framework for Lab 4: LLM Quantization. You will learn how to quantize a large language model that can run efficiently. We will implement AWQ (activation aware weight only quantization) for 4 bit weight-only quantization.\n",
        "\n",
        "Running large language models (LLMs) on the edge is of great importance, which not only enhances user experience but also addresses privacy concerns, as sensitive data remains localized and reduces the risk of potential breaches.\n",
        "\n",
        "However, deploying LLMs on the edge presents significant challenges. Edge devices operate under tight power constraints, setting them apart from workstations or cloud servers. This translates to restricted memory bandwidth and limited peak computation throughput on the edge. For instance, the NVIDIA Jetson Orin Nano, with its 8GB DRAM, cannot accommodate even the most compact LLaMA-2 model in half precision. Thankfully, AWQ presents a push-the-button solution for weight quantization, empowering LLM inference on edge devices with constrained memory.\n",
        "\n",
        "Furthermore, by using the AWQ 4-bit weight-only quantization algorithm, combined with an efficient 4-bit kernel, we can achieve the following acceleration on the RTX 4090. In the next lab section, we will also use TinyChatEnigne to achieve actual performance acceleration."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "MKX1i6epRi3G",
      "metadata": {
        "id": "MKX1i6epRi3G"
      },
      "source": [
        "# AWQ (activation aware weight only quantization)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "02e4a918",
      "metadata": {},
      "source": [
        "![](../../images/lab04/1.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "41b79e03",
      "metadata": {
        "id": "41b79e03"
      },
      "source": [
        "Large language models (LLMs) have shown excellent performance on various tasks, but the astronomical model size raises the hardware barrier for serving (memory size) and slows down token generation (memory bandwidth). LLM sizes and computation are increasing exponentially, while memory bandwidth is increasing slowly. This gap is a major bottleneck for LLMs. In this lab, we will explore the use of an novel quantization algorithm (AWQ) to reduce memory footprint of LLMs and achieve accelerations for inference."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9f55aea4",
      "metadata": {
        "id": "9f55aea4"
      },
      "source": [
        "In previous courses, we have learned the basic methods of quantization.\n",
        "There are two types of quantization:\n",
        "\n",
        "- Quantize both weight and activation\n",
        "    - Better for computation-bounded scenarios: context stage, large batch inference\n",
        "    - For example, SmoothQuant: W8A8 quantization\n",
        "- Weight-only quantization\n",
        "    - Better for memory-bounded scenarios: decoding stage, single batch inference\n",
        "    - For example, AWQ that will be introduced in this lab: W4A16 quantization"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a4a1ad9f",
      "metadata": {
        "id": "a4a1ad9f"
      },
      "source": [
        "For the LLaMA-65B model, in the decoding stage of single batch inference, we need to perform GEMV $[1, 8192] \\times [8192, 8192]$. Taking the NVIDIA A100 80G as an example, its half-precision (FP16) performance is 312TFLOPS, and the memory bandwidth is about 2000GB/s. Therefore, its computation intensity is:\n",
        "\n",
        "$$\n",
        "\\frac{\\text{FLOP}}{\\text{Byte}} = \\frac{2\\times 8192^2}{8192^2} << \\frac{3.12\\times 10^{11}}{2\\times 10^9}\n",
        "$$\n",
        "\n",
        "This is very memory-bounded (~$10^2$ gap), which is why we need low-bit weight quantization."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "174d2d1e",
      "metadata": {
        "id": "174d2d1e"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2797112a",
      "metadata": {
        "id": "2797112a"
      },
      "outputs": [],
      "source": [
        "print('Installing packages...')\n",
        "!pip install torch transformers==4.31.0 accelerate==0.21.0 sentencepiece==0.1.99 tokenizers==0.13.3 tqdm zstandard\n",
        "# !pip install torch transformers==4.31.0 accelerate==0.21.0 sentencepiece==0.1.99 tokenizers==0.13.3 datasets==2.14.4 tqdm zstandard"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c8985111",
      "metadata": {},
      "outputs": [],
      "source": [
        "# ValueError: Invalid pattern: '**' can only be an entire path component\n",
        "# https://stackoverflow.com/questions/77671277/valueerror-invalid-pattern-can-only-be-an-entire-path-component\n",
        "# The solution works for datasets version 2.10.1 on Python 3.10, as it should update the package with a hotfix that was added for version > 2.15.0.\n",
        "!pip install -U datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "id": "cfe5330c",
      "metadata": {
        "id": "cfe5330c"
      },
      "outputs": [],
      "source": [
        "import tqdm\n",
        "import torch\n",
        "from torch import nn\n",
        "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
        "from datasets import load_dataset\n",
        "from functools import partial\n",
        "import gc"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2a86da42",
      "metadata": {
        "id": "2a86da42"
      },
      "source": [
        "Here we use wikitext-2 dataset for evaluation. The dataset is automatically downloaded by the code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "84ce637b",
      "metadata": {
        "id": "84ce637b"
      },
      "outputs": [],
      "source": [
        "def evaluate(model, tokenizer):\n",
        "    testenc = load_dataset('wikitext', 'wikitext-2-raw-v1', split='test')\n",
        "    # testenc = load_dataset('wikitext', 'wikitext-103-v1', split='train')\n",
        "    testenc = tokenizer(\"\\n\\n\".join(testenc['text']), return_tensors='pt')\n",
        "\n",
        "    testenc = testenc.input_ids.to(model.device)\n",
        "    nsamples = 40\n",
        "    model = model.eval()\n",
        "\n",
        "    nlls = []\n",
        "    for i in tqdm.tqdm(range(nsamples), desc=\"evaluating...\"):\n",
        "        batch = testenc[:, (i * 2048):((i + 1) * 2048)].to(model.device)\n",
        "        with torch.no_grad():\n",
        "            lm_logits = model(batch).logits\n",
        "        shift_logits = lm_logits[:, :-1, :].contiguous().float()\n",
        "        shift_labels = testenc[:, (i * 2048):((i + 1) * 2048)][:, 1:]\n",
        "        loss_fct = nn.CrossEntropyLoss()\n",
        "        loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))\n",
        "        neg_log_likelihood = loss.float() * 2048\n",
        "        nlls.append(neg_log_likelihood)\n",
        "\n",
        "    return torch.exp(torch.stack(nlls).sum() / (nsamples * 2048))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Kq-32KkcyKcM",
      "metadata": {
        "id": "Kq-32KkcyKcM"
      },
      "source": [
        "The following code is used to calculate the model size."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "32204623",
      "metadata": {
        "id": "32204623"
      },
      "outputs": [],
      "source": [
        "def get_model_size(model: nn.Module, data_width=16, group_size=-1):\n",
        "\n",
        "    if group_size != -1:\n",
        "        data_width += (16 + 4) / group_size\n",
        "\n",
        "    num_elements = 0\n",
        "    for param in model.parameters():\n",
        "        num_elements += param.numel()\n",
        "    return num_elements * data_width\n",
        "\n",
        "Byte = 8\n",
        "KiB = 1024 * Byte\n",
        "MiB = 1024 * KiB\n",
        "GiB = 1024 * MiB"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "id": "ea752638",
      "metadata": {},
      "outputs": [],
      "source": [
        "model_path = \"facebook/opt-1.3b\"\n",
        "tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False)\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2a9be846",
      "metadata": {
        "id": "2a9be846"
      },
      "source": [
        "Let's first evaluate the perplexity and model size of the FP32 Model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "id": "b723b52b",
      "metadata": {
        "id": "b723b52b"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.41it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "model perplexity: 14.47\n",
            "model size: 5043.73 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the model\n",
        "model_perplexity = evaluate(model, tokenizer)\n",
        "model_size = get_model_size(model, data_width=32, group_size=128)\n",
        "print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3eb40d37",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Check each layer in model \n",
        "for n, m in model.named_modules():\n",
        "    print(f\"{n}: {m}\")\n",
        "    if isinstance(m, nn.Linear):\n",
        "        print(f\"{n}: {m.weight.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "VB2bNIrKySLZ",
      "metadata": {
        "id": "VB2bNIrKySLZ"
      },
      "source": [
        "Uniform quantization is to map real values in the range $[\\beta, \\alpha]$ to lie within $[0, 2^{b} - 1]$.\n",
        "\n",
        "Notation:\n",
        "\n",
        "- Quantized Weight: $w_q$\n",
        "\n",
        "- Scale factor: $s_q$\n",
        "\n",
        "- Zero Point: $z$\n",
        "\n",
        "\\begin{equation}\n",
        "s_q = \\frac{\\alpha - \\beta}{2^{b} - 1} \\tag{1},\n",
        "\\end{equation}\n",
        "\n",
        "\\begin{equation}\n",
        "z = -\\text{Round}(\\beta * scale) \\tag{2}\n",
        "\\end{equation}\n",
        "\n",
        "\\begin{equation}\n",
        "w_q = \\text{Clamp}(\\text{Round}(\\frac{w}{s_q}) + z) \\tag{3},\n",
        "\\end{equation}\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "au0OJ3lV_irH",
      "metadata": {
        "id": "au0OJ3lV_irH"
      },
      "source": [
        "### pseudo quantization\n",
        "The following code is for pseudo quantization.\n",
        "\n",
        "Pseudo Quantization is used to simulate the effects of quantization on a model  without actually quantizing the model's weights. (i.e. rounding to the nearest quantized value and then **dequantizing back to a float**.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "id": "96157c7b",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(True)"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "test_vector = torch.randn(10)\n",
        "# test_vector[0] = torch.nan\n",
        "torch.isnan(test_vector).sum() == 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "id": "d63486a4",
      "metadata": {
        "id": "d63486a4"
      },
      "outputs": [],
      "source": [
        "# core quantization method (simulated quantization)\n",
        "def pseudo_quantize_tensor(w, n_bit=4, q_group_size=-1):\n",
        "    org_w_shape = w.shape\n",
        "    if q_group_size > 0:\n",
        "        assert org_w_shape[-1] % q_group_size == 0\n",
        "        w = w.reshape(-1, q_group_size)\n",
        "\n",
        "    assert w.dim() == 2\n",
        "\n",
        "    # Calculate the maximum (\\alpha) and minimum values (\\beta) in the tensor.\n",
        "    max_val = w.amax(dim=1, keepdim=True)\n",
        "    assert max_val.dim() == 2 and max_val.size(0) == w.size(0) and max_val.size(1) == 1\n",
        "    min_val = w.amin(dim=1, keepdim=True)\n",
        "    assert min_val.dim() == 2 and min_val.size(0) == w.size(0) and min_val.size(1) == 1\n",
        "\n",
        "    # Calculate the scale factor and zero point.  (Formula 1 & 2)\n",
        "    max_int = 2 ** n_bit - 1\n",
        "    scales = (max_val - min_val).clamp(min=1e-5) / max_int\n",
        "    assert scales.shape == max_val.shape\n",
        "    zeros = (-torch.round(min_val / scales)).clamp_(0, max_int)\n",
        "    assert scales.shape == min_val.shape\n",
        "    assert torch.isnan(scales).sum() == 0\n",
        "    assert torch.isnan(w).sum() == 0\n",
        "\n",
        "    # Quantize W: Map values in the range [\\beta, \\alpha] to lie within [0, 2^b - 1] (Formula 3)\n",
        "    w = torch.clamp(torch.round(w / scales) + zeros, 0, max_int)\n",
        "    assert w.dim() == 2 and w.size(0) == scales.size(0) and w.size(1) == q_group_size\n",
        "\n",
        "    # Dequantize W (pseudo quantization, the inverse transformation of Formula 3)\n",
        "    w = (w - zeros) * scales\n",
        "    assert w.dim() == 2 and w.size(0) == scales.size(0) and w.size(1) == q_group_size\n",
        "\n",
        "    assert torch.isnan(w).sum() == 0\n",
        "\n",
        "    w = w.reshape(org_w_shape)\n",
        "    return w\n",
        "\n",
        "@torch.no_grad()\n",
        "def pseudo_quantize_model_weight(\n",
        "    model, w_bit, q_group_size,\n",
        "):\n",
        "    for n, m in model.named_modules():\n",
        "        if isinstance(m, nn.Linear):\n",
        "            m.weight.data = pseudo_quantize_tensor(m.weight.data, n_bit=w_bit, q_group_size=q_group_size)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "hU8nK-JY0iKA",
      "metadata": {
        "id": "hU8nK-JY0iKA"
      },
      "source": [
        "Let's evaluate the perplexity and model size of the quantized 3-bit Model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "id": "fc985610",
      "metadata": {
        "id": "fc985610"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "model perplexity: 121.90\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "del model\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "pseudo_quantize_model_weight(model, w_bit=3, q_group_size=128)\n",
        "\n",
        "# Evaluate the model\n",
        "model_perplexity = evaluate(model, tokenizer)\n",
        "model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "KrDoPrp7Ncma",
      "metadata": {
        "id": "KrDoPrp7Ncma"
      },
      "source": [
        "We can see that the model size has decreased, but the perplexity has significantly increased."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "-BAC3SPY0swu",
      "metadata": {
        "id": "-BAC3SPY0swu"
      },
      "source": [
        "There is a observation in LLM activations that **outliers appear in a small fraction of the channels**. If one channel has an outlier, it **persistently appears in all tokens**. The variance amongst the channels for a given token is large (the activations in some channels are very large, but most are small), but the variance between the magnitudes of a given channel across tokens is small (outlier channels are consistently large).\n",
        "\n",
        "According to the observation of AWQ, weight channels corresponding to activation outliers are more salient, and preserving those salient weights can lead to a significant performance improvement. Next, let's try to find the salient weights and retain them as original values to observe the change in perplexity.\n",
        "\n",
        "The following code is used to load the calibration dataset, so as to obtain activation outliers to identify salient weights."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "id": "f67abbef",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([10, 20, 10, 10])\n",
            "torch.Size([2000, 10])\n",
            "torch.Size([10])\n"
          ]
        }
      ],
      "source": [
        "test_vector = torch.randn(10, 20, 10, 10)\n",
        "print(test_vector.shape)\n",
        "test_vector = test_vector.view(-1, test_vector.shape[-1])\n",
        "print(test_vector.shape)\n",
        "test_vector = test_vector.mean(dim=0)\n",
        "print(test_vector.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "fb52620d",
      "metadata": {
        "id": "fb52620d"
      },
      "outputs": [],
      "source": [
        "def get_calib_dataset(tokenizer=None, n_samples=256, block_size=512):\n",
        "    dataset = load_dataset(\"mit-han-lab/pile-val-backup\", split=\"validation\")\n",
        "    dataset = dataset.shuffle(seed=42)\n",
        "    samples = []\n",
        "    n_run = 0\n",
        "    for data in dataset:\n",
        "        line = data[\"text\"]\n",
        "        line = line.strip()\n",
        "        line_encoded = tokenizer.encode(line)\n",
        "        if len(line_encoded) > block_size:\n",
        "            continue\n",
        "        sample = torch.tensor([line_encoded])\n",
        "        if sample.numel() == 0:\n",
        "            continue\n",
        "        samples.append(sample)\n",
        "        n_run += 1\n",
        "        if n_run == n_samples:\n",
        "            break\n",
        "\n",
        "    # now concatenate all samples and split according to block size\n",
        "    cat_samples = torch.cat(samples, dim=1)\n",
        "    n_split = cat_samples.shape[1] // block_size\n",
        "    print(f\" * Split into {n_split} blocks\")\n",
        "    return [cat_samples[:, i*block_size:(i+1)*block_size] for i in range(n_split)]\n",
        "\n",
        "@torch.no_grad()\n",
        "def get_calib_feat(model, tokenizer):\n",
        "    input_dict = dict()\n",
        "    def stat_input_max_hook(m, x, y, name):\n",
        "        if isinstance(x, tuple):\n",
        "            x = x[0]\n",
        "        x_max = x.view(-1, x.shape[-1]).abs().mean(dim=0).cpu().detach()  # each channel's mean in each block (127 in this case)\n",
        "        if name not in input_dict:\n",
        "            input_dict[name] = [x_max]\n",
        "        else:\n",
        "            input_dict[name] += [x_max]\n",
        "\n",
        "    hooks = []\n",
        "    for name, m in model.named_modules():\n",
        "        if isinstance(m, nn.Linear):\n",
        "            hooks.append(\n",
        "                m.register_forward_hook(\n",
        "                    partial(stat_input_max_hook, name=name)))\n",
        "\n",
        "    print(\"Collecting activation scales...\")\n",
        "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "    samples = get_calib_dataset(tokenizer)\n",
        "    pbar = tqdm.tqdm(samples)\n",
        "    for input_ids in pbar:\n",
        "        input_ids = input_ids.to(device)  # (1, 512)\n",
        "        model(input_ids) # gather input max\n",
        "\n",
        "    for hook in hooks:\n",
        "        hook.remove()\n",
        "    return input_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bfd04606",
      "metadata": {
        "id": "bfd04606"
      },
      "outputs": [],
      "source": [
        "del model\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "input_feat = get_calib_feat(model, tokenizer) # each block's mean, 127 blocks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "id": "83889757",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "145"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "input_feat.__len__()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "bb29dc6a",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "model.decoder.layers.0.self_attn.q_proj: 127 torch.Size([2048])\n"
          ]
        }
      ],
      "source": [
        "for k, v in input_feat.items():  # Max in each block(127 blocks)\n",
        "    print(f\"{k}: {v.__len__()} {v[0].shape}\") # each kayer, 127 blocks, each block has 2048 elements\n",
        "    break"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Cu1fUdHnBnDP",
      "metadata": {
        "id": "Cu1fUdHnBnDP"
      },
      "source": [
        "### Question 1 (50 pts)\n",
        "#### Question 1.1 (20 pts)\n",
        "Next, please add codes before and after the quantization to protect 1% of the salient weight channels (1% channels with highest importance), ensuring that their values remain unchanged after quantization. (**The desired perplexity is 17.15**)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "id": "b2654479",
      "metadata": {
        "id": "b2654479"
      },
      "outputs": [],
      "source": [
        "@torch.no_grad()\n",
        "def pseudo_quantize_model_salient_weight_fp16(\n",
        "    model, w_bit, q_group_size, input_feat\n",
        "):\n",
        "    for n, m in model.named_modules():\n",
        "        if isinstance(m, nn.Linear):\n",
        "            importance = sum(input_feat[n]).float()\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 1: Find 1% of the salient weight channels according to importance (hint: use torch.topk())\n",
        "            outlier_indices = torch.topk(importance, int(0.01 * importance.size(0)), largest=True).indices\n",
        "            assert outlier_indices.dim() == 1\n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################\n",
        "\n",
        "            # Back up the values of the salient weight channels\n",
        "            outlier = m.weight.data[:, outlier_indices].clone()\n",
        "\n",
        "            m.weight.data = pseudo_quantize_tensor(m.weight.data, n_bit=w_bit, q_group_size=q_group_size)\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 2: Restore the 1% salient weight channels to their original FP16 values\n",
        "            m.weight.data[:, outlier_indices] = outlier\n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "id": "2aad125d",
      "metadata": {
        "id": "2aad125d"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "model perplexity: 17.15\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "del model\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "pseudo_quantize_model_salient_weight_fp16(model, w_bit=3, q_group_size=128, input_feat=input_feat)\n",
        "\n",
        "# Evaluate the model\n",
        "model_perplexity = evaluate(model, tokenizer)\n",
        "model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "y2MnArYw4BtE",
      "metadata": {
        "id": "y2MnArYw4BtE"
      },
      "source": [
        "#### Question 1.2 (15 pts)\n",
        "Let's conduct an ablation experiment: randomly protect 1% of the weight channels, ensuring that their values remain unchanged after quantization, and then observe the perplexity. (**The desired perplexity is over 100**)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "id": "5c32c188",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([ 0.5130,  3.1619, -1.9837, -1.1557, -0.4532, -0.4831,  0.7884, -0.1122,\n",
            "         0.6722, -0.2606, -1.2696,  0.3370,  0.0889,  0.2339,  0.5943,  1.2150,\n",
            "        -0.7380,  1.0870, -1.5264, -0.7932])\n",
            "tensor([False, False, False, False,  True, False, False, False,  True, False,\n",
            "        False, False, False, False,  True, False, False,  True, False,  True])\n"
          ]
        }
      ],
      "source": [
        "x = torch.randn(20, )\n",
        "print(x)\n",
        "y = torch.randperm(x.size(0)) < 5\n",
        "print(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "id": "eZnTvBxw3nrJ",
      "metadata": {
        "id": "eZnTvBxw3nrJ"
      },
      "outputs": [],
      "source": [
        "@torch.no_grad()\n",
        "def pseudo_quantize_model_random_weight_fp16(\n",
        "    model, w_bit, q_group_size, input_feat\n",
        "):\n",
        "    for n, m in model.named_modules():\n",
        "        if isinstance(m, nn.Linear):\n",
        "            importance = sum(input_feat[n]).float()\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 1: Randomly choose 1% of the weight channels\n",
        "            outlier_mask = torch.randperm(importance.size(0)) < int(0.01 * importance.size(0))\n",
        "            assert outlier_mask.dim() == 1\n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################\n",
        "\n",
        "            # Back up the values of the selected weight channels\n",
        "            outlier = m.weight.data[:, outlier_mask].clone()\n",
        "\n",
        "            m.weight.data = pseudo_quantize_tensor(m.weight.data, n_bit=w_bit, q_group_size=q_group_size)\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 2: Restore the 1% selected weight channels to their original FP16 values\n",
        "            m.weight.data[:, outlier_mask] = outlier  \n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "id": "FZpUl8Xo3zII",
      "metadata": {
        "id": "FZpUl8Xo3zII"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.41it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "model perplexity: 116.94\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "del model\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "pseudo_quantize_model_random_weight_fp16(model, w_bit=3, q_group_size=128, input_feat=input_feat)\n",
        "\n",
        "# Evaluate the model\n",
        "model_perplexity = evaluate(model, tokenizer)\n",
        "model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "w5skvspRDH18",
      "metadata": {
        "id": "w5skvspRDH18"
      },
      "source": [
        "#### Question 1.3 (15 pts)\n",
        "Please provide a possible explanation for why the salient weight channels are so important.\n",
        "\n",
        "#### Answser 1.3\n",
        "\n",
        "When the salient weight channels remains not randomly, the model perlexity contains as high performance. It seems that the salient weight channels are important for the model to maintain its performance, and those channels have most information than other less important channels.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "x0OVYFc2DbSr",
      "metadata": {
        "id": "x0OVYFc2DbSr"
      },
      "source": [
        "### Question 2 (50 pts)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "h5GGLwczKghz",
      "metadata": {
        "id": "h5GGLwczKghz"
      },
      "source": [
        "Despite keeping 0.1% of weights in FP16 can improve the quantized performance\n",
        "without a noticeable increase in model size (measured in total bits), such a mixed-precision data type will make the system implementation difficult. We need to come up with a method to protect the important weights without actually keeping them as FP16."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "srM0CaQw3xyc",
      "metadata": {
        "id": "srM0CaQw3xyc"
      },
      "source": [
        "According to the methodology of AWQ, simply scaling up the salient weight channels can protect them. The principle is as follows:\n",
        "\n",
        "- Consider a linear layer channel $\\mathbf{y} = \\mathbf{w}x$ (from $\\mathbf{W}x$). We care about the quantization error from $Q(\\mathbf{w})x$.\n",
        "\n",
        "- $Err(Q(\\mathbf{w}) x) = Δ\\cdot RoundErr(\\frac{\\mathbf{w}}{Δ})\\cdot x$, $Δ = \\frac{\\max(|w|)}{2^{N - 1}}$.\n",
        "- The scaled version is $Err(Q(\\mathbf{w} \\cdot s)(\\frac{x}{s})) = Δ\\cdot RoundErr(\\frac{\\mathbf{w}}{Δ})\\cdot x\\cdot \\mathbf{\\frac{1}{s}}$.\n",
        "- The $RoundErr$ is always ~0.25 (average from 0-0.5).\n",
        "- When the group size is relatively large (e.g., 128), scaling up one channel usually does not increase the maximum value in a group (i.e. $Δ$ remains unchanged).\n",
        "- Thus, $Err(Q(\\mathbf{w} \\cdot s)(\\frac{x}{s})) = Δ\\cdot RoundErr(\\frac{\\mathbf{w}}{Δ})\\cdot x\\cdot \\mathbf{\\frac{1}{s}}$ < $Δ\\cdot RoundErr(\\frac{\\mathbf{w}}{Δ})\\cdot x = Err(Q(\\mathbf{w}) x)$."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ui06UW1kK_Ep",
      "metadata": {
        "id": "ui06UW1kK_Ep"
      },
      "source": [
        "Taking the following figure as an example, if we assume 3-bit int quantization, then the quantization error caused by the value in the last column of the second row of $W(+1.4)$ should be $Err(Q(\\mathbf{w}) x) = Δ\\cdot RoundErr(\\frac{\\mathbf{w}}{Δ})\\cdot x$ = $\\frac{4}{2^{3 - 1}} * |1.4 - 1.0| * (2 + 2 + 2) = 2.4$.\n",
        "\n",
        "If the second channel is scaled up by a factor of $2$, the resulting quantization error would reduce to $\\frac{4}{2^{3 - 1}} * |2.8 - 3.0| * (2/2 + 2/2 + 2/2) = 0.6$."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "oXb_q3e08jKG",
      "metadata": {
        "id": "oXb_q3e08jKG"
      },
      "source": [
        "![scaleup.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "qLOfsUrW8xrv",
      "metadata": {
        "id": "qLOfsUrW8xrv"
      },
      "source": [
        "#### Question 2.1 (20 pts)\n",
        "Please write code to scale up the salient weight channels, then quantize it, and finally scale it back down, and observe the changes in perplexity. (**The desired perplexity is 18.93**)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "TdO4KtnsNKf5",
      "metadata": {
        "id": "TdO4KtnsNKf5"
      },
      "outputs": [],
      "source": [
        "@torch.no_grad()\n",
        "def pseudo_quantize_model_weight_scaleup(\n",
        "    model, w_bit, q_group_size, input_feat, scale_factor\n",
        "):\n",
        "    for n, m in model.named_modules():\n",
        "        if isinstance(m, nn.Linear):\n",
        "            importance = sum(input_feat[n]).float()\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 1: Find 1% of the salient weight channels\n",
        "            outlier_mask = torch.topk(importance, int(0.01 * importance.size(0)), largest=True).indices\n",
        "            assert outlier_mask.dim() == 1\n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################\n",
        "\n",
        "            # To simulate applying the scale factor, we can simply multiply it before quantization, and then divide by the scale factor after quantization.\n",
        "            # Scale up the values of the salient weight channels\n",
        "            m.weight.data[:, outlier_mask] *= scale_factor\n",
        "\n",
        "            m.weight.data = pseudo_quantize_tensor(m.weight.data, n_bit=w_bit, q_group_size=q_group_size)\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 2: Scale back down the values of the salient weight channels\n",
        "            m.weight.data[:, outlier_mask] /= scale_factor\n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "GoTh5CzuPhtV",
      "metadata": {
        "id": "GoTh5CzuPhtV"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "model perplexity: 18.93\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "del model\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "pseudo_quantize_model_weight_scaleup(model, w_bit=3, q_group_size=128, input_feat=input_feat, scale_factor=2)\n",
        "\n",
        "# Evaluate the model\n",
        "model_perplexity = evaluate(model, tokenizer)\n",
        "model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "id": "f67be6ad",
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1\n",
            "\n",
            "model perplexity: 121.90\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2\n",
            "\n",
            "model perplexity: 18.93\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 3\n",
            "\n",
            "model perplexity: 19.25\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 4\n",
            "\n",
            "model perplexity: 21.26\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 5\n",
            "\n",
            "model perplexity: 24.50\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 6\n",
            "\n",
            "model perplexity: 30.36\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 7\n",
            "\n",
            "model perplexity: 47.13\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 8\n",
            "\n",
            "model perplexity: 100.99\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "scale_list = (1, 2, 3, 4, 5, 6, 7, 8)\n",
        "for scale_factor in scale_list:\n",
        "    del model\n",
        "    gc.collect()\n",
        "    torch.cuda.empty_cache()\n",
        "    model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "    pseudo_quantize_model_weight_scaleup(model, w_bit=3, q_group_size=128, input_feat=input_feat, scale_factor=scale_factor)\n",
        "\n",
        "    # Evaluate the model\n",
        "    model_perplexity = evaluate(model, tokenizer)\n",
        "    model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "    print(f\"\\n  Scale factor {scale_factor}\")\n",
        "    print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "    print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "id": "e348308f",
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.0\n",
            "\n",
            "model perplexity: 18.93\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.0999999046325684\n",
            "\n",
            "model perplexity: 18.86\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.200000047683716\n",
            "\n",
            "model perplexity: 19.00\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.299999952316284\n",
            "\n",
            "model perplexity: 18.96\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.4000000953674316\n",
            "\n",
            "model perplexity: 18.97\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.5\n",
            "\n",
            "model perplexity: 19.20\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.5999999046325684\n",
            "\n",
            "model perplexity: 18.91\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.700000047683716\n",
            "\n",
            "model perplexity: 19.03\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.799999952316284\n",
            "\n",
            "model perplexity: 18.90\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.9000000953674316\n",
            "\n",
            "model perplexity: 19.12\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 3.0\n",
            "\n",
            "model perplexity: 19.25\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "scale_list = torch.arange(2, 3.1, 0.1)\n",
        "for scale_factor in scale_list:\n",
        "    del model\n",
        "    gc.collect()\n",
        "    torch.cuda.empty_cache()\n",
        "    model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "    pseudo_quantize_model_weight_scaleup(model, w_bit=3, q_group_size=128, input_feat=input_feat, scale_factor=scale_factor)\n",
        "\n",
        "    # Evaluate the model\n",
        "    model_perplexity = evaluate(model, tokenizer)\n",
        "    model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "    print(f\"\\n  Scale factor {scale_factor}\")\n",
        "    print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "    print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "e2789af9",
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.0\n",
            "\n",
            "model perplexity: 121.90\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.100000023841858\n",
            "\n",
            "model perplexity: 47.12\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.2000000476837158\n",
            "\n",
            "model perplexity: 30.96\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.2999999523162842\n",
            "\n",
            "model perplexity: 25.90\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.399999976158142\n",
            "\n",
            "model perplexity: 21.14\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.5\n",
            "\n",
            "model perplexity: 20.19\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.600000023841858\n",
            "\n",
            "model perplexity: 19.71\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.7000000476837158\n",
            "\n",
            "model perplexity: 19.01\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.7999999523162842\n",
            "\n",
            "model perplexity: 18.97\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 1.899999976158142\n",
            "\n",
            "model perplexity: 18.89\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.39it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Scale factor 2.0\n",
            "\n",
            "model perplexity: 18.93\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "scale_list = torch.arange(1, 2.1, 0.1)\n",
        "for scale_factor in scale_list:\n",
        "    del model\n",
        "    gc.collect()\n",
        "    torch.cuda.empty_cache()\n",
        "    model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "    pseudo_quantize_model_weight_scaleup(model, w_bit=3, q_group_size=128, input_feat=input_feat, scale_factor=scale_factor)\n",
        "\n",
        "    # Evaluate the model\n",
        "    model_perplexity = evaluate(model, tokenizer)\n",
        "    model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "    print(f\"\\n  Scale factor {scale_factor}\")\n",
        "    print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "    print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "kDIYt2xJEt84",
      "metadata": {
        "id": "kDIYt2xJEt84"
      },
      "source": [
        "#### Question 2.2 (15 pts)\n",
        "Please try different scale factors (e.g. 1, 2, 3, and 4) in the code and observe the changes in perplexity.\n",
        "\n",
        "Did you observe the perplexity first decreasing and then increasing? Please explain why this would happen based on the principle mentioned above.\n",
        "\n",
        "#### Answer 2.2\n",
        "############### YOUR ANSWER STARTS HERE #################\n",
        "\n",
        "From Scale 2, this perplexities are gradually increasing. At Scale 8, it reach out over the perplexity 100.\n",
        "\n",
        "From Scale 2 to 3, those perplexities are also gradually increasing.\n",
        "\n",
        "From Scale 1 to 2, those perplexities are also gradually decreasing and it reach out saturation at Scale 1.8\n",
        "\n",
        "############### YOUR ANSWER ENDS HERE #################"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ueFx8RCHF2zu",
      "metadata": {
        "id": "ueFx8RCHF2zu"
      },
      "source": [
        "### Question 2.3 (15 pts)\n",
        "Due to the instability of fine-tuning, it would be a better choice to find the optimal $s$ within a predefined search space. We can find the optimal scale in the search space to protect the salient weights while also considering other values. In practice, it can be observed that considering just the activations is sufficient to yield good results. Please add the code for search and run it to observe the perplexity. (**The desired perplexity is 17.92**)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bA4b4L2OL05N",
      "metadata": {
        "id": "bA4b4L2OL05N"
      },
      "source": [
        "$$\n",
        "𝐋(\\mathbf{s})=\\lVert Q(\\mathbf{W}\\cdot \\mathbf{s})  (\\mathbf{s^{-1}} \\cdot \\mathbf{X}) - \\mathbf{W}\\mathbf{X}  \\rVert,  \\quad\\mathbf{s}= \\mathbf{s_X}^{\\alpha}\n",
        "$$\n",
        "$$\n",
        "\\mathbf{s}^* = \\text{argmin}_{\\mathbf{s}} 𝐋(\\mathbf{s}),\\quad \\alpha^*=\\text{argmin}_{\\alpha} 𝐋(\\mathbf{s_X}^{\\alpha})\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "id": "ff_sv6k0R2Eb",
      "metadata": {
        "id": "ff_sv6k0R2Eb"
      },
      "outputs": [],
      "source": [
        "@torch.no_grad()\n",
        "def scale_ln_fcs(ln, fcs, scales):\n",
        "    if not isinstance(fcs, list):\n",
        "        fcs = [fcs]\n",
        "\n",
        "    scales = scales.to(ln.weight.device)\n",
        "\n",
        "    ln.weight.div_(scales)\n",
        "    if hasattr(ln, 'bias') and ln.bias is not None:\n",
        "        ln.bias.div_(scales)\n",
        "\n",
        "    for fc in fcs:\n",
        "        fc.weight.mul_(scales.view(1, -1))\n",
        "\n",
        "    for p in ln.parameters():\n",
        "        assert torch.isnan(p).sum() == 0\n",
        "    for fc in fcs:\n",
        "        for p in fc.parameters():\n",
        "            assert torch.isnan(p).sum() == 0\n",
        "\n",
        "\n",
        "@torch.no_grad()\n",
        "def scale_fc_fc(fc1, fc2, scales):\n",
        "    assert isinstance(fc1, nn.Linear)\n",
        "    assert isinstance(fc2, nn.Linear)\n",
        "\n",
        "    scales = scales.to(fc1.weight.device)\n",
        "\n",
        "    # fc1.weight.div_(scales.view(-1, 1))\n",
        "    fc1.weight[-scales.size(0):].div_(scales.view(-1, 1))\n",
        "    if fc1.bias is not None:\n",
        "        fc1.bias.div_(scales.view(-1))\n",
        "\n",
        "    fc2.weight.mul_(scales.view(1, -1))\n",
        "\n",
        "    for p in fc1.parameters():\n",
        "        assert torch.isnan(p).sum() == 0\n",
        "    for p in fc2.parameters():\n",
        "        assert torch.isnan(p).sum() == 0\n",
        "\n",
        "@torch.no_grad()\n",
        "def auto_scale_block(module, name, w_bit,\n",
        "                     q_group_size,\n",
        "                     input_feat):\n",
        "\n",
        "    # find the best scale ratio\n",
        "    def _search_module_scale(block, linears2scale: list, x, kwargs={}):\n",
        "\n",
        "        x = x.to(next(block.parameters()).device)\n",
        "        with torch.no_grad():\n",
        "            org_out = block(x, **kwargs)\n",
        "            if isinstance(org_out, tuple):\n",
        "                org_out = org_out[0]\n",
        "\n",
        "        s_x = x.view(-1, x.shape[-1]).abs().mean(0)\n",
        "\n",
        "        ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "        # Step 1: Initialize the best_error, best_ratio and best_scales\n",
        "        best_error = float('inf')\n",
        "        best_ratio = -1\n",
        "        best_scales = None\n",
        "\n",
        "        ############### YOUR CODE ENDS HERE #################\n",
        "\n",
        "        n_grid = 20\n",
        "        history = []\n",
        "\n",
        "        org_sd = {k: v.cpu() for k, v in block.state_dict().items()}\n",
        "        for ratio in range(n_grid):\n",
        "            # ratio is the \\alpha in the formula\n",
        "            ratio = ratio * 1 / n_grid\n",
        "\n",
        "            ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "            # Step 2: Calculate the scales by the formula: scales = s_x^ratio\n",
        "            scales = torch.clamp(s_x, 1e-5).pow(ratio)\n",
        "            assert scales.shape == s_x.shape\n",
        "\n",
        "            ############### YOUR CODE ENDS HERE #################\n",
        "\n",
        "            scales = scales / (scales.max() * scales.min()).sqrt().view(1, -1)\n",
        "\n",
        "            for fc in linears2scale:\n",
        "\n",
        "                scales = scales.to(fc.weight.device)\n",
        "\n",
        "                # Scale up the values of the weight channels\n",
        "                fc.weight.mul_(scales)\n",
        "\n",
        "                fc.weight.data = pseudo_quantize_tensor(fc.weight.data, w_bit, q_group_size)\n",
        "\n",
        "                ############### YOUR CODE STARTS HERE ###############\n",
        "\n",
        "                # Step 3: Scale back down the values of the weight channels\n",
        "                fc.weight.div_(scales)\n",
        "\n",
        "                ############### YOUR CODE ENDS HERE #################\n",
        "\n",
        "            out = block(x, **kwargs)\n",
        "            if isinstance(out, tuple):\n",
        "                out = out[0]\n",
        "\n",
        "            loss = (org_out - out).float().pow(2).mean().item()  # float prevents overflow\n",
        "            history.append(loss)\n",
        "            is_best = loss < best_error\n",
        "            if is_best:\n",
        "                best_error = loss\n",
        "                best_ratio = ratio\n",
        "                best_scales = scales\n",
        "            block.load_state_dict(org_sd)\n",
        "\n",
        "        if best_ratio == -1:\n",
        "            print(history)\n",
        "            raise Exception\n",
        "\n",
        "        best_scales = best_scales.view(-1)\n",
        "\n",
        "        assert torch.isnan(best_scales).sum() == 0, best_scales\n",
        "        return best_scales.detach()\n",
        "\n",
        "    # attention input\n",
        "    inp = input_feat[name + '.self_attn.out_proj']\n",
        "    inp = torch.cat([x.unsqueeze(0) for x in inp], dim=0).unsqueeze(0)\n",
        "    qkv = [module.self_attn.q_proj, module.self_attn.k_proj, module.self_attn.v_proj]\n",
        "    final_scales = _search_module_scale(module.self_attn, qkv, inp)\n",
        "    scale_ln_fcs(module.self_attn_layer_norm, qkv, final_scales)\n",
        "\n",
        "    # attn out\n",
        "    inp = input_feat[name + '.self_attn.out_proj']\n",
        "    inp = torch.cat([x.unsqueeze(0) for x in inp], dim=0)\n",
        "    final_scales = _search_module_scale(module.self_attn.out_proj, [module.self_attn.out_proj], inp)\n",
        "    scale_fc_fc(module.self_attn.v_proj, module.self_attn.out_proj, final_scales)\n",
        "\n",
        "    # fc1\n",
        "    inp = input_feat[name + '.fc1']\n",
        "    inp = torch.cat([x.unsqueeze(0) for x in inp], dim=0)\n",
        "    final_scales = _search_module_scale(module.fc1, [module.fc1], inp)\n",
        "    scale_ln_fcs(module.final_layer_norm, module.fc1, final_scales)\n",
        "\n",
        "    # fc2\n",
        "    inp = input_feat[name + '.fc2']\n",
        "    inp = torch.cat([x.unsqueeze(0) for x in inp], dim=0)\n",
        "    final_scales = _search_module_scale(module.fc2, [module.fc2], inp)\n",
        "    scale_fc_fc(module.fc1, module.fc2, final_scales)\n",
        "\n",
        "@torch.no_grad()\n",
        "def pseudo_quantize_model_weight_auto_scale(\n",
        "    model, w_bit, q_group_size, input_feat\n",
        "):\n",
        "    from transformers.models.opt.modeling_opt import OPTDecoderLayer\n",
        "\n",
        "    for name, module in model.named_modules():\n",
        "        if isinstance(module, OPTDecoderLayer):\n",
        "            auto_scale_block(module, name, w_bit, q_group_size, input_feat)\n",
        "\n",
        "    for n, m in model.named_modules():\n",
        "        if isinstance(m, nn.Linear):\n",
        "            m.weight.data = pseudo_quantize_tensor(m.weight.data, n_bit=w_bit, q_group_size=q_group_size)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "id": "cXuQUykZMdKa",
      "metadata": {
        "id": "cXuQUykZMdKa"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "evaluating...: 100%|██████████| 40/40 [00:16<00:00,  2.40it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "model perplexity: 17.93\n",
            "model size: 495.06 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "del model\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")\n",
        "pseudo_quantize_model_weight_auto_scale(model, w_bit=3, q_group_size=128, input_feat=input_feat)\n",
        "\n",
        "# Evaluate the model\n",
        "model_perplexity = evaluate(model, tokenizer)\n",
        "model_size = get_model_size(model, data_width=3, group_size=128)\n",
        "print(f\"\\nmodel perplexity: {model_perplexity:.2f}\")\n",
        "print(f\"model size: {model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "MIZG376WRyzs",
      "metadata": {
        "id": "MIZG376WRyzs"
      },
      "source": [
        "## Bonus point\n",
        "Any optimization techniques without mixed precision on your mind? Try to implement them to improve the perplexity further! If you can further improve the perplexity to $x$, you can get $\\max(0, (17.92 - x) \\times 10)$ bonus points here!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "AjMKgVqq5BFG",
      "metadata": {
        "id": "AjMKgVqq5BFG"
      },
      "source": [
        "In conclusion, we can significantly reduce perplexity without using mixed-precision. Through an efficient kernel implementation, the 4-bit model can achieve decent acceleration for inference. Through learning about TinyChatEngine in the next section, we can run a LLaMA-7B model on our own laptops like the demo presented in the introduction."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "machine_shape": "hm",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.18"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}