07_model_optimization_quantization.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Quantization, Making Models Smaller and Inference Faster"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Quantization is a technique used in the optimization of large language models (LLMs). It reduces the precision of the model's parameters, effectively shrinking its size and computational requirements, while aiming to maintain its performance. The main approaches to quantization are:\n",
        "\n",
        "- **Post-Training Static Quantization (PTQ Static)**: Converts at least model weights to a lower precision (e.g., from 32-bit floating-point to 8-bit integer) before inference. Converting also activations requires a calibration set to determine the optimal quantization parameters: scale and zero-point.\n",
        "\n",
        "- **Post-Training Dynamic Quantization (PTQ Dynamic)**:  Quantizes typically the weights of linear layers in advance but activations are dynamically quantized during inference. Unlike static quantization, this method doesn't require a separate calibration step, making it more flexible in deployment. Although it's slightly slower than static quantization (the activations are read and written to memory in floating point format), it often preserves more of the model's original accuracy.\n",
        "\n",
        "- **Quantization-Aware Training (QAT)**: Applies additional training to simulate the effects of quantization by rounding float32 values. This allows the model to learn (update the model parameters) to minimize the final loss when applying quantization. As a result, it generally achieves the best balance of model size reduction and accuracy preservation. However, it comes with the drawback of requiring a complete retraining of the model (end-to-end forward/backward propagation)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The intuition behind Quantization is that we can discretize floating-point values by mapping their range [`f_max`, `f_min`] into a smaller range of fixed-point numbers [`q_max`, `q_min`], and linearly distributing all values between these ranges. In practice, this typically reduces the precision of a 32-bit floating-point to lower bit widths like 8-bits (scalar quantization) or 1-bit values (binary quantization):"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<p align=\"center\">\n",
        "  <img src=\"./static/model_quantization.png\">\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In this notebook, we introduce how quantization works specifically for LLMs, demonstrating its practical implementation (PTQ Dynamic) and benchmarking in terms of model size, inference latency, and accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "%pip install transformers datasets evaluate --quiet | tail -n 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 1. Load BERT Transformer Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We use a BERT-base model that has been fine-tuned for intent classification using the [clinc dataset](https://huggingface.co/datasets/clinc/clinc_oos):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "-PC1iVAfy-t2"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/python/3.10.13/lib/python3.10/site-packages/transformers/tokenization_utils_base.py:1601: FutureWarning: `clean_up_tokenization_spaces` was not set. It will be set to `True` by default. This behavior will be depracted in transformers v4.45, and will be then set to `False` by default. For more details check this issue: https://github.com/huggingface/transformers/issues/31884\n",
            "  warnings.warn(\n"
          ]
        }
      ],
      "source": [
        "from transformers import pipeline\n",
        "\n",
        "bert_ckpt = \"transformersbook/bert-base-uncased-finetuned-clinc\"\n",
        "pipe = pipeline(\"text-classification\", model=bert_ckpt)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mAFufxfwzQOl",
        "outputId": "97884679-49dd-4dc5-c72b-502cdb71be2d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[{'label': 'book_flight', 'score': 0.5934060215950012}]"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "query = \"\"\"I need to book a flight from New York to Tokyo for next month in economy class\"\"\"\n",
        "pipe(query)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 1.1 Model Architecture\n",
        "\n",
        "This BERT-based model is an encoder-only transformer composed of a stack of 12 layers. Note that each layer implements a self-attention mechanism (query, key, value linear transformations):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "BertForSequenceClassification(\n",
              "  (bert): BertModel(\n",
              "    (embeddings): BertEmbeddings(\n",
              "      (word_embeddings): Embedding(30522, 768, padding_idx=0)\n",
              "      (position_embeddings): Embedding(512, 768)\n",
              "      (token_type_embeddings): Embedding(2, 768)\n",
              "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "    )\n",
              "    (encoder): BertEncoder(\n",
              "      (layer): ModuleList(\n",
              "        (0-11): 12 x BertLayer(\n",
              "          (attention): BertAttention(\n",
              "            (self): BertSdpaSelfAttention(\n",
              "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
              "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
              "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
              "              (dropout): Dropout(p=0.1, inplace=False)\n",
              "            )\n",
              "            (output): BertSelfOutput(\n",
              "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
              "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "              (dropout): Dropout(p=0.1, inplace=False)\n",
              "            )\n",
              "          )\n",
              "          (intermediate): BertIntermediate(\n",
              "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
              "            (intermediate_act_fn): GELUActivation()\n",
              "          )\n",
              "          (output): BertOutput(\n",
              "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
              "            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (pooler): BertPooler(\n",
              "      (dense): Linear(in_features=768, out_features=768, bias=True)\n",
              "      (activation): Tanh()\n",
              "    )\n",
              "  )\n",
              "  (dropout): Dropout(p=0.1, inplace=False)\n",
              "  (classifier): Linear(in_features=768, out_features=151, bias=True)\n",
              ")"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model = AutoModelForSequenceClassification.from_pretrained(model_ckpt).to(\"cpu\")\n",
        "model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 1.2 Weight Distribution in Query Attention Layer"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "By plotting the frequency distribution of the weights in an exemplary attention layer, we observe that the values are indeed concentrated around a relatively narrow range [-0.522441, +0.454290]. This means we can effectively map float32 values to 256 int8 buckets without significant loss of information:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "model.bert.encoder.layer[0].attention.self.query.weight:\n",
            "Min: -0.522441, Max: 0.454290\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "def weights_distribution(model, layer_name):\n",
        "    weights = model.bert.encoder.layer[0].attention.self.query.weight\n",
        "    weights = weights.flatten().detach().cpu().numpy()\n",
        "\n",
        "    print(\"model.bert.encoder.layer[0].attention.self.query.weight:\")\n",
        "    print(f\"Min: {weights.min():.6f}, Max: {weights.max():.6f}\")\n",
        "    \n",
        "    plt.figure(figsize=(8, 4))\n",
        "    sns.histplot(weights, kde=True, bins=100)\n",
        "    plt.title(f'Unquantized Weights Distribution in {layer_name}')\n",
        "    plt.xlabel('Weight Value')\n",
        "    plt.ylabel('Frequency')\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "weights_distribution(model, \"bert.encoder.layer[0].attention.query\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1p8BkZYzqk-"
      },
      "source": [
        "### 2. Prepare Performance Benchmark: Size, Latency, and Accuracy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In this section, we'll create a benchmark to evaluate a model across three key metrics: model performance, latency, and size. **Model performance** will be assessed using accuracy. **Latency** will be measured as the average time taken to generate responses. And **Model size** will be quantified in terms of the number of parameters and the disk space required for storage. By combining these metrics, we aim at allowing informed comparisons and trade-off analyses between a baseline model before and after quantization."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "mNCfADkVzgl-"
      },
      "outputs": [],
      "source": [
        "import evaluate\n",
        "import torch\n",
        "import numpy as np\n",
        "\n",
        "from pathlib import Path\n",
        "from time import perf_counter\n",
        "from typing import Dict, Any\n",
        "\n",
        "class PerformanceBenchmark:\n",
        "    def __init__(self, pipeline, dataset, optim_type=\"BERT Baseline\", num_latency_runs=100, accuracy_sample_size=None):\n",
        "        self.pipeline = pipeline\n",
        "        self.dataset = dataset\n",
        "        self.optim_type = optim_type\n",
        "        self.num_latency_runs = num_latency_runs\n",
        "        self.accuracy_sample_size = accuracy_sample_size\n",
        "\n",
        "    def compute_size(self) -> Dict[str, float]:\n",
        "      \"\"\"Compute the size of the model (MB).\"\"\"\n",
        "      tpm_path = Path(\"temp.p\")\n",
        "      torch.save(self.pipeline.model.state_dict(), tpm_path)\n",
        "      size_mb = Path(tpm_path).stat().st_size / (1024 ** 2)\n",
        "      tpm_path.unlink()\n",
        "      return {\"size_mb\": size_mb}\n",
        "\n",
        "    def compute_latency(self) -> Dict[str, float]:\n",
        "      \"\"\"Compute the average latency of the model.\"\"\"\n",
        "      latencies = [self._inference_time() for _ in range(self.num_latency_runs)]\n",
        "      time_avg_ms = 1000 * np.mean(latencies)\n",
        "      time_std_ms = 1000 * np.std(latencies)\n",
        "      return {\"time_avg_ms\": time_avg_ms, \"time_std_ms\": time_std_ms}\n",
        "\n",
        "    def compute_accuracy(self) -> Dict[str, float]:\n",
        "      \"\"\"Compute the accuracy of the model on the dataset.\"\"\"\n",
        "      accuracy_metric = evaluate.load(\"accuracy\")\n",
        "      intents = self.dataset.features[\"intent\"]\n",
        "        \n",
        "      dataset = self.dataset\n",
        "      if self.accuracy_sample_size:\n",
        "          dataset = self.dataset.select(range(self.accuracy_sample_size))\n",
        "\n",
        "      x = [_[\"text\"] for _ in dataset]\n",
        "      y = [_[\"intent\"] for _ in dataset]\n",
        "\n",
        "      preds = [intents.str2int(self._predict(text)) for text in x]\n",
        "      return accuracy_metric.compute(predictions=preds, references=y)\n",
        "    \n",
        "    def run_benchmark(self):\n",
        "      metrics = {self.optim_type: {}}\n",
        "      metrics[self.optim_type].update(self.compute_size())\n",
        "      metrics[self.optim_type].update(self.compute_latency())\n",
        "      metrics[self.optim_type].update(self.compute_accuracy())\n",
        "      self._print(metrics[self.optim_type])\n",
        "      return metrics\n",
        "\n",
        "    def _inference_time(self) -> float:\n",
        "      t1 = perf_counter()\n",
        "      _ = self.pipeline(self.dataset[42][\"text\"]) # we use always the same sample\n",
        "      t2 = perf_counter()\n",
        "      return t2 - t1\n",
        "\n",
        "    def _predict(self, text: str) -> str:\n",
        "      return self.pipeline(text)[0][\"label\"]\n",
        "    \n",
        "    @staticmethod\n",
        "    def _print(metrics: Dict[str, Any]) -> None:\n",
        "      print(f\"Model size (MB): {metrics['size_mb']:.2f}\")\n",
        "      print(f\"Average latency (ms): {metrics['time_avg_ms']:.2f} ± {metrics['time_std_ms']:.2f}\")\n",
        "      print(f\"Accuracy on test set: {metrics['accuracy']:.3f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3. Evaluate Model before Quantization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We use the [clinc_oos](https://huggingface.co/datasets/clinc/clinc_oos) dataset:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sWG1n0Lh1be9",
        "outputId": "98cef2fb-da37-4b3c-f926-091d7bcace0a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'text': 'transfer $100 from my checking to saving account', 'intent': 133}"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from datasets import load_dataset\n",
        "\n",
        "clinc = load_dataset(\"clinc_oos\", \"plus\")\n",
        "sample = clinc[\"test\"][42]\n",
        "sample"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "And run the benchmark:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WvYlkMnt6P0w",
        "outputId": "a0ae7d1d-cb2b-4846-a178-a6422c811e11"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model size (MB): 418.15\n",
            "Average latency (ms): 64.76 ± 5.02\n",
            "Accuracy on test set: 0.867\n"
          ]
        }
      ],
      "source": [
        "pb = PerformanceBenchmark(pipe, clinc[\"test\"])\n",
        "perf_metrics = pb.run_benchmark()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jvR9jp73UOH5"
      },
      "source": [
        "### 4. Dynamic Quantization w/ PyTorch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We call `torch.quantization.quantize_dynamic` on the model to apply dynamic quantization on this BERT model. Specifically, we specify that we want the `torch.nn.Linear` modules in our model to be quantized; and the weights to be converted to `quantized int8` values."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4US3qY6ClCdF"
      },
      "outputs": [],
      "source": [
        "from transformers import AutoModelForSequenceClassification\n",
        "from torch.quantization import quantize_dynamic\n",
        "\n",
        "model_ckpt = \"transformersbook/bert-base-uncased-finetuned-clinc\"\n",
        "model = AutoModelForSequenceClassification.from_pretrained(model_ckpt).to(\"cpu\")\n",
        "\n",
        "model_ptq_dynamic = quantize_dynamic(\n",
        "    model, qconfig_spec={torch.nn.Linear}, dtype=torch.qint8\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 4.1 Quantization Analysis"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "##### 4.1.1 Architecture"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The linear layers are now `DynamicQuantized` layers, whereas the embedding and normalization layers are as expected not included in the quantization:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "BertForSequenceClassification(\n",
              "  (bert): BertModel(\n",
              "    (embeddings): BertEmbeddings(\n",
              "      (word_embeddings): Embedding(30522, 768, padding_idx=0)\n",
              "      (position_embeddings): Embedding(512, 768)\n",
              "      (token_type_embeddings): Embedding(2, 768)\n",
              "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "    )\n",
              "    (encoder): BertEncoder(\n",
              "      (layer): ModuleList(\n",
              "        (0-11): 12 x BertLayer(\n",
              "          (attention): BertAttention(\n",
              "            (self): BertSdpaSelfAttention(\n",
              "              (query): DynamicQuantizedLinear(in_features=768, out_features=768, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "              (key): DynamicQuantizedLinear(in_features=768, out_features=768, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "              (value): DynamicQuantizedLinear(in_features=768, out_features=768, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "              (dropout): Dropout(p=0.1, inplace=False)\n",
              "            )\n",
              "            (output): BertSelfOutput(\n",
              "              (dense): DynamicQuantizedLinear(in_features=768, out_features=768, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "              (dropout): Dropout(p=0.1, inplace=False)\n",
              "            )\n",
              "          )\n",
              "          (intermediate): BertIntermediate(\n",
              "            (dense): DynamicQuantizedLinear(in_features=768, out_features=3072, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "            (intermediate_act_fn): GELUActivation()\n",
              "          )\n",
              "          (output): BertOutput(\n",
              "            (dense): DynamicQuantizedLinear(in_features=3072, out_features=768, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (pooler): BertPooler(\n",
              "      (dense): DynamicQuantizedLinear(in_features=768, out_features=768, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              "      (activation): Tanh()\n",
              "    )\n",
              "  )\n",
              "  (dropout): Dropout(p=0.1, inplace=False)\n",
              "  (classifier): DynamicQuantizedLinear(in_features=768, out_features=151, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
              ")"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_ptq_dynamic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The tensor is now quantized in `qint8` format using the `per_tensor_affine` schema (see the scale factor and zero point). The weight values we can see are dequantized values, namely the floating-point equivalents to `int8`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[-0.0164,  0.0246, -0.0246,  ...,  0.0164,  0.0779,  0.0574],\n",
              "        [-0.0328,  0.0328, -0.0410,  ..., -0.0533,  0.1393,  0.0082],\n",
              "        [ 0.0082,  0.0328,  0.0123,  ..., -0.0287,  0.0246, -0.0451],\n",
              "        ...,\n",
              "        [-0.0082,  0.0492,  0.0533,  ...,  0.0287,  0.0533, -0.0533],\n",
              "        [-0.0205,  0.0942,  0.0615,  ..., -0.1024,  0.0615,  0.0451],\n",
              "        [ 0.0041, -0.0983,  0.0082,  ..., -0.0164, -0.0492, -0.0082]],\n",
              "       size=(768, 768), dtype=torch.qint8,\n",
              "       quantization_scheme=torch.per_tensor_affine, scale=0.004097579047083855,\n",
              "       zero_point=0)"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qweights = model_ptq_dynamic.bert.encoder.layer[0].attention.self.query.weight()\n",
        "qweights"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Note the quantization error when comparing those values with the original model weights:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Parameter containing:\n",
              "tensor([[-0.0169,  0.0253, -0.0261,  ...,  0.0155,  0.0769,  0.0554],\n",
              "        [-0.0324,  0.0346, -0.0428,  ..., -0.0525,  0.1400,  0.0072],\n",
              "        [ 0.0095,  0.0334,  0.0114,  ..., -0.0281,  0.0248, -0.0457],\n",
              "        ...,\n",
              "        [-0.0079,  0.0508,  0.0552,  ...,  0.0296,  0.0543, -0.0531],\n",
              "        [-0.0193,  0.0950,  0.0622,  ..., -0.1041,  0.0602,  0.0463],\n",
              "        [ 0.0021, -0.0966,  0.0081,  ..., -0.0180, -0.0508, -0.0075]],\n",
              "       requires_grad=True)"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.bert.encoder.layer[0].attention.self.query.weight"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also get the actual quantized integer values as stored in 8-bit integer format:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[ -4,   6,  -6,  ...,   4,  19,  14],\n",
              "        [ -8,   8, -10,  ..., -13,  34,   2],\n",
              "        [  2,   8,   3,  ...,  -7,   6, -11],\n",
              "        ...,\n",
              "        [ -2,  12,  13,  ...,   7,  13, -13],\n",
              "        [ -5,  23,  15,  ..., -25,  15,  11],\n",
              "        [  1, -24,   2,  ...,  -4, -12,  -2]], dtype=torch.int8)"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qweights.int_repr()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Furthermore, by applying `(quantized_value - zero_point) * scale`, we can manually dequantize this internal `int8` representation, the values correspond as expected to those provided by PyTorch:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[-0.0164,  0.0246, -0.0246,  ...,  0.0164,  0.0779,  0.0574],\n",
              "        [-0.0328,  0.0328, -0.0410,  ..., -0.0533,  0.1393,  0.0082],\n",
              "        [ 0.0082,  0.0328,  0.0123,  ..., -0.0287,  0.0246, -0.0451],\n",
              "        ...,\n",
              "        [-0.0082,  0.0492,  0.0533,  ...,  0.0287,  0.0533, -0.0533],\n",
              "        [-0.0205,  0.0942,  0.0615,  ..., -0.1024,  0.0615,  0.0451],\n",
              "        [ 0.0041, -0.0983,  0.0082,  ..., -0.0164, -0.0492, -0.0082]])"
            ]
          },
          "execution_count": 38,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(qweights.int_repr().float() - qweights.q_zero_point()) * qweights.q_scale()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "##### 4.1.2 Weights Distribution"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The weights are correctly distributed in `int8` buckets:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "bert.encoder.layer[0].attention.self.query:\n",
            "Scale: 0.004098, Zero Point: 0\n",
            "Min: -128, Max: 111\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import torch\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "def weight_distribution(model, layer_name):\n",
        "    weight = model.bert.encoder.layer[0].attention.self.query.weight()\n",
        "\n",
        "    scale = weight.q_scale()\n",
        "    zero_point = weight.q_zero_point()\n",
        "\n",
        "    int_repr = weight.int_repr()\n",
        "\n",
        "    min_val = int_repr.min().item()\n",
        "    max_val = int_repr.max().item()\n",
        "\n",
        "    print(f\"{layer_name}:\")\n",
        "    print(f\"Scale: {scale:.6f}, Zero Point: {zero_point}\")\n",
        "    print(f\"Min: {min_val}, Max: {max_val}\")\n",
        "\n",
        "    plt.figure(figsize=(8, 4))\n",
        "    sns.histplot(int_repr.flatten().numpy(), bins=256, kde=True)\n",
        "    plt.title(f'Quantized Weights (int8) - {layer_name}')\n",
        "    plt.xlabel('Quantized Weights (int8)')\n",
        "    plt.ylabel('Frequency')\n",
        "    plt.show()\n",
        "\n",
        "weight_distribution(model_ptq_dynamic, \"bert.encoder.layer[0].attention.query\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 4.2 Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dyVe1SKyVkQo"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/python/3.10.13/lib/python3.10/site-packages/transformers/tokenization_utils_base.py:1601: FutureWarning: `clean_up_tokenization_spaces` was not set. It will be set to `True` by default. This behavior will be depracted in transformers v4.45, and will be then set to `False` by default. For more details check this issue: https://github.com/huggingface/transformers/issues/31884\n",
            "  warnings.warn(\n"
          ]
        }
      ],
      "source": [
        "from transformers import AutoTokenizer\n",
        "\n",
        "tokenizer = AutoTokenizer.from_pretrained(model_ckpt)\n",
        "pipe = pipeline(\"text-classification\", model=model_dynamic_quantized, tokenizer=tokenizer)\n",
        "\n",
        "optim_type = \"Dynamic Quantization\"\n",
        "pb = PerformanceBenchmark(pipe, clinc[\"test\"], optim_type=optim_type)\n",
        "perf_metrics.update(pb.run_benchmark())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 6. Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "def plot_metrics(perf_metrics, y_min=80, y_max=90, x_padding=20):\n",
        "    df = pd.DataFrame.from_dict(perf_metrics, orient='index')\n",
        "    \n",
        "    fig, ax = plt.subplots()\n",
        "    sizes = np.sqrt(df[\"size_mb\"]) * 25  # Scale sizes for better visibility\n",
        "    \n",
        "    scatter = ax.scatter(df[\"time_avg_ms\"], df[\"accuracy\"] * 100,\n",
        "                         s=sizes, alpha=0.5, c=range(len(df)), cmap='Set3', edgecolors='black', linewidth=0.5)\n",
        "    \n",
        "    # Add labels\n",
        "    for idx, row in df.iterrows():\n",
        "        ax.annotate(idx, (row[\"time_avg_ms\"], row[\"accuracy\"] * 100),\n",
        "                    xytext=(10, 10), textcoords='offset points') \n",
        "    \n",
        "    ax.set_ylim(y_min, y_max)\n",
        "    ax.set_xlim(1, df[\"time_avg_ms\"].max() + x_padding)\n",
        "    ax.set_ylabel(\"Accuracy (%)\")\n",
        "    ax.set_xlabel(\"Average latency (ms)\")\n",
        "    ax.set_title(\"BERT (Quantized) Models: Performance Metrics\")\n",
        "    \n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "plot_metrics(perf_metrics)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'BERT Baseline': {'size_mb': 418.14690494537354,\n",
              "  'time_avg_ms': np.float64(66.56128514999921),\n",
              "  'time_std_ms': np.float64(7.1043671034855205),\n",
              "  'accuracy': 0.8672727272727273},\n",
              " 'Dynamic Quantization': {'size_mb': 173.18227100372314,\n",
              "  'time_avg_ms': np.float64(22.055510930003948),\n",
              "  'time_std_ms': np.float64(5.500500611905444),\n",
              "  'accuracy': 0.8638181818181818}}"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "perf_metrics"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyPChD2YpMJax4NCMvy4qK8J",
      "include_colab_link": true,
      "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.10.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}