final_Lab2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pmi4V4VaYR6i"
   },
   "source": [
    "# **MIT 6.5940 EfficientML.ai Fall 2023 Lab 2: Quantization**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_PC9ifUhHwRT"
   },
   "source": [
    "This colab notebook provides code and a framework for Lab 2 quantization. You can work out your solutions here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A-antxp8SSyb"
   },
   "source": [
    "Please fill out this [feedback form](https://forms.gle/ZeCH5anNPrkd5wpp7) when you finished this lab. We would love to hear your thoughts or feedback on how we can improve this lab!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vhVOMmbAaHRd"
   },
   "source": [
    "## Goals\n",
    "\n",
    "In this assignment, you will practice quantizing a classical neural network model to reduce both model size and latency. The goals of this assignment are as follows:\n",
    "\n",
    "- Understand the basic concept of **quantization**\n",
    "- Implement and apply **k-means quantization**\n",
    "- Implement and apply **quantization-aware training** for k-means quantization\n",
    "- Implement and apply **linear quantization**\n",
    "- Implement and apply **integer-only inference** for linear quantization\n",
    "- Get a basic understanding of performance improvement (such as speedup) from quantization\n",
    "- Understand the differences and tradeoffs between these quantization approaches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W6HPdGZ7aHZo"
   },
   "source": [
    "## Contents\n",
    "\n",
    "\n",
    "There are 2 main sections: ***K-Means Quantization*** and ***Linear Quantization***.\n",
    "\n",
    "There are ***10*** questions in total:\n",
    "- For *K-Means Quantization*, there are ***3*** questions (Question 1-3).\n",
    "- For *Linear Quantization*, there are ***6*** questions (Question 4-9).\n",
    "- Question 10 compares k-means quantization and linear quantization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2tFjnZZVlIFL"
   },
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Bz16rxaSH_7f"
   },
   "source": [
    "First, install the required packages and download the datasets and pretrained model. Here we use CIFAR10 dataset and VGG network which is the same as what we used in the Lab 0 tutorial.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nyngBRTXQG2n",
    "outputId": "b3febb13-0e6d-4fad-9815-b2e91985e2ad"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Installing torchprofile...\n",
      "Looking in indexes: http://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: torchprofile in /root/miniconda3/lib/python3.8/site-packages (0.0.4)\n",
      "Requirement already satisfied: numpy>=1.14 in /root/miniconda3/lib/python3.8/site-packages (from torchprofile) (1.24.2)\n",
      "Requirement already satisfied: torchvision>=0.4 in /root/miniconda3/lib/python3.8/site-packages (from torchprofile) (0.15.1+cu118)\n",
      "Requirement already satisfied: torch>=1.4 in /root/miniconda3/lib/python3.8/site-packages (from torchprofile) (2.0.0+cu118)\n",
      "Requirement already satisfied: typing-extensions in /root/miniconda3/lib/python3.8/site-packages (from torch>=1.4->torchprofile) (4.5.0)\n",
      "Requirement already satisfied: networkx in /root/miniconda3/lib/python3.8/site-packages (from torch>=1.4->torchprofile) (3.0)\n",
      "Requirement already satisfied: sympy in /root/miniconda3/lib/python3.8/site-packages (from torch>=1.4->torchprofile) (1.11.1)\n",
      "Requirement already satisfied: filelock in /root/miniconda3/lib/python3.8/site-packages (from torch>=1.4->torchprofile) (3.10.0)\n",
      "Requirement already satisfied: jinja2 in /root/miniconda3/lib/python3.8/site-packages (from torch>=1.4->torchprofile) (3.1.2)\n",
      "Requirement already satisfied: triton==2.0.0 in /root/miniconda3/lib/python3.8/site-packages (from torch>=1.4->torchprofile) (2.0.0)\n",
      "Requirement already satisfied: lit in /root/miniconda3/lib/python3.8/site-packages (from triton==2.0.0->torch>=1.4->torchprofile) (15.0.7)\n",
      "Requirement already satisfied: cmake in /root/miniconda3/lib/python3.8/site-packages (from triton==2.0.0->torch>=1.4->torchprofile) (3.26.0)\n",
      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /root/miniconda3/lib/python3.8/site-packages (from torchvision>=0.4->torchprofile) (9.4.0)\n",
      "Requirement already satisfied: requests in /root/miniconda3/lib/python3.8/site-packages (from torchvision>=0.4->torchprofile) (2.28.2)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /root/miniconda3/lib/python3.8/site-packages (from jinja2->torch>=1.4->torchprofile) (2.1.2)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /root/miniconda3/lib/python3.8/site-packages (from requests->torchvision>=0.4->torchprofile) (2.10)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /root/miniconda3/lib/python3.8/site-packages (from requests->torchvision>=0.4->torchprofile) (1.26.6)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /root/miniconda3/lib/python3.8/site-packages (from requests->torchvision>=0.4->torchprofile) (2021.5.30)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /root/miniconda3/lib/python3.8/site-packages (from requests->torchvision>=0.4->torchprofile) (3.1.0)\n",
      "Requirement already satisfied: mpmath>=0.19 in /root/miniconda3/lib/python3.8/site-packages (from sympy->torch>=1.4->torchprofile) (1.3.0)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
      "Installing fast-pytorch-kmeans...\n",
      "Looking in indexes: http://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: fast-pytorch-kmeans in /root/miniconda3/lib/python3.8/site-packages (0.2.0.1)\n",
      "Requirement already satisfied: pynvml in /root/miniconda3/lib/python3.8/site-packages (from fast-pytorch-kmeans) (11.5.0)\n",
      "Requirement already satisfied: numpy in /root/miniconda3/lib/python3.8/site-packages (from fast-pytorch-kmeans) (1.24.2)\n",
      "Requirement already satisfied: torch in /root/miniconda3/lib/python3.8/site-packages (from fast-pytorch-kmeans) (2.0.0+cu118)\n",
      "Requirement already satisfied: typing-extensions in /root/miniconda3/lib/python3.8/site-packages (from torch->fast-pytorch-kmeans) (4.5.0)\n",
      "Requirement already satisfied: triton==2.0.0 in /root/miniconda3/lib/python3.8/site-packages (from torch->fast-pytorch-kmeans) (2.0.0)\n",
      "Requirement already satisfied: filelock in /root/miniconda3/lib/python3.8/site-packages (from torch->fast-pytorch-kmeans) (3.10.0)\n",
      "Requirement already satisfied: jinja2 in /root/miniconda3/lib/python3.8/site-packages (from torch->fast-pytorch-kmeans) (3.1.2)\n",
      "Requirement already satisfied: networkx in /root/miniconda3/lib/python3.8/site-packages (from torch->fast-pytorch-kmeans) (3.0)\n",
      "Requirement already satisfied: sympy in /root/miniconda3/lib/python3.8/site-packages (from torch->fast-pytorch-kmeans) (1.11.1)\n",
      "Requirement already satisfied: lit in /root/miniconda3/lib/python3.8/site-packages (from triton==2.0.0->torch->fast-pytorch-kmeans) (15.0.7)\n",
      "Requirement already satisfied: cmake in /root/miniconda3/lib/python3.8/site-packages (from triton==2.0.0->torch->fast-pytorch-kmeans) (3.26.0)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /root/miniconda3/lib/python3.8/site-packages (from jinja2->torch->fast-pytorch-kmeans) (2.1.2)\n",
      "Requirement already satisfied: mpmath>=0.19 in /root/miniconda3/lib/python3.8/site-packages (from sympy->torch->fast-pytorch-kmeans) (1.3.0)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
      "All required packages have been successfully installed!\n"
     ]
    }
   ],
   "source": [
    "print('Installing torchprofile...')\n",
    "!pip install torchprofile \n",
    "print('Installing fast-pytorch-kmeans...')\n",
    "! pip install fast-pytorch-kmeans\n",
    "print('All required packages have been successfully installed!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 255
    },
    "id": "zDWoVhv_wGmA",
    "outputId": "d6662ba5-388c-40af-f4e9-f28454e49620"
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import math\n",
    "import random\n",
    "from collections import OrderedDict, defaultdict\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.colors import ListedColormap\n",
    "import numpy as np\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.optim import *\n",
    "from torch.optim.lr_scheduler import *\n",
    "from torch.utils.data import DataLoader\n",
    "from torchprofile import profile_macs\n",
    "from torchvision.datasets import *\n",
    "from torchvision.transforms import *\n",
    "\n",
    "from torchprofile import profile_macs\n",
    "\n",
    "assert torch.cuda.is_available(), \\\n",
    "\"The current runtime does not have CUDA support.\" \\\n",
    "\"Please go to menu bar (Runtime - Change runtime type) and select GPU\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nLcJUofTDKud",
    "outputId": "5a0e02bf-708e-4832-d92a-d271f7fea960"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f05e319d110>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "6kpu78GyHGA-"
   },
   "outputs": [],
   "source": [
    "def download_url(url, model_dir='.', overwrite=False):\n",
    "    import os, sys\n",
    "    from urllib.request import urlretrieve\n",
    "    target_dir = url.split('/')[-1]\n",
    "    model_dir = os.path.expanduser(model_dir)\n",
    "    try:\n",
    "        if not os.path.exists(model_dir):\n",
    "            os.makedirs(model_dir)\n",
    "        model_dir = os.path.join(model_dir, target_dir)\n",
    "        cached_file = model_dir\n",
    "        if not os.path.exists(cached_file) or overwrite:\n",
    "            sys.stderr.write('Downloading: \"{}\" to {}\\n'.format(url, cached_file))\n",
    "            urlretrieve(url, cached_file)\n",
    "        return cached_file\n",
    "    except Exception as e:\n",
    "        # remove lock file so download can be executed next time.\n",
    "        os.remove(os.path.join(model_dir, 'download.lock'))\n",
    "        sys.stderr.write('Failed to download from url %s' % url + '\\n' + str(e) + '\\n')\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "qqInscyoifYN"
   },
   "outputs": [],
   "source": [
    "class VGG(nn.Module):\n",
    "  ARCH = [64, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']\n",
    "\n",
    "  def __init__(self) -> None:\n",
    "    super().__init__()\n",
    "\n",
    "    layers = []\n",
    "    counts = defaultdict(int)\n",
    "\n",
    "    def add(name: str, layer: nn.Module) -> None:\n",
    "      layers.append((f\"{name}{counts[name]}\", layer))\n",
    "      counts[name] += 1\n",
    "\n",
    "    in_channels = 3\n",
    "    for x in self.ARCH:\n",
    "      if x != 'M':\n",
    "        # conv-bn-relu\n",
    "        add(\"conv\", nn.Conv2d(in_channels, x, 3, padding=1, bias=False))\n",
    "        add(\"bn\", nn.BatchNorm2d(x))\n",
    "        add(\"relu\", nn.ReLU(True))\n",
    "        in_channels = x\n",
    "      else:\n",
    "        # maxpool\n",
    "        add(\"pool\", nn.MaxPool2d(2))\n",
    "    add(\"avgpool\", nn.AvgPool2d(2))\n",
    "    self.backbone = nn.Sequential(OrderedDict(layers))\n",
    "    self.classifier = nn.Linear(512, 10)\n",
    "\n",
    "  def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "    # backbone: [N, 3, 32, 32] => [N, 512, 2, 2]\n",
    "    x = self.backbone(x)\n",
    "\n",
    "    # avgpool: [N, 512, 2, 2] => [N, 512]\n",
    "    # x = x.mean([2, 3])\n",
    "    x = x.view(x.shape[0], -1)\n",
    "\n",
    "    # classifier: [N, 512] => [N, 10]\n",
    "    x = self.classifier(x)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "WqnPt0LUEaWi"
   },
   "outputs": [],
   "source": [
    "def train(\n",
    "  model: nn.Module,\n",
    "  dataloader: DataLoader,\n",
    "  criterion: nn.Module,\n",
    "  optimizer: Optimizer,\n",
    "  scheduler: LambdaLR,\n",
    "  callbacks = None\n",
    ") -> None:\n",
    "  model.train()\n",
    "\n",
    "  for inputs, targets in tqdm(dataloader, desc='train', leave=False):\n",
    "    # Move the data from CPU to GPU\n",
    "    inputs = inputs.cuda()\n",
    "    targets = targets.cuda()\n",
    "\n",
    "    # Reset the gradients (from the last iteration)\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # Forward inference\n",
    "    outputs = model(inputs)\n",
    "    loss = criterion(outputs, targets)\n",
    "\n",
    "    # Backward propagation\n",
    "    loss.backward()\n",
    "\n",
    "    # Update optimizer and LR scheduler\n",
    "    optimizer.step()\n",
    "    scheduler.step()\n",
    "\n",
    "    if callbacks is not None:\n",
    "        for callback in callbacks:\n",
    "            callback()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "wVA1_oeUEUf6"
   },
   "outputs": [],
   "source": [
    "@torch.inference_mode()\n",
    "def evaluate(\n",
    "  model: nn.Module,\n",
    "  dataloader: DataLoader,\n",
    "  extra_preprocess = None\n",
    ") -> float:\n",
    "  model.eval()\n",
    "\n",
    "  num_samples = 0\n",
    "  num_correct = 0\n",
    "\n",
    "  for inputs, targets in tqdm(dataloader, desc=\"eval\", leave=False):\n",
    "    # Move the data from CPU to GPU\n",
    "    inputs = inputs.cuda()\n",
    "    if extra_preprocess is not None:\n",
    "        for preprocess in extra_preprocess:\n",
    "            inputs = preprocess(inputs)\n",
    "\n",
    "    targets = targets.cuda()\n",
    "\n",
    "    # Inference\n",
    "    outputs = model(inputs)\n",
    "\n",
    "    # Convert logits to class indices\n",
    "    outputs = outputs.argmax(dim=1)\n",
    "\n",
    "    # Update metrics\n",
    "    num_samples += targets.size(0)\n",
    "    num_correct += (outputs == targets).sum()\n",
    "  \n",
    "  return (num_correct / num_samples * 100).item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QBBKNhKNlAwE"
   },
   "source": [
    "Helpler Functions (Flops, Model Size calculation, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "mRdK_ThzlMxL"
   },
   "outputs": [],
   "source": [
    "def get_model_flops(model, inputs):\n",
    "    num_macs = profile_macs(model, inputs)\n",
    "    return num_macs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "cepv4SUalU79"
   },
   "outputs": [],
   "source": [
    "def get_model_size(model: nn.Module, data_width=32):\n",
    "    \"\"\"\n",
    "    calculate the model size in bits\n",
    "    :param data_width: #bits per element\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": "markdown",
   "metadata": {
    "id": "CGhomDjsaDB5"
   },
   "source": [
    "Define misc funcions for verification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "WOJBXVXQeCXF"
   },
   "outputs": [],
   "source": [
    "def test_k_means_quantize(\n",
    "    test_tensor=torch.tensor([\n",
    "        [-0.3747,  0.0874,  0.3200, -0.4868,  0.4404],\n",
    "        [-0.0402,  0.2322, -0.2024, -0.4986,  0.1814],\n",
    "        [ 0.3102, -0.3942, -0.2030,  0.0883, -0.4741],\n",
    "        [-0.1592, -0.0777, -0.3946, -0.2128,  0.2675],\n",
    "        [ 0.0611, -0.1933, -0.4350,  0.2928, -0.1087]]),\n",
    "    bitwidth=2):\n",
    "    def plot_matrix(tensor, ax, title, cmap=ListedColormap(['white'])):\n",
    "        ax.imshow(tensor.cpu().numpy(), vmin=-0.5, vmax=0.5, cmap=cmap)\n",
    "        ax.set_title(title)\n",
    "        ax.set_yticklabels([])\n",
    "        ax.set_xticklabels([])\n",
    "        for i in range(tensor.shape[1]):\n",
    "            for j in range(tensor.shape[0]):\n",
    "                text = ax.text(j, i, f'{tensor[i, j].item():.2f}',\n",
    "                                ha=\"center\", va=\"center\", color=\"k\")\n",
    "\n",
    "    fig, axes = plt.subplots(1,2, figsize=(8, 12))\n",
    "    ax_left, ax_right = axes.ravel()\n",
    "\n",
    "    print(test_tensor)\n",
    "    plot_matrix(test_tensor, ax_left, 'original tensor')\n",
    "\n",
    "    num_unique_values_before_quantization = test_tensor.unique().numel()\n",
    "    k_means_quantize(test_tensor, bitwidth=bitwidth)\n",
    "    num_unique_values_after_quantization = test_tensor.unique().numel()\n",
    "    print('* Test k_means_quantize()')\n",
    "    print(f'    target bitwidth: {bitwidth} bits')\n",
    "    print(f'        num unique values before k-means quantization: {num_unique_values_before_quantization}')\n",
    "    print(f'        num unique values after  k-means quantization: {num_unique_values_after_quantization}')\n",
    "    assert num_unique_values_after_quantization == min((1 << bitwidth), num_unique_values_before_quantization)\n",
    "    print('* Test passed.')\n",
    "\n",
    "    plot_matrix(test_tensor, ax_right, f'{bitwidth}-bit k-means quantized tensor', cmap='tab20c')\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "jI92NMafaCk7"
   },
   "outputs": [],
   "source": [
    "def test_linear_quantize(\n",
    "    test_tensor=torch.tensor([\n",
    "        [ 0.0523,  0.6364, -0.0968, -0.0020,  0.1940],\n",
    "        [ 0.7500,  0.5507,  0.6188, -0.1734,  0.4677],\n",
    "        [-0.0669,  0.3836,  0.4297,  0.6267, -0.0695],\n",
    "        [ 0.1536, -0.0038,  0.6075,  0.6817,  0.0601],\n",
    "        [ 0.6446, -0.2500,  0.5376, -0.2226,  0.2333]]),\n",
    "    quantized_test_tensor=torch.tensor([\n",
    "        [-1,  1, -1, -1,  0],\n",
    "        [ 1,  1,  1, -2,  0],\n",
    "        [-1,  0,  0,  1, -1],\n",
    "        [-1, -1,  1,  1, -1],\n",
    "        [ 1, -2,  1, -2,  0]], dtype=torch.int8),\n",
    "    real_min=-0.25, real_max=0.75, bitwidth=2, scale=1/3, zero_point=-1):\n",
    "    def plot_matrix(tensor, ax, title, vmin=0, vmax=1, cmap=ListedColormap(['white'])):\n",
    "        ax.imshow(tensor.cpu().numpy(), vmin=vmin, vmax=vmax, cmap=cmap)\n",
    "        ax.set_title(title)\n",
    "        ax.set_yticklabels([])\n",
    "        ax.set_xticklabels([])\n",
    "        for i in range(tensor.shape[0]):\n",
    "            for j in range(tensor.shape[1]):\n",
    "                datum = tensor[i, j].item()\n",
    "                if isinstance(datum, float):\n",
    "                    text = ax.text(j, i, f'{datum:.2f}',\n",
    "                                    ha=\"center\", va=\"center\", color=\"k\")\n",
    "                else:\n",
    "                    text = ax.text(j, i, f'{datum}',\n",
    "                                    ha=\"center\", va=\"center\", color=\"k\")\n",
    "    quantized_min, quantized_max = get_quantized_range(bitwidth)\n",
    "    fig, axes = plt.subplots(1,3, figsize=(10, 32))\n",
    "    plot_matrix(test_tensor, axes[0], 'original tensor', vmin=real_min, vmax=real_max)\n",
    "    _quantized_test_tensor = linear_quantize(\n",
    "        test_tensor, bitwidth=bitwidth, scale=scale, zero_point=zero_point)\n",
    "    _reconstructed_test_tensor = scale * (_quantized_test_tensor.float() - zero_point)\n",
    "    print('* Test linear_quantize()')\n",
    "    print(f'    target bitwidth: {bitwidth} bits')\n",
    "    print(f'        scale: {scale}')\n",
    "    print(f'        zero point: {zero_point}')\n",
    "    assert _quantized_test_tensor.equal(quantized_test_tensor)\n",
    "    print('* Test passed.')\n",
    "    plot_matrix(_quantized_test_tensor, axes[1], f'2-bit linear quantized tensor',\n",
    "                vmin=quantized_min, vmax=quantized_max, cmap='tab20c')\n",
    "    plot_matrix(_reconstructed_test_tensor, axes[2], f'reconstructed tensor',\n",
    "                vmin=real_min, vmax=real_max, cmap='tab20c')\n",
    "    fig.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "vK-56lHteduz"
   },
   "outputs": [],
   "source": [
    "def test_quantized_fc(\n",
    "    input=torch.tensor([\n",
    "        [0.6118, 0.7288, 0.8511, 0.2849, 0.8427, 0.7435, 0.4014, 0.2794],\n",
    "        [0.3676, 0.2426, 0.1612, 0.7684, 0.6038, 0.0400, 0.2240, 0.4237],\n",
    "        [0.6565, 0.6878, 0.4670, 0.3470, 0.2281, 0.8074, 0.0178, 0.3999],\n",
    "        [0.1863, 0.3567, 0.6104, 0.0497, 0.0577, 0.2990, 0.6687, 0.8626]]),\n",
    "    weight=torch.tensor([\n",
    "        [ 1.2626e-01, -1.4752e-01,  8.1910e-02,  2.4982e-01, -1.0495e-01,\n",
    "         -1.9227e-01, -1.8550e-01, -1.5700e-01],\n",
    "        [ 2.7624e-01, -4.3835e-01,  5.1010e-02, -1.2020e-01, -2.0344e-01,\n",
    "          1.0202e-01, -2.0799e-01,  2.4112e-01],\n",
    "        [-3.8216e-01, -2.8047e-01,  8.5238e-02, -4.2504e-01, -2.0952e-01,\n",
    "          3.2018e-01, -3.3619e-01,  2.0219e-01],\n",
    "        [ 8.9233e-02, -1.0124e-01,  1.1467e-01,  2.0091e-01,  1.1438e-01,\n",
    "         -4.2427e-01,  1.0178e-01, -3.0941e-04],\n",
    "        [-1.8837e-02, -2.1256e-01, -4.5285e-01,  2.0949e-01, -3.8684e-01,\n",
    "         -1.7100e-01, -4.5331e-01, -2.0433e-01],\n",
    "        [-2.0038e-01, -5.3757e-02,  1.8997e-01, -3.6866e-01,  5.5484e-02,\n",
    "          1.5643e-01, -2.3538e-01,  2.1103e-01],\n",
    "        [-2.6875e-01,  2.4984e-01, -2.3514e-01,  2.5527e-01,  2.0322e-01,\n",
    "          3.7675e-01,  6.1563e-02,  1.7201e-01],\n",
    "        [ 3.3541e-01, -3.3555e-01, -4.3349e-01,  4.3043e-01, -2.0498e-01,\n",
    "         -1.8366e-01, -9.1553e-02, -4.1168e-01]]),\n",
    "    bias=torch.tensor([ 0.1954, -0.2756,  0.3113,  0.1149,  0.4274,  0.2429, -0.1721, -0.2502]),\n",
    "    quantized_bias=torch.tensor([ 3, -2,  3,  1,  3,  2, -2, -2], dtype=torch.int32),\n",
    "    shifted_quantized_bias=torch.tensor([-1,  0, -3, -1, -3,  0,  2, -4], dtype=torch.int32),\n",
    "    calc_quantized_output=torch.tensor([\n",
    "        [ 0, -1,  0, -1, -1,  0,  1, -2],\n",
    "        [ 0,  0, -1,  0,  0,  0,  0, -1],\n",
    "        [ 0,  0,  0, -1,  0,  0,  0, -1],\n",
    "        [ 0,  0,  0,  0,  0,  1, -1, -2]], dtype=torch.int8),\n",
    "    bitwidth=2, batch_size=4, in_channels=8, out_channels=8):\n",
    "    def plot_matrix(tensor, ax, title, vmin=0, vmax=1, cmap=ListedColormap(['white'])):\n",
    "        ax.imshow(tensor.cpu().numpy(), vmin=vmin, vmax=vmax, cmap=cmap)\n",
    "        ax.set_title(title)\n",
    "        ax.set_yticklabels([])\n",
    "        ax.set_xticklabels([])\n",
    "        for i in range(tensor.shape[0]):\n",
    "            for j in range(tensor.shape[1]):\n",
    "                datum = tensor[i, j].item()\n",
    "                if isinstance(datum, float):\n",
    "                    text = ax.text(j, i, f'{datum:.2f}',\n",
    "                                    ha=\"center\", va=\"center\", color=\"k\")\n",
    "                else:\n",
    "                    text = ax.text(j, i, f'{datum}',\n",
    "                                    ha=\"center\", va=\"center\", color=\"k\")\n",
    "\n",
    "    output = torch.nn.functional.linear(input, weight, bias)\n",
    "\n",
    "    quantized_weight, weight_scale, weight_zero_point = \\\n",
    "        linear_quantize_weight_per_channel(weight, bitwidth)\n",
    "    quantized_input, input_scale, input_zero_point = \\\n",
    "        linear_quantize_feature(input, bitwidth)\n",
    "    _quantized_bias, bias_scale, bias_zero_point = \\\n",
    "        linear_quantize_bias_per_output_channel(bias, weight_scale, input_scale)\n",
    "    assert _quantized_bias.equal(_quantized_bias)\n",
    "    _shifted_quantized_bias = \\\n",
    "        shift_quantized_linear_bias(quantized_bias, quantized_weight, input_zero_point)\n",
    "    assert _shifted_quantized_bias.equal(shifted_quantized_bias)\n",
    "    quantized_output, output_scale, output_zero_point = \\\n",
    "        linear_quantize_feature(output, bitwidth)\n",
    "\n",
    "    _calc_quantized_output = quantized_linear(\n",
    "        quantized_input, quantized_weight, shifted_quantized_bias,\n",
    "        bitwidth, bitwidth,\n",
    "        input_zero_point, output_zero_point,\n",
    "        input_scale, weight_scale, output_scale)\n",
    "    assert _calc_quantized_output.equal(calc_quantized_output)\n",
    "\n",
    "    reconstructed_weight = weight_scale * (quantized_weight.float() - weight_zero_point)\n",
    "    reconstructed_input = input_scale * (quantized_input.float() - input_zero_point)\n",
    "    reconstructed_bias = bias_scale * (quantized_bias.float() - bias_zero_point)\n",
    "    reconstructed_calc_output = output_scale * (calc_quantized_output.float() - output_zero_point)\n",
    "\n",
    "    fig, axes = plt.subplots(3,3, figsize=(15, 12))\n",
    "    quantized_min, quantized_max = get_quantized_range(bitwidth)\n",
    "    plot_matrix(weight, axes[0, 0], 'original weight', vmin=-0.5, vmax=0.5)\n",
    "    plot_matrix(input.t(), axes[1, 0], 'original input', vmin=0, vmax=1)\n",
    "    plot_matrix(output.t(), axes[2, 0], 'original output', vmin=-1.5, vmax=1.5)\n",
    "    plot_matrix(quantized_weight, axes[0, 1], f'{bitwidth}-bit linear quantized weight',\n",
    "                vmin=quantized_min, vmax=quantized_max, cmap='tab20c')\n",
    "    plot_matrix(quantized_input.t(), axes[1, 1], f'{bitwidth}-bit linear quantized input',\n",
    "                vmin=quantized_min, vmax=quantized_max, cmap='tab20c')\n",
    "    plot_matrix(calc_quantized_output.t(), axes[2, 1], f'quantized output from quantized_linear()',\n",
    "                vmin=quantized_min, vmax=quantized_max, cmap='tab20c')\n",
    "    plot_matrix(reconstructed_weight, axes[0, 2], f'reconstructed weight',\n",
    "                vmin=-0.5, vmax=0.5, cmap='tab20c')\n",
    "    plot_matrix(reconstructed_input.t(), axes[1, 2], f'reconstructed input',\n",
    "                vmin=0, vmax=1, cmap='tab20c')\n",
    "    plot_matrix(reconstructed_calc_output.t(), axes[2, 2], f'reconstructed output',\n",
    "                vmin=-1.5, vmax=1.5, cmap='tab20c')\n",
    "\n",
    "    print('* Test quantized_fc()')\n",
    "    print(f'    target bitwidth: {bitwidth} bits')\n",
    "    print(f'      batch size: {batch_size}')\n",
    "    print(f'      input channels: {in_channels}')\n",
    "    print(f'      output channels: {out_channels}')\n",
    "    print('* Test passed.')\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mDDp0OWLh6vK"
   },
   "source": [
    "Load Pretrained Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# import subprocess\n",
    "# import os\n",
    "\n",
    "# result = subprocess.run('bash -c \"source /etc/network_turbo && env | grep proxy\"', shell=True, capture_output=True, text=True)\n",
    "# output = result.stdout\n",
    "# for line in output.splitlines():\n",
    "#     if '=' in line:\n",
    "#         var, value = line.split('=', 1)\n",
    "#         os.environ[var] = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oNEYAZ_TQf7d",
    "outputId": "cc8da607-74e4-402a-dda8-0256f0a79abd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> loading checkpoint './vgg.cifar.pretrained.pth.2'\n"
     ]
    }
   ],
   "source": [
    "checkpoint_url = \"./vgg.cifar.pretrained.pth.2\"\n",
    "checkpoint = torch.load(checkpoint_url, map_location=\"cpu\")\n",
    "# checkpoint_url = \"https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth\"\n",
    "# checkpoint = torch.load(download_url(checkpoint_url), map_location=\"cpu\")\n",
    "model = VGG().cuda()\n",
    "# model = VGG()\n",
    "print(f\"=> loading checkpoint '{checkpoint_url}'\")\n",
    "model.load_state_dict(checkpoint['state_dict'])\n",
    "recover_model = lambda : model.load_state_dict(checkpoint['state_dict'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jQb3_6zlQfib",
    "outputId": "b641d404-c845-4faf-a5bd-3f4563ed31cc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "image_size = 32\n",
    "transforms = {\n",
    "    \"train\": Compose([\n",
    "        RandomCrop(image_size, padding=4),\n",
    "        RandomHorizontalFlip(),\n",
    "        ToTensor(),\n",
    "    ]),\n",
    "    \"test\": ToTensor(),\n",
    "}\n",
    "dataset = {}\n",
    "for split in [\"train\", \"test\"]:\n",
    "  dataset[split] = CIFAR10(\n",
    "    root=\"data/cifar10\",\n",
    "    train=(split == \"train\"),\n",
    "    download=True,\n",
    "    transform=transforms[split],\n",
    "  )\n",
    "dataloader = {}\n",
    "for split in ['train', 'test']:\n",
    "  dataloader[split] = DataLoader(\n",
    "    dataset[split],\n",
    "    batch_size=64,\n",
    "    shuffle=(split == 'train'),\n",
    "    num_workers=0,\n",
    "    pin_memory=True,\n",
    "  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rjESsg5nkdBG"
   },
   "source": [
    "# Let's First Evaluate the Accuracy and Model Size of the FP32 Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.006810426712036133,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fp32 model has accuracy=92.95%\n"
     ]
    }
   ],
   "source": [
    "fp32_model_accuracy = evaluate(model, dataloader['test'])\n",
    "print(f\"fp32 model has accuracy={fp32_model_accuracy:.2f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 53,
     "referenced_widgets": [
      "ad5b6c560bf343ce868a93239cd70d90",
      "6fa2cbe32b924f2ab8a5a8b423899687",
      "bedc4a062c8f4a62adb77df58443f8fa",
      "e703cd82e6aa4e88956521fa81c2cee5",
      "d04ec8a340184537a00bc74915c6cf00",
      "7a6d74a3063341888db38747c6583672",
      "514f462dd0d34b94b02a8d4ee73ecb65",
      "6073486b74c1496dba43786273d9eb4b",
      "c37c77e092c04a6e8305b820ec9af947",
      "64b23fc20bcc49c6b58b091338eea1f7",
      "09826ccf4f764dffb3f50c4734d0bded"
     ]
    },
    "id": "DTiA8hxMkkbU",
    "outputId": "b3f3c89c-1808-4c46-9b65-2cda8a5220fc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fp32 model has size=35.20 MiB\n"
     ]
    }
   ],
   "source": [
    "# fp32_model_accuracy = evaluate(model, dataloader['test'])\n",
    "# print(f\"fp32 model has accuracy={fp32_model_accuracy:.2f}%\")\n",
    "\n",
    "fp32_model_size = get_model_size(model)\n",
    "print(f\"fp32 model has size={fp32_model_size/MiB:.2f} MiB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6QdGiddu87p2"
   },
   "source": [
    "# K-Means Quantization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gr0MvPoVTirU"
   },
   "source": [
    "Network quantization compresses the network by reducing the bits per weight required to represent the deep network. The quantized network can have a faster inference speed with hardware support."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lzlKpiNvY3lc"
   },
   "source": [
    "In this section, we will explore the K-means quantization for neural networks as in [Deep Compression: Compressing Deep Neural Networks With Pruning, Trained Quantization\n",
    "And Huffman Coding](https://arxiv.org/pdf/1510.00149.pdf).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KDoR8iXP0VDG"
   },
   "source": [
    "![kmeans.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mGkEk4CX0VIe"
   },
   "source": [
    "A $n$-bit k-means quantization will divide synapses into $2^n$ clusters, and synapses in the same cluster will share the same weight value.\n",
    "\n",
    "Therefore, k-means quantization will create a codebook, inlcuding\n",
    "*   `centroids`: $2^n$ fp32 cluster centers.\n",
    "*   `labels`: a $n$-bit integer tensor with the same #elements of the original fp32 weights tensor. Each integer indicates which cluster it belongs to.\n",
    "\n",
    "During the inference, a fp32 tensor is generated based on the codebook for inference:\n",
    "\n",
    "> ***quantized_weight* = *codebook.centroids*\\[*codebook.labels*\\].view_as(weight)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "Z2x1DbpfT3SD"
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Codebook = namedtuple('Codebook', ['centroids', 'labels'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f3BczeDEN0y6"
   },
   "source": [
    "## Question 1 (10 pts)\n",
    "\n",
    "Please complete the following K-Means quantization function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "id": "bnZ2b4hgOnoC"
   },
   "outputs": [],
   "source": [
    "from fast_pytorch_kmeans import KMeans\n",
    "\n",
    "def k_means_quantize(fp32_tensor: torch.Tensor, bitwidth=4, codebook=None):\n",
    "    \"\"\"\n",
    "    quantize tensor using k-means clustering\n",
    "    :param fp32_tensor:\n",
    "    :param bitwidth: [int] quantization bit width, default=4\n",
    "    :param codebook: [Codebook] (the cluster centroids, the cluster label tensor)\n",
    "    :return:\n",
    "        [Codebook = (centroids, labels)]\n",
    "            centroids: [torch.(cuda.)FloatTensor] the cluster centroids\n",
    "            labels: [torch.(cuda.)LongTensor] cluster label tensor\n",
    "    \"\"\"\n",
    "    if codebook is None:\n",
    "        #fp32_tensor####### YOUR CODE STARTS HERE ###############\n",
    "        # get number of clusters based on the quantization precision\n",
    "        # hint: one line of code\n",
    "        n_clusters = 2 ** bitwidth\n",
    "        ############### YOUR CODE ENDS HERE #################\n",
    "        # use k-means to get the quantization centroids\n",
    "        kmeans = KMeans(n_clusters=n_clusters, mode='euclidean', verbose=0)\n",
    "        labels = kmeans.fit_predict(fp32_tensor.view(-1, 1)).to(torch.long)\n",
    "        centroids = kmeans.centroids.to(torch.float).view(-1)\n",
    "        codebook = Codebook(centroids, labels)\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # decode the codebook into k-means quantized tensor for inference\n",
    "    # hint: one line of code\n",
    "    quantized_tensor = codebook.centroids[codebook.labels]\n",
    "    # quantized_tensor = torch.tensor([codebook.centroids[i] for i in codebook.labels]).to(fp32_tensor.device)\n",
    "    # print(quantized_tensor.device, fp32_tensor.device)\n",
    "    # import pdb; pdb.set_trace()\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "    fp32_tensor.set_(quantized_tensor.view_as(fp32_tensor))\n",
    "    return codebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XlVfIFRYPbfc"
   },
   "source": [
    "Let's verify the functionality of defined k-means quantization by applying the function above on a dummy tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 617
    },
    "id": "WZd8z1vGPdG8",
    "outputId": "afd40a74-b932-452b-b4d8-448cb1bbaea1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.3518, -0.0213,  0.2921, -0.3518,  0.2921],\n",
      "        [-0.0213,  0.2921, -0.3518, -0.3518,  0.2921],\n",
      "        [ 0.2921, -0.3518, -0.3518, -0.0213, -0.3518],\n",
      "        [-0.0213, -0.0213, -0.3518, -0.3518,  0.2921],\n",
      "        [-0.0213, -0.3518, -0.3518,  0.2921, -0.0213]])\n",
      "* Test k_means_quantize()\n",
      "    target bitwidth: 2 bits\n",
      "        num unique values before k-means quantization: 3\n",
      "        num unique values after  k-means quantization: 3\n",
      "* Test passed.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_k_means_quantize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O4FIfKk8JQX5"
   },
   "source": [
    "## Question 2 (10 pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o5mT6vV_JS5w"
   },
   "source": [
    "The last code cell performs 2-bit k-means quantization\n",
    "and plots the tensor before and after the quantization. Each cluster is rendered with a unique color. There are 4 unique colors rendered in the quantized tensor.\n",
    "\n",
    "Given this observation, please answer the following questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DwERfTxNKFqa"
   },
   "source": [
    "### Question 2.1 (5 pts)\n",
    "\n",
    "If 4-bit k-means quantization is performed, how many unique colors will be rendered in the quantized tensor?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0PGiy4rGKPbe"
   },
   "source": [
    "**Your Answer:**  16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dt1ZGParKRWD"
   },
   "source": [
    "### Question 2.2 (5 pts)\n",
    "\n",
    "If *n*-bit k-means quantization is performed, how many unique colors will be rendered in the quantized tensor?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gK8v80tnKZHa"
   },
   "source": [
    "**Your Answer:** 2**n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Aa7KVrLrSlNb"
   },
   "source": [
    "## K-Means Quantization on Whole Model\n",
    "\n",
    "Similar to what we did in lab 1, we now wrap the k-means quantization function into a class for quantizing the whole model. In class `KMeansQuantizer`, we have to keep a record of the codebooks (i.e., `centroids` and `labels`) so that we could apply or update the codebooks whenever the model weights change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "id": "eaMAP465Te-p"
   },
   "outputs": [],
   "source": [
    "from torch.nn import parameter\n",
    "class KMeansQuantizer:\n",
    "    def __init__(self, model : nn.Module, bitwidth=4):\n",
    "        self.codebook = KMeansQuantizer.quantize(model, bitwidth)\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def apply(self, model, update_centroids):\n",
    "        for name, param in model.named_parameters():\n",
    "            if name in self.codebook:\n",
    "                if update_centroids:\n",
    "                    update_codebook(param, codebook=self.codebook[name])\n",
    "                self.codebook[name] = k_means_quantize(\n",
    "                    param, codebook=self.codebook[name])\n",
    "\n",
    "    @staticmethod\n",
    "    @torch.no_grad()\n",
    "    def quantize(model: nn.Module, bitwidth=4):\n",
    "        codebook = dict()\n",
    "        if isinstance(bitwidth, dict):\n",
    "            for name, param in model.named_parameters():\n",
    "                if name in bitwidth:\n",
    "                    codebook[name] = k_means_quantize(param, bitwidth=bitwidth[name])\n",
    "        else:\n",
    "            for name, param in model.named_parameters():\n",
    "                if param.dim() > 1:\n",
    "                    codebook[name] = k_means_quantize(param, bitwidth=bitwidth)\n",
    "        return codebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "od8iy9KjVhlT"
   },
   "source": [
    "Now let's quantize model into 8 bits, 4 bits and 2 bits using K-Means Quantization. *Note that we ignore the storage for codebooks when calculating the model size.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 198,
     "referenced_widgets": [
      "46892d7217234937a2075b54eb53b21c",
      "80e4fe9caf854c4f8f6b8dd84279a0bb",
      "04a3d093af94471a82901728bd1d0047",
      "b816947748334439a1ac9c4e4ec972a3",
      "d2ca4d4575a547ef813bcf67d06731bc",
      "e7555fa29fea435ba06492262ea23025",
      "3f17773aebf049389df462c92ab81d70",
      "5145c0622cec4fcdb3fe8c9a9c1c67da",
      "e49093574063476eb0d16fac9ea864ff",
      "5fdca8a8df304221a45a6506c5ddb963",
      "7c3c8d1a58c64b08b74eca64c372cf70",
      "fd30b2e812f64490b6187b1c1f05e16a",
      "ec371339d3034321849d60c736bc561a",
      "9d01e8022c65423da1b59ef12645dd0f",
      "0fd1df941349405aafb60066b796534f",
      "ab33092059dd460a910bcb069e22f476",
      "0d9c4ad64a8443b7b7def8be9f3ef017",
      "fe48396262e1440ba8ab08bc985f3082",
      "9c444234c59a42a08b6fe57e00314d4d",
      "bfe5f3e25f144841b0b9c1d76241bcc9",
      "e71c40534bdc45cc8ede15e5d6e881e5",
      "44def100781e4ab3be646243af253093",
      "c05cde7977e74584bc77d59b7c0ebd13",
      "9277f4e283444aa1921624f8c91a607b",
      "96697b08aaa648fcaf3325fb1fb3b453",
      "cced96ac1d80461a818bfe8018afbd86",
      "6d142ac2daed41cbaddef18787a9e227",
      "4a29e42982444cc2a8940dce0f8ef9b7",
      "e3b66716fb3c44149723c966cbd81a67",
      "c56e25f6842c4b34994a4f96ceea2199",
      "0a4c9a04d46d419581fd6b161954be1e",
      "c210b5e033154f4aa7014afb9ea0961e",
      "24aa08087bef412cbf86c6dbfd0d915a"
     ]
    },
    "id": "CCI9sCUmVre-",
    "outputId": "d2184c66-f9cb-4124-d826-7474bad8ebb5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note that the storage for codebooks is ignored when calculating the model size.\n",
      "k-means quantizing model into 8 bits\n",
      "    8-bit k-means quantized model has size=8.80 MiB\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.00562739372253418,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    8-bit k-means quantized model has accuracy=92.83%\n",
      "k-means quantizing model into 4 bits\n",
      "    4-bit k-means quantized model has size=4.40 MiB\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.0049860477447509766,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    4-bit k-means quantized model has accuracy=73.70%\n",
      "k-means quantizing model into 2 bits\n",
      "    2-bit k-means quantized model has size=2.20 MiB\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.004969358444213867,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    2-bit k-means quantized model has accuracy=13.33%\n"
     ]
    }
   ],
   "source": [
    "print('Note that the storage for codebooks is ignored when calculating the model size.')\n",
    "quantizers = dict()\n",
    "for bitwidth in [8, 4, 2]:\n",
    "    recover_model()\n",
    "    print(f'k-means quantizing model into {bitwidth} bits')\n",
    "    quantizer = KMeansQuantizer(model, bitwidth)\n",
    "    quantized_model_size = get_model_size(model, bitwidth)\n",
    "    print(f\"    {bitwidth}-bit k-means quantized model has size={quantized_model_size/MiB:.2f} MiB\")\n",
    "    quantized_model_accuracy = evaluate(model, dataloader['test'])\n",
    "    print(f\"    {bitwidth}-bit k-means quantized model has accuracy={quantized_model_accuracy:.2f}%\")\n",
    "    quantizers[bitwidth] = quantizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4jj3FnIIWVq0"
   },
   "source": [
    "## Trained K-Means Quantization\n",
    "\n",
    "As we can see from the results of last cell, the accuracy significantly drops when quantizing the model into lower bits. Therefore, we have to perform quantization-aware training to recover the accuracy.\n",
    "\n",
    "During the k-means quantization-aware training, the centroids are also updated, which is proposed in [Deep Compression: Compressing Deep Neural Networks With Pruning, Trained Quantization\n",
    "And Huffman Coding](https://arxiv.org/pdf/1510.00149.pdf).\n",
    "\n",
    "The gradient for the centroids is calculated as,\n",
    "\n",
    "> $\\frac{\\partial \\mathcal{L} }{\\partial C_k} = \\sum_{j} \\frac{\\partial \\mathcal{L} }{\\partial W_{j}} \\frac{\\partial W_{j} }{\\partial C_k} = \\sum_{j} \\frac{\\partial \\mathcal{L} }{\\partial W_{j}} \\mathbf{1}(I_{j}=k)$\n",
    "\n",
    "where $\\mathcal{L}$ is the loss, $C_k$ is *k*-th centroid, $I_{j}$ is the label for weight $W_{j}$. $\\mathbf{1}()$ is the indicator function, and $\\mathbf{1}(I_{j}=k)$ means $1\\;\\mathrm{if}\\;I_{j}=k\\;\\mathrm{else}\\;0$, *i.e.*, $I_{j}==k$.\n",
    "\n",
    "Here in the lab, **for simplicity**, we directly update the centroids according to the latest weights:\n",
    "\n",
    "> $C_k = \\frac{\\sum_{j}W_{j}\\mathbf{1}(I_{j}=k)}{\\sum_{j}\\mathbf{1}(I_{j}=k)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q_hfG16fLVda"
   },
   "source": [
    "### Question 3 (10 pts)\n",
    "\n",
    "Please complete the following codebook update function.\n",
    "\n",
    "**Hint**:\n",
    "\n",
    "The above equation for updating centroids is indeed using the `mean` of weights in the same cluster to be the updated centroid value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "id": "t8_FfiUf_1ZM"
   },
   "outputs": [],
   "source": [
    "def update_codebook(fp32_tensor: torch.Tensor, codebook: Codebook):\n",
    "    \"\"\"\n",
    "    update the centroids in the codebook using updated fp32_tensor\n",
    "    :param fp32_tensor: [torch.(cuda.)Tensor]\n",
    "    :param codebook: [Codebook] (the cluster centroids, the cluster label tensor)\n",
    "    \"\"\"\n",
    "    n_clusters = codebook.centroids.numel()\n",
    "    fp32_tensor = fp32_tensor.view(-1)\n",
    "    for k in range(n_clusters):\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "        # hint: one line of code\n",
    "        codebook.centroids[k] = (fp32_tensor * (codebook.labels == k)).sum() / (codebook.labels == k).sum()\n",
    "    ############### YOUR CODE ENDS HERE #################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ho4RDW0ccw4f"
   },
   "source": [
    "Now let's run the following code cell to finetune the k-means quantized model to recover the accuracy. We will stop finetuning if accuracy drop is less than 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 424
    },
    "id": "DR1Fu6Arfgnk",
    "outputId": "decdbbcd-2786-4e84-fab1-2069401e5dc6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k-means quantizing model into 8 bits\n",
      "    8-bit k-means quantized model has size=8.80 MiB\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005362033843994141,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    8-bit k-means quantized model has accuracy=92.83% before quantization-aware training \n",
      "        No need for quantization-aware training since accuracy drop=0.12% is smaller than threshold=0.50%\n",
      "k-means quantizing model into 4 bits\n",
      "    4-bit k-means quantized model has size=4.40 MiB\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005182504653930664,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    4-bit k-means quantized model has accuracy=76.40% before quantization-aware training \n",
      "        Quantization-aware training due to accuracy drop=16.55% is larger than threshold=0.50%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005668163299560547,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.008824586868286133,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 0 Accuracy 92.39% / Best Accuracy: 92.39%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005066633224487305,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.009482383728027344,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 1 Accuracy 92.26% / Best Accuracy: 92.39%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005222320556640625,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.007733821868896484,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 2 Accuracy 92.57% / Best Accuracy: 92.57%\n",
      "k-means quantizing model into 2 bits\n",
      "    2-bit k-means quantized model has size=2.20 MiB\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005259037017822266,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    2-bit k-means quantized model has accuracy=13.33% before quantization-aware training \n",
      "        Quantization-aware training due to accuracy drop=79.62% is larger than threshold=0.50%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005685091018676758,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005173921585083008,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 0 Accuracy 91.73% / Best Accuracy: 91.73%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005122661590576172,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005523681640625,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 1 Accuracy 91.69% / Best Accuracy: 91.73%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005321502685546875,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005497932434082031,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 2 Accuracy 91.81% / Best Accuracy: 91.81%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.011488914489746094,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.005468845367431641,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 3 Accuracy 91.80% / Best Accuracy: 91.81%\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.0050830841064453125,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "train",
       "rate": null,
       "total": 782,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/782 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.006975412368774414,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Epoch 4 Accuracy 91.90% / Best Accuracy: 91.90%\n"
     ]
    }
   ],
   "source": [
    "accuracy_drop_threshold = 0.5\n",
    "quantizers_before_finetune = copy.deepcopy(quantizers)\n",
    "quantizers_after_finetune = quantizers\n",
    "\n",
    "for bitwidth in [8, 4, 2]:\n",
    "    recover_model()\n",
    "    quantizer = quantizers[bitwidth]\n",
    "    print(f'k-means quantizing model into {bitwidth} bits')\n",
    "    quantizer.apply(model, update_centroids=False)\n",
    "    quantized_model_size = get_model_size(model, bitwidth)\n",
    "    print(f\"    {bitwidth}-bit k-means quantized model has size={quantized_model_size/MiB:.2f} MiB\")\n",
    "    quantized_model_accuracy = evaluate(model, dataloader['test'])\n",
    "    print(f\"    {bitwidth}-bit k-means quantized model has accuracy={quantized_model_accuracy:.2f}% before quantization-aware training \")\n",
    "    accuracy_drop = fp32_model_accuracy - quantized_model_accuracy\n",
    "    if accuracy_drop > accuracy_drop_threshold:\n",
    "        print(f\"        Quantization-aware training due to accuracy drop={accuracy_drop:.2f}% is larger than threshold={accuracy_drop_threshold:.2f}%\")\n",
    "        num_finetune_epochs = 5\n",
    "        optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
    "        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, num_finetune_epochs)\n",
    "        criterion = nn.CrossEntropyLoss()\n",
    "        best_accuracy = 0\n",
    "        epoch = num_finetune_epochs\n",
    "        while accuracy_drop > accuracy_drop_threshold and epoch > 0:\n",
    "            train(model, dataloader['train'], criterion, optimizer, scheduler,\n",
    "                  callbacks=[lambda: quantizer.apply(model, update_centroids=True)])\n",
    "            model_accuracy = evaluate(model, dataloader['test'])\n",
    "            is_best = model_accuracy > best_accuracy\n",
    "            best_accuracy = max(model_accuracy, best_accuracy)\n",
    "            print(f'        Epoch {num_finetune_epochs-epoch} Accuracy {model_accuracy:.2f}% / Best Accuracy: {best_accuracy:.2f}%')\n",
    "            accuracy_drop = fp32_model_accuracy - best_accuracy\n",
    "            epoch -= 1\n",
    "    else:\n",
    "        print(f\"        No need for quantization-aware training since accuracy drop={accuracy_drop:.2f}% is smaller than threshold={accuracy_drop_threshold:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "USisw8QcnPNP"
   },
   "source": [
    "# Linear Quantization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sEzwgl9mZ6F2"
   },
   "source": [
    "In this section, we will implement and perform linear quantization.\n",
    "\n",
    "Linear quantization directly rounds the floating-point value into the nearest quantized integer after range truncation and scaling.\n",
    "\n",
    "[Linear quantization](https://arxiv.org/pdf/1712.05877.pdf) can be represented as\n",
    "\n",
    "$r = S(q-Z)$\n",
    "\n",
    "where $r$ is a floating point real number, $q$ is a *n*-bit integer, $Z$ is a *n*-bit integer, and $S$ is a floating point real number. $Z$ is quantization zero point and $S$ is quantization scaling factor. Both constant $Z$ and $S$ are quantization parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c6vO1_VBdTzs"
   },
   "source": [
    "## *n*-bit Integer\n",
    "\n",
    "A *n*-bit signed integer is usually represented in [two's complement](https://en.wikipedia.org/wiki/Two%27s_complement) notation.\n",
    "\n",
    "A *n*-bit signed integer can enode integers in the range $[-2^{n-1}, 2^{n-1}-1]$. For example, a 8-bit integer falls in the range [-128, 127]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "uz51HcD8dTIb"
   },
   "outputs": [],
   "source": [
    "def get_quantized_range(bitwidth):\n",
    "    quantized_max = (1 << (bitwidth - 1)) - 1\n",
    "    quantized_min = -(1 << (bitwidth - 1))\n",
    "    return quantized_min, quantized_max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FSRwyEWrnA7o"
   },
   "source": [
    "## **Question 4** (15 pts)\n",
    "\n",
    "Please complete the following linear quantization function.\n",
    "\n",
    "**Hint**:\n",
    "*   From $r=S(q-Z)$, we have $q = r/S + Z$.\n",
    "*   Both $r$ and $S$ are floating numbers, and thus we cannot directly add integer $Z$ to $r/S$. Therefore $q = \\mathrm{int}(\\mathrm{round}(r/S)) + Z$.\n",
    "*   To convert [`torch.FloatTensor`](https://pytorch.org/docs/stable/tensors.html) to [`torch.IntTensor`](https://pytorch.org/docs/stable/tensors.html), we could use [`torch.round()`](https://pytorch.org/docs/stable/generated/torch.round.html#torch.round), [`torch.Tensor.round()`](https://pytorch.org/docs/stable/generated/torch.Tensor.round.html#torch.Tensor.round), [`torch.Tensor.round_()`](https://pytorch.org/docs/stable/generated/torch.Tensor.round_) to first convert all values to floating integer, and then use [`torch.Tensor.to(torch.int8)`](https://pytorch.org/docs/stable/generated/torch.Tensor.to.html#torch.Tensor.to) to convert the data type from [`torch.float`](https://pytorch.org/docs/stable/tensors.html) to [`torch.int8`](https://pytorch.org/docs/stable/tensors.html).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "id": "1vg4SfIJYFUq"
   },
   "outputs": [],
   "source": [
    "def linear_quantize(fp_tensor, bitwidth, scale, zero_point, dtype=torch.int8) -> torch.Tensor:\n",
    "    \"\"\"\n",
    "    linear quantization for single fp_tensor\n",
    "      from\n",
    "        fp_tensor = (quantized_tensor - zero_point) * scale\n",
    "      we have,\n",
    "        quantized_tensor = int(round(fp_tensor / scale)) + zero_point\n",
    "    :param tensor: [torch.(cuda.)FloatTensor] floating tensor to be quantized\n",
    "    :param bitwidth: [int] quantization bit width\n",
    "    :param scale: [torch.(cuda.)FloatTensor] scaling factor\n",
    "    :param zero_point: [torch.(cuda.)IntTensor] the desired centroid of tensor values\n",
    "    :return:\n",
    "        [torch.(cuda.)FloatTensor] quantized tensor whose values are integers\n",
    "    \"\"\"\n",
    "    assert(fp_tensor.dtype == torch.float)\n",
    "    assert(isinstance(scale, float) or\n",
    "           (scale.dtype == torch.float and scale.dim() == fp_tensor.dim()))\n",
    "    assert(isinstance(zero_point, int) or\n",
    "           (zero_point.dtype == dtype and zero_point.dim() == fp_tensor.dim()))\n",
    "\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # Step 1: scale the fp_tensor\n",
    "    scaled_tensor = fp_tensor / scale\n",
    "    # Step 2: round the floating value to integer value\n",
    "    rounded_tensor = torch.round(scaled_tensor)\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "    rounded_tensor = rounded_tensor.to(dtype)\n",
    "\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # Step 3: shift the rounded_tensor to make zero_point 0\n",
    "    shifted_tensor = rounded_tensor + zero_point\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "    # Step 4: clamp the shifted_tensor to lie in bitwidth-bit range\n",
    "    quantized_min, quantized_max = get_quantized_range(bitwidth)\n",
    "    quantized_tensor = shifted_tensor.clamp_(quantized_min, quantized_max)\n",
    "    return quantized_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Qn-OU5z9IAtr"
   },
   "source": [
    "Let's verify the functionality of defined linear quantization by applying the function above on a dummy tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 462
    },
    "id": "10sN7WRNAWCc",
    "outputId": "d52928c7-d36e-4e2a-d0e1-91fc952b6bf2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Test linear_quantize()\n",
      "    target bitwidth: 2 bits\n",
      "        scale: 0.3333333333333333\n",
      "        zero point: -1\n",
      "* Test passed.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x3200 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_linear_quantize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y9WBvG1jnhEz"
   },
   "source": [
    "## Question 5 (10 pts)\n",
    "\n",
    "Now we have to determine the scaling factor $S$ and zero point $Z$ for linear quantization.\n",
    "\n",
    "Recall that [linear quantization](https://arxiv.org/pdf/1712.05877.pdf) can be represented as\n",
    "\n",
    "$r = S(q-Z)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lLgyax_fgrS1"
   },
   "source": [
    "### Scale\n",
    "\n",
    "Linear quantization projects the floating point range [*fp_min*, *fp_max*] to the quantized range [*quantized_min*, *quantized_max*]. That is to say,\n",
    "\n",
    "> $r_{\\mathrm{max}} = S(q_{\\mathrm{max}}-Z)$\n",
    ">\n",
    "> $r_{\\mathrm{min}} = S(q_{\\mathrm{min}}-Z)$\n",
    "\n",
    "Substracting these two equations, we have,\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PkSalSPzSwN2"
   },
   "source": [
    "#### Question 5.1 (1 pts)\n",
    "\n",
    "Please select the correct answer and delete the wrong answers in the next text cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dctWTxHaTnUy"
   },
   "source": [
    "\n",
    "> $S=(r_{\\mathrm{max}} - r_{\\mathrm{min}}) / (q_{\\mathrm{max}} - q_{\\mathrm{min}})$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WWfff4eISuES"
   },
   "source": [
    "\n",
    "There are different approaches to determine the $r_{\\mathrm{min}}$ and  $r_{\\mathrm{max}}$ of a floating point tensor `fp_tensor`.\n",
    "\n",
    "*   The most common method is directly using the minimum and maximum value of `fp_tensor`.\n",
    "*   Another widely used method is minimizing Kullback-Leibler-J divergence to determine the *fp_max*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SSb42B8Gjlpa"
   },
   "source": [
    "### zero point\n",
    "\n",
    "Once we determine the scaling factor $S$, we can directly use the relationship between $r_{\\mathrm{min}}$ and $q_{\\mathrm{min}}$ to calculate the zero point $Z$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u13Wmw_8TdDA"
   },
   "source": [
    "#### Question 5.2 (1 pts)\n",
    "\n",
    "Please select the correct answer and delete the wrong answers in the next text cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uD3Q_FfSTwIL"
   },
   "source": [
    "> $Z = \\mathrm{int}(\\mathrm{round}(q_{\\mathrm{min}} - r_{\\mathrm{min}} / S))$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tk4aPTKdAikt"
   },
   "source": [
    "### Question 5.3 (8 pts)\n",
    "\n",
    "Please complete the following function for calculating the scale $S$ and zero point $Z$ from floating point tensor $r$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "id": "LfAjS4KhfwDY"
   },
   "outputs": [],
   "source": [
    "def get_quantization_scale_and_zero_point(fp_tensor, bitwidth):\n",
    "    \"\"\"\n",
    "    get quantization scale for single tensor\n",
    "    :param fp_tensor: [torch.(cuda.)Tensor] floating tensor to be quantized\n",
    "    :param bitwidth: [int] quantization bit width\n",
    "    :return:\n",
    "        [float] scale\n",
    "        [int] zero_point\n",
    "    \"\"\"\n",
    "    quantized_min, quantized_max = get_quantized_range(bitwidth)\n",
    "    fp_max = fp_tensor.max().item()\n",
    "    fp_min = fp_tensor.min().item()\n",
    "\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # hint: one line of code for calculating scale\n",
    "    scale = (fp_max - fp_min) / (quantized_max - quantized_min)\n",
    "    # hint: one line of code for calculating zero_point\n",
    "    zero_point = quantized_min - fp_min / scale\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "    # clip the zero_point to fall in [quantized_min, quantized_max]\n",
    "    if zero_point < quantized_min:\n",
    "        zero_point = quantized_min\n",
    "    elif zero_point > quantized_max:\n",
    "        zero_point = quantized_max\n",
    "    else: # convert from float to int using round()\n",
    "        zero_point = round(zero_point)\n",
    "    return scale, int(zero_point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OW1AOZboSK0e"
   },
   "source": [
    "We now wrap  `linear_quantize()` in Question 4 and `get_quantization_scale_and_zero_point()` in Question 5 into one function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "id": "FWeOwwXgoPLc"
   },
   "outputs": [],
   "source": [
    "def linear_quantize_feature(fp_tensor, bitwidth):\n",
    "    \"\"\"\n",
    "    linear quantization for feature tensor\n",
    "    :param fp_tensor: [torch.(cuda.)Tensor] floating feature to be quantized\n",
    "    :param bitwidth: [int] quantization bit width\n",
    "    :return:\n",
    "        [torch.(cuda.)Tensor] quantized tensor\n",
    "        [float] scale tensor\n",
    "        [int] zero point\n",
    "    \"\"\"\n",
    "    scale, zero_point = get_quantization_scale_and_zero_point(fp_tensor, bitwidth)\n",
    "    quantized_tensor = linear_quantize(fp_tensor, bitwidth, scale, zero_point)\n",
    "    return quantized_tensor, scale, zero_point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a0YWp1YtfY-a"
   },
   "source": [
    "## Special case: linear quantization on weight tensor\n",
    "\n",
    "Let's first see the distribution of weight values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 609
    },
    "id": "-HdIc5kKk89j",
    "outputId": "9210eb70-1e84-4b4c-e3f0-ff3ad4909b0b"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_weight_distribution(model, bitwidth=32):\n",
    "    # bins = (1 << bitwidth) if bitwidth <= 8 else 256\n",
    "    if bitwidth <= 8:\n",
    "        qmin, qmax = get_quantized_range(bitwidth)\n",
    "        bins = np.arange(qmin, qmax + 2)\n",
    "        align = 'left'\n",
    "    else:\n",
    "        bins = 256\n",
    "        align = 'mid'\n",
    "    fig, axes = plt.subplots(3,3, figsize=(10, 6))\n",
    "    axes = axes.ravel()\n",
    "    plot_index = 0\n",
    "    for name, param in model.named_parameters():\n",
    "        if param.dim() > 1:\n",
    "            ax = axes[plot_index]\n",
    "            ax.hist(param.detach().view(-1).cpu(), bins=bins, density=True,\n",
    "                    align=align, color = 'blue', alpha = 0.5,\n",
    "                    edgecolor='black' if bitwidth <= 4 else None)\n",
    "            if bitwidth <= 4:\n",
    "                quantized_min, quantized_max = get_quantized_range(bitwidth)\n",
    "                ax.set_xticks(np.arange(start=quantized_min, stop=quantized_max+1))\n",
    "            ax.set_xlabel(name)\n",
    "            ax.set_ylabel('density')\n",
    "            plot_index += 1\n",
    "    fig.suptitle(f'Histogram of Weights (bitwidth={bitwidth} bits)')\n",
    "    fig.tight_layout()\n",
    "    fig.subplots_adjust(top=0.925)\n",
    "    plt.show()\n",
    "\n",
    "recover_model()\n",
    "plot_weight_distribution(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WpAmSr7IlDn9"
   },
   "source": [
    "As we can see from the histograms above, the distribution of weight values are nearly symmetric about 0 (except for the classifier in this case). Therefore, we usually make zero point $Z=0$ when quantizating the weights.\n",
    "\n",
    "From $r = S(q-Z)$, we have\n",
    "\n",
    "> $r_{\\mathrm{max}} = S \\cdot q_{\\mathrm{max}}$\n",
    "\n",
    "and then\n",
    "\n",
    "> $S = r_{\\mathrm{max}} / q_{\\mathrm{max}}$\n",
    "\n",
    "We directly use the maximum magnitude of weight values as $r_{\\mathrm{max}}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "id": "v3d-Y-G9enEA"
   },
   "outputs": [],
   "source": [
    "def get_quantization_scale_for_weight(weight, bitwidth):\n",
    "    \"\"\"\n",
    "    get quantization scale for single tensor of weight\n",
    "    :param weight: [torch.(cuda.)Tensor] floating weight to be quantized\n",
    "    :param bitwidth: [integer] quantization bit width\n",
    "    :return:\n",
    "        [floating scalar] scale\n",
    "    \"\"\"\n",
    "    # we just assume values in weight are symmetric\n",
    "    # we also always make zero_point 0 for weight\n",
    "    fp_max = max(weight.abs().max().item(), 5e-7)\n",
    "    _, quantized_max = get_quantized_range(bitwidth)\n",
    "    return fp_max / quantized_max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X71SQhfDnwS7"
   },
   "source": [
    "### Per-channel Linear Quantization\n",
    "\n",
    "Recall that for 2D convolution, the weight tensor is a 4-D tensor in the shape of (num_output_channels, num_input_channels, kernel_height, kernel_width).\n",
    "\n",
    "Intensive experiments show that using the different scaling factors $S$ and zero points $Z$ for different output channels will perform better. Therefore, we have to determine scaling factor $S$ and zero point $Z$ for the subtensor of each output channel independently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "id": "tFkA5JlgoiLs"
   },
   "outputs": [],
   "source": [
    "def linear_quantize_weight_per_channel(tensor, bitwidth):\n",
    "    \"\"\"\n",
    "    linear quantization for weight tensor\n",
    "        using different scales and zero_points for different output channels\n",
    "    :param tensor: [torch.(cuda.)Tensor] floating weight to be quantized\n",
    "    :param bitwidth: [int] quantization bit width\n",
    "    :return:\n",
    "        [torch.(cuda.)Tensor] quantized tensor\n",
    "        [torch.(cuda.)Tensor] scale tensor\n",
    "        [int] zero point (which is always 0)\n",
    "    \"\"\"\n",
    "    dim_output_channels = 0\n",
    "    num_output_channels = tensor.shape[dim_output_channels]\n",
    "    scale = torch.zeros(num_output_channels, device=tensor.device)\n",
    "    for oc in range(num_output_channels):\n",
    "        _subtensor = tensor.select(dim_output_channels, oc)\n",
    "        _scale = get_quantization_scale_for_weight(_subtensor, bitwidth)\n",
    "        scale[oc] = _scale\n",
    "    scale_shape = [1] * tensor.dim()\n",
    "    scale_shape[dim_output_channels] = -1\n",
    "    scale = scale.view(scale_shape)\n",
    "    quantized_tensor = linear_quantize(tensor, bitwidth, scale, zero_point=0)\n",
    "    return quantized_tensor, scale, 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CbB4x8ZhwsKz"
   },
   "outputs": [],
   "source": [
    "# per tensor 量化时， 按照output channel选取量化，其中，选取tensor时，可以使用tensor.select(dim, oc), outputchannel总是第0个维度\n",
    "# 上述 linear量化，可以处理scale 和 zero point为列表。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bqKnjcUJpq2R"
   },
   "source": [
    "### A Quick Peek at Linear Quantization on Weights\n",
    "\n",
    "Now let's have a peek on the weight distribution and model size when applying linear quantization on weights with different bitwidths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "6PzZe2DGvWap",
    "outputId": "50ba2a30-c4e0-44bd-face-9c7d51310035"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def peek_linear_quantization():\n",
    "    for bitwidth in [4, 2]:\n",
    "        for name, param in model.named_parameters():\n",
    "            if param.dim() > 1:\n",
    "                quantized_param, scale, zero_point = \\\n",
    "                    linear_quantize_weight_per_channel(param, bitwidth)\n",
    "                param.copy_(quantized_param)\n",
    "        plot_weight_distribution(model, bitwidth)\n",
    "        recover_model()\n",
    "\n",
    "peek_linear_quantization()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5Dw14QcxxItm"
   },
   "source": [
    "## Quantized Inference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zsHy-Bx-UfpL"
   },
   "source": [
    "After quantization, the inference of convolution and fully-connected layers also change.\n",
    "\n",
    "Recall that $r = S(q-Z)$, and we have\n",
    "\n",
    "> $r_{\\mathrm{input}} = S_{\\mathrm{input}}(q_{\\mathrm{input}}-Z_{\\mathrm{input}})$\n",
    ">\n",
    "> $r_{\\mathrm{weight}} = S_{\\mathrm{weight}}(q_{\\mathrm{weight}}-Z_{\\mathrm{weight}})$\n",
    ">\n",
    "> $r_{\\mathrm{bias}} = S_{\\mathrm{bias}}(q_{\\mathrm{bias}}-Z_{\\mathrm{bias}})$\n",
    "\n",
    "Since $Z_{\\mathrm{weight}}=0$, $r_{\\mathrm{weight}} = S_{\\mathrm{weight}}q_{\\mathrm{weight}}$.\n",
    "\n",
    "The floating point convolution can be written as,\n",
    "\n",
    "> $r_{\\mathrm{output}} = \\mathrm{CONV}[r_{\\mathrm{input}}, r_{\\mathrm{weight}}] + r_{\\mathrm{bias}}\\\\\n",
    "\\;\\;\\;\\;\\;\\;\\;\\;= \\mathrm{CONV}[S_{\\mathrm{input}}(q_{\\mathrm{input}}-Z_{\\mathrm{input}}), S_{\\mathrm{weight}}q_{\\mathrm{weight}}] + S_{\\mathrm{bias}}(q_{\\mathrm{bias}}-Z_{\\mathrm{bias}})\\\\\n",
    "\\;\\;\\;\\;\\;\\;\\;\\;= \\mathrm{CONV}[q_{\\mathrm{input}}-Z_{\\mathrm{input}}, q_{\\mathrm{weight}}]\\cdot (S_{\\mathrm{input}} \\cdot S_{\\mathrm{weight}}) + S_{\\mathrm{bias}}(q_{\\mathrm{bias}}-Z_{\\mathrm{bias}})$\n",
    "\n",
    "To further simplify the computation, we could let\n",
    "\n",
    "> $Z_{\\mathrm{bias}} = 0$\n",
    ">\n",
    "> $S_{\\mathrm{bias}} = S_{\\mathrm{input}} \\cdot S_{\\mathrm{weight}}$\n",
    "\n",
    "so that\n",
    "\n",
    "> $r_{\\mathrm{output}} = (\\mathrm{CONV}[q_{\\mathrm{input}}-Z_{\\mathrm{input}}, q_{\\mathrm{weight}}] + q_{\\mathrm{bias}})\\cdot (S_{\\mathrm{input}} \\cdot S_{\\mathrm{weight}})$\n",
    "> $\\;\\;\\;\\;\\;\\;\\;\\;= (\\mathrm{CONV}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] - \\mathrm{CONV}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}] + q_{\\mathrm{bias}})\\cdot (S_{\\mathrm{input}}S_{\\mathrm{weight}})$\n",
    "\n",
    "Since\n",
    "> $r_{\\mathrm{output}} = S_{\\mathrm{output}}(q_{\\mathrm{output}}-Z_{\\mathrm{output}})$\n",
    "\n",
    "we have\n",
    "> $S_{\\mathrm{output}}(q_{\\mathrm{output}}-Z_{\\mathrm{output}}) = (\\mathrm{CONV}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] - \\mathrm{CONV}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}] + q_{\\mathrm{bias}})\\cdot (S_{\\mathrm{input}} S_{\\mathrm{weight}})$\n",
    "\n",
    "and thus\n",
    "> $q_{\\mathrm{output}} = (\\mathrm{CONV}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] - \\mathrm{CONV}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}] + q_{\\mathrm{bias}})\\cdot (S_{\\mathrm{input}}S_{\\mathrm{weight}} / S_{\\mathrm{output}}) + Z_{\\mathrm{output}}$\n",
    "\n",
    "Since $Z_{\\mathrm{input}}$, $q_{\\mathrm{weight}}$, $q_{\\mathrm{bias}}$ are determined before inference, let\n",
    "\n",
    "> $Q_{\\mathrm{bias}} = q_{\\mathrm{bias}} - \\mathrm{CONV}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}]$\n",
    "\n",
    "we have\n",
    "\n",
    "> $q_{\\mathrm{output}} = (\\mathrm{CONV}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] + Q_{\\mathrm{bias}}) \\cdot (S_{\\mathrm{input}}S_{\\mathrm{weight}} / S_{\\mathrm{output}}) + Z_{\\mathrm{output}}$\n",
    "\n",
    "Similarily, for fully-connected layer, we have\n",
    "\n",
    "> $q_{\\mathrm{output}} = (\\mathrm{Linear}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] + Q_{\\mathrm{bias}})\\cdot (S_{\\mathrm{input}} \\cdot S_{\\mathrm{weight}} / S_{\\mathrm{output}}) + Z_{\\mathrm{output}}$\n",
    "\n",
    "where\n",
    "\n",
    "> $Q_{\\mathrm{bias}} = q_{\\mathrm{bias}} - \\mathrm{Linear}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}]$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XlH0zg7M2J_L"
   },
   "source": [
    "### Question 6 (5 pts)\n",
    "\n",
    "Please complete the following function for linear quantizing the bias.\n",
    "\n",
    "**Hint**:\n",
    "\n",
    "From the above deduction, we know that\n",
    "\n",
    "> $Z_{\\mathrm{bias}} = 0$\n",
    ">\n",
    "> $S_{\\mathrm{bias}} = S_{\\mathrm{input}} \\cdot S_{\\mathrm{weight}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "id": "0JZiyAms2G1J"
   },
   "outputs": [],
   "source": [
    "def linear_quantize_bias_per_output_channel(bias, weight_scale, input_scale):\n",
    "    \"\"\"\n",
    "    linear quantization for single bias tensor\n",
    "        quantized_bias = fp_bias / bias_scale\n",
    "    :param bias: [torch.FloatTensor] bias weight to be quantized\n",
    "    :param weight_scale: [float or torch.FloatTensor] weight scale tensor\n",
    "    :param input_scale: [float] input scale\n",
    "    :return:\n",
    "        [torch.IntTensor] quantized bias tensor\n",
    "    \"\"\"\n",
    "    assert(bias.dim() == 1)\n",
    "    assert(bias.dtype == torch.float)\n",
    "    assert(isinstance(input_scale, float))\n",
    "    if isinstance(weight_scale, torch.Tensor):\n",
    "        assert(weight_scale.dtype == torch.float)\n",
    "        weight_scale = weight_scale.view(-1)\n",
    "        assert(bias.numel() == weight_scale.numel())\n",
    "\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # hint: one line of code\n",
    "    bias_scale = weight_scale * input_scale\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "    quantized_bias = linear_quantize(bias, 32, bias_scale, zero_point=0, dtype=torch.int32)\n",
    "    return quantized_bias, bias_scale, 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mMM7uYX25rFM"
   },
   "source": [
    "### Quantized Fully-Connected Layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "znsT4EWL5tA5"
   },
   "source": [
    "For quantized fully-connected layer, we first precompute $Q_{\\mathrm{bias}}$. Recall that $Q_{\\mathrm{bias}} = q_{\\mathrm{bias}} - \\mathrm{Linear}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "id": "4rnNs4MN5tgF"
   },
   "outputs": [],
   "source": [
    "def shift_quantized_linear_bias(quantized_bias, quantized_weight, input_zero_point):\n",
    "    \"\"\"\n",
    "    shift quantized bias to incorporate input_zero_point for nn.Linear\n",
    "        shifted_quantized_bias = quantized_bias - Linear(input_zero_point, quantized_weight)\n",
    "    :param quantized_bias: [torch.IntTensor] quantized bias (torch.int32)\n",
    "    :param quantized_weight: [torch.CharTensor] quantized weight (torch.int8)\n",
    "    :param input_zero_point: [int] input zero point\n",
    "    :return:\n",
    "        [torch.IntTensor] shifted quantized bias tensor\n",
    "    \"\"\"\n",
    "    assert(quantized_bias.dtype == torch.int32)\n",
    "    assert(isinstance(input_zero_point, int))\n",
    "    return quantized_bias - quantized_weight.sum(1).to(torch.int32) * input_zero_point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DqNMxMzk3cDz"
   },
   "source": [
    "#### Question 7 (15 pts)\n",
    "\n",
    "Please complete the following quantized fully-connected layer inference function.\n",
    "\n",
    "**Hint**:\n",
    "\n",
    "> $q_{\\mathrm{output}} = (\\mathrm{Linear}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] + Q_{\\mathrm{bias}})\\cdot (S_{\\mathrm{input}} S_{\\mathrm{weight}} / S_{\\mathrm{output}}) + Z_{\\mathrm{output}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "id": "3PVvI7jP3cMo"
   },
   "outputs": [],
   "source": [
    "def quantized_linear(input, weight, bias, feature_bitwidth, weight_bitwidth,\n",
    "                     input_zero_point, output_zero_point,\n",
    "                     input_scale, weight_scale, output_scale):\n",
    "    \"\"\"\n",
    "    quantized fully-connected layer\n",
    "    :param input: [torch.CharTensor] quantized input (torch.int8)\n",
    "    :param weight: [torch.CharTensor] quantized weight (torch.int8)\n",
    "    :param bias: [torch.IntTensor] shifted quantized bias or None (torch.int32)\n",
    "    :param feature_bitwidth: [int] quantization bit width of input and output\n",
    "    :param weight_bitwidth: [int] quantization bit width of weight\n",
    "    :param input_zero_point: [int] input zero point\n",
    "    :param output_zero_point: [int] output zero point\n",
    "    :param input_scale: [float] input feature scale\n",
    "    :param weight_scale: [torch.FloatTensor] weight per-channel scale\n",
    "    :param output_scale: [float] output feature scale\n",
    "    :return:\n",
    "        [torch.CharIntTensor] quantized output feature (torch.int8)\n",
    "    \"\"\"\n",
    "    assert(input.dtype == torch.int8)\n",
    "    assert(weight.dtype == input.dtype)\n",
    "    assert(bias is None or bias.dtype == torch.int32)\n",
    "    assert(isinstance(input_zero_point, int))\n",
    "    assert(isinstance(output_zero_point, int))\n",
    "    assert(isinstance(input_scale, float))\n",
    "    assert(isinstance(output_scale, float))\n",
    "    assert(weight_scale.dtype == torch.float)\n",
    "\n",
    "    # Step 1: integer-based fully-connected (8-bit multiplication with 32-bit accumulation)\n",
    "    if 'cpu' in input.device.type:\n",
    "        # use 32-b MAC for simplicity\n",
    "        output = torch.nn.functional.linear(input.to(torch.int32), weight.to(torch.int32), bias)\n",
    "    else:\n",
    "        # current version pytorch does not yet support integer-based linear() on GPUs\n",
    "        output = torch.nn.functional.linear(input.float(), weight.float(), bias.float())\n",
    "\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # Step 2: scale the output\n",
    "    # hint: 1. scales are floating numbers, we need to convert output to float as well\n",
    "    #   2. the shape of weight scale is [oc, 1, 1, 1] while the shape of output is [batch_size, oc]\n",
    "    # import pdb; pdb.set_trace()\n",
    "    # output = output.to(torch.float)\n",
    "    output = output.transpose(1, 0) * input_scale * weight_scale / output_scale\n",
    "    output = output.transpose(1, 0)\n",
    "\n",
    "    # Step 3: shift output by output_zero_point\n",
    "    #         hint: one line of code\n",
    "    output = output + output_zero_point\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "    # Make sure all value lies in the bitwidth-bit range\n",
    "    output = output.round().clamp(*get_quantized_range(feature_bitwidth)).to(torch.int8)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "115enVamIG_e"
   },
   "source": [
    "Let's verify the functionality of defined quantized fully connected layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "HWmsLxgHH_B3",
    "outputId": "9e7a28cf-854c-45bd-b6b8-bbda62365750"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Test quantized_fc()\n",
      "    target bitwidth: 2 bits\n",
      "      batch size: 4\n",
      "      input channels: 8\n",
      "      output channels: 8\n",
      "* Test passed.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1200 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_quantized_fc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ATooyRrH50ls"
   },
   "source": [
    "### Quantized Convolution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8mk1Ziof51JG"
   },
   "source": [
    "For quantized convolution layer, we first precompute $Q_{\\mathrm{bias}}$. Recall that $Q_{\\mathrm{bias}} = q_{\\mathrm{bias}} - \\mathrm{CONV}[Z_{\\mathrm{input}}, q_{\\mathrm{weight}}]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "id": "wEeANE_I53hz"
   },
   "outputs": [],
   "source": [
    "def shift_quantized_conv2d_bias(quantized_bias, quantized_weight, input_zero_point):\n",
    "    \"\"\"\n",
    "    shift quantized bias to incorporate input_zero_point for nn.Conv2d\n",
    "        shifted_quantized_bias = quantized_bias - Conv(input_zero_point, quantized_weight)\n",
    "    :param quantized_bias: [torch.IntTensor] quantized bias (torch.int32)\n",
    "    :param quantized_weight: [torch.CharTensor] quantized weight (torch.int8)\n",
    "    :param input_zero_point: [int] input zero point\n",
    "    :return:\n",
    "        [torch.IntTensor] shifted quantized bias tensor\n",
    "    \"\"\"\n",
    "    assert(quantized_bias.dtype == torch.int32)\n",
    "    assert(isinstance(input_zero_point, int))\n",
    "    return quantized_bias - quantized_weight.sum((1,2,3)).to(torch.int32) * input_zero_point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0x2SqxOp23cw"
   },
   "source": [
    "#### Question 8 (15 pts)\n",
    "\n",
    "Please complete the following quantized convolution function.\n",
    "\n",
    "**Hint**:\n",
    "> $q_{\\mathrm{output}} = (\\mathrm{CONV}[q_{\\mathrm{input}}, q_{\\mathrm{weight}}] + Q_{\\mathrm{bias}}) \\cdot (S_{\\mathrm{input}}S_{\\mathrm{weight}} / S_{\\mathrm{output}}) + Z_{\\mathrm{output}}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "id": "LVRqhiUno65x"
   },
   "outputs": [],
   "source": [
    "def quantized_conv2d(input, weight, bias, feature_bitwidth, weight_bitwidth,\n",
    "                     input_zero_point, output_zero_point,\n",
    "                     input_scale, weight_scale, output_scale,\n",
    "                     stride, padding, dilation, groups):\n",
    "    \"\"\"\n",
    "    quantized 2d convolution\n",
    "    :param input: [torch.CharTensor] quantized input (torch.int8)\n",
    "    :param weight: [torch.CharTensor] quantized weight (torch.int8)\n",
    "    :param bias: [torch.IntTensor] shifted quantized bias or None (torch.int32)\n",
    "    :param feature_bitwidth: [int] quantization bit width of input and output\n",
    "    :param weight_bitwidth: [int] quantization bit width of weight\n",
    "    :param input_zero_point: [int] input zero point\n",
    "    :param output_zero_point: [int] output zero point\n",
    "    :param input_scale: [float] input feature scale\n",
    "    :param weight_scale: [torch.FloatTensor] weight per-channel scale\n",
    "    :param output_scale: [float] output feature scale\n",
    "    :return:\n",
    "        [torch.(cuda.)CharTensor] quantized output feature\n",
    "    \"\"\"\n",
    "    assert(len(padding) == 4)\n",
    "    assert(input.dtype == torch.int8)\n",
    "    assert(weight.dtype == input.dtype)\n",
    "    assert(bias is None or bias.dtype == torch.int32)\n",
    "    assert(isinstance(input_zero_point, int))\n",
    "    assert(isinstance(output_zero_point, int))\n",
    "    assert(isinstance(input_scale, float))\n",
    "    assert(isinstance(output_scale, float))\n",
    "    assert(weight_scale.dtype == torch.float)\n",
    "\n",
    "    # Step 1: calculate integer-based 2d convolution (8-bit multiplication with 32-bit accumulation)\n",
    "    input = torch.nn.functional.pad(input, padding, 'constant', input_zero_point)\n",
    "    if 'cpu' in input.device.type:\n",
    "        # use 32-b MAC for simplicity\n",
    "        output = torch.nn.functional.conv2d(input.to(torch.int32), weight.to(torch.int32), None, stride, 0, dilation, groups)\n",
    "    else:\n",
    "        # current version pytorch does not yet support integer-based conv2d() on GPUs\n",
    "        output = torch.nn.functional.conv2d(input.float(), weight.float(), None, stride, 0, dilation, groups)\n",
    "        output = output.round().to(torch.int32)\n",
    "    if bias is not None:\n",
    "        output = output + bias.view(1, -1, 1, 1)\n",
    "\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    # hint: this code block should be the very similar to quantized_linear()\n",
    "\n",
    "    # Step 2: scale the output\n",
    "    # hint: 1. scales are floating numbers, we need to convert output to float as well\n",
    "    #    2. the shape of weight scale is [oc, 1, 1, 1] while the shape of output is [batch_size, oc, height, width]\n",
    "    # output = output.float()\n",
    "    # import pdb; pdb.set_trace()\n",
    "    output = output.permute(1, 0, 2, 3) * input_scale * weight_scale / output_scale\n",
    "    output = output.permute(1, 0, 2, 3)\n",
    "    # Step 3: shift output by output_zero_point\n",
    "    #         hint: one line of code\n",
    "    output = output + output_zero_point\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "    # Make sure all value lies in the bitwidth-bit range\n",
    "    output = output.round().clamp(*get_quantized_range(feature_bitwidth)).to(torch.int8)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "32vvQ4WJHVlA"
   },
   "source": [
    "## Question 9 (10 pts)\n",
    "\n",
    "Finally, we are putting everything together and perform post-training `int8` quantization for the model. We will convert the convolutional and linear layers in the model to a quantized version one-by-one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2E5EDR2sINVS"
   },
   "source": [
    "1. Firstly, we will fuse a BatchNorm layer into its previous convolutional layer, which is a standard practice before quantization. Fusing batchnorm reduces the extra multiplication during inference.\n",
    "\n",
    "We will also verify that the fused model `model_fused` has the same accuracy as the original model (BN fusion is an equivalent transform that does not change network functionality)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 456,
     "referenced_widgets": [
      "47119da651ee448d8b6f566c3c18c2e7",
      "9a534e2321da4e4396a1d44bd41b0ad7",
      "36dfec77928d413ab3d729596017161d",
      "164eb1e49ed34274bc7ef0ae03458b58",
      "daa14d9ba26e48f4901cccf72f2d16a4",
      "b75c51a35def4818b928867e6cfb7a3a",
      "00fff45b663b47369df4498d4dbb0ea6",
      "7c2bd46c3e604bc18c80c37233c9e382",
      "e1eb202eb1f048559f66a77c337043f1",
      "2b68c2d8660f4d909b0ecca7f6ac1a9e",
      "0b59c0019d1340509ff7e2510fdf0181"
     ]
    },
    "id": "V2K8KSl7IE4D",
    "outputId": "4d759365-98d9-4ff9-943c-45605572bf0a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before conv-bn fusion: backbone length 29\n",
      "After conv-bn fusion: backbone length 21\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.006163597106933594,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the fused model=92.95%\n"
     ]
    }
   ],
   "source": [
    "def fuse_conv_bn(conv, bn):\n",
    "    # modified from https://mmcv.readthedocs.io/en/latest/_modules/mmcv/cnn/utils/fuse_conv_bn.html\n",
    "    assert conv.bias is None\n",
    "\n",
    "    factor = bn.weight.data / torch.sqrt(bn.running_var.data + bn.eps)\n",
    "    conv.weight.data = conv.weight.data * factor.reshape(-1, 1, 1, 1)\n",
    "    conv.bias = nn.Parameter(- bn.running_mean.data * factor + bn.bias.data)\n",
    "\n",
    "    return conv\n",
    "\n",
    "print('Before conv-bn fusion: backbone length', len(model.backbone))\n",
    "#  fuse the batchnorm into conv layers\n",
    "recover_model()\n",
    "model_fused = copy.deepcopy(model)\n",
    "fused_backbone = []\n",
    "ptr = 0\n",
    "while ptr < len(model_fused.backbone):\n",
    "    if isinstance(model_fused.backbone[ptr], nn.Conv2d) and \\\n",
    "        isinstance(model_fused.backbone[ptr + 1], nn.BatchNorm2d):\n",
    "        fused_backbone.append(fuse_conv_bn(\n",
    "            model_fused.backbone[ptr], model_fused.backbone[ptr+ 1]))\n",
    "        ptr += 2\n",
    "    else:\n",
    "        fused_backbone.append(model_fused.backbone[ptr])\n",
    "        ptr += 1\n",
    "model_fused.backbone = nn.Sequential(*fused_backbone)\n",
    "\n",
    "print('After conv-bn fusion: backbone length', len(model_fused.backbone))\n",
    "# sanity check, no BN anymore\n",
    "for m in model_fused.modules():\n",
    "    assert not isinstance(m, nn.BatchNorm2d)\n",
    "\n",
    "#  the accuracy will remain the same after fusion\n",
    "fused_acc = evaluate(model_fused, dataloader['test'])\n",
    "print(f'Accuracy of the fused model={fused_acc:.2f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oCOXprerMY5t"
   },
   "source": [
    "2. We will run the model with some sample data to get the range of each feature map, so that we can get the range of the feature maps and compute their corresponding scaling factors and zero points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "id": "CjKrC7L-UrxZ"
   },
   "outputs": [],
   "source": [
    "# add hook to record the min max value of the activation\n",
    "input_activation = {}\n",
    "output_activation = {}\n",
    "\n",
    "def add_range_recoder_hook(model):\n",
    "    import functools\n",
    "    def _record_range(self, x, y, module_name):\n",
    "        x = x[0]\n",
    "        input_activation[module_name] = x.detach()\n",
    "        output_activation[module_name] = y.detach()\n",
    "\n",
    "    all_hooks = []\n",
    "    for name, m in model.named_modules():\n",
    "        if isinstance(m, (nn.Conv2d, nn.Linear, nn.ReLU)):\n",
    "            all_hooks.append(m.register_forward_hook(\n",
    "                functools.partial(_record_range, module_name=name)))\n",
    "    return all_hooks\n",
    "\n",
    "hooks = add_range_recoder_hook(model_fused)\n",
    "sample_data = iter(dataloader['train']).__next__()[0]\n",
    "model_fused(sample_data.cuda())\n",
    "\n",
    "# remove hooks\n",
    "for h in hooks:\n",
    "    h.remove()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uq3fvyx_6bLW"
   },
   "source": [
    "3. Finally, let's do model quantization. We will convert the model in the following mapping\n",
    "```python\n",
    "nn.Conv2d: QuantizedConv2d,\n",
    "nn.Linear: QuantizedLinear,\n",
    "# the following twos are just wrappers, as current\n",
    "# torch modules do not support int8 data format;\n",
    "# we will temporarily convert them to fp32 for computation\n",
    "nn.MaxPool2d: QuantizedMaxPool2d,\n",
    "nn.AvgPool2d: QuantizedAvgPool2d,\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "id": "iFD5W0H1Zban"
   },
   "outputs": [],
   "source": [
    "class QuantizedConv2d(nn.Module):\n",
    "    def __init__(self, weight, bias,\n",
    "                 input_zero_point, output_zero_point,\n",
    "                 input_scale, weight_scale, output_scale,\n",
    "                 stride, padding, dilation, groups,\n",
    "                 feature_bitwidth=8, weight_bitwidth=8):\n",
    "        super().__init__()\n",
    "        # current version Pytorch does not support IntTensor as nn.Parameter\n",
    "        self.register_buffer('weight', weight)\n",
    "        self.register_buffer('bias', bias)\n",
    "\n",
    "        self.input_zero_point = input_zero_point\n",
    "        self.output_zero_point = output_zero_point\n",
    "\n",
    "        self.input_scale = input_scale\n",
    "        self.register_buffer('weight_scale', weight_scale)\n",
    "        self.output_scale = output_scale\n",
    "\n",
    "        self.stride = stride\n",
    "        self.padding = (padding[1], padding[1], padding[0], padding[0])\n",
    "        self.dilation = dilation\n",
    "        self.groups = groups\n",
    "\n",
    "        self.feature_bitwidth = feature_bitwidth\n",
    "        self.weight_bitwidth = weight_bitwidth\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        return quantized_conv2d(\n",
    "            x, self.weight, self.bias,\n",
    "            self.feature_bitwidth, self.weight_bitwidth,\n",
    "            self.input_zero_point, self.output_zero_point,\n",
    "            self.input_scale, self.weight_scale, self.output_scale,\n",
    "            self.stride, self.padding, self.dilation, self.groups\n",
    "            )\n",
    "\n",
    "class QuantizedLinear(nn.Module):\n",
    "    def __init__(self, weight, bias,\n",
    "                 input_zero_point, output_zero_point,\n",
    "                 input_scale, weight_scale, output_scale,\n",
    "                 feature_bitwidth=8, weight_bitwidth=8):\n",
    "        super().__init__()\n",
    "        # current version Pytorch does not support IntTensor as nn.Parameter\n",
    "        self.register_buffer('weight', weight)\n",
    "        self.register_buffer('bias', bias)\n",
    "\n",
    "        self.input_zero_point = input_zero_point\n",
    "        self.output_zero_point = output_zero_point\n",
    "\n",
    "        self.input_scale = input_scale\n",
    "        self.register_buffer('weight_scale', weight_scale)\n",
    "        self.output_scale = output_scale\n",
    "\n",
    "        self.feature_bitwidth = feature_bitwidth\n",
    "        self.weight_bitwidth = weight_bitwidth\n",
    "\n",
    "    def forward(self, x):\n",
    "        return quantized_linear(\n",
    "            x, self.weight, self.bias,\n",
    "            self.feature_bitwidth, self.weight_bitwidth,\n",
    "            self.input_zero_point, self.output_zero_point,\n",
    "            self.input_scale, self.weight_scale, self.output_scale\n",
    "            )\n",
    "\n",
    "class QuantizedMaxPool2d(nn.MaxPool2d):\n",
    "    def forward(self, x):\n",
    "        # current version PyTorch does not support integer-based MaxPool\n",
    "        return super().forward(x.float()).to(torch.int8)\n",
    "\n",
    "class QuantizedAvgPool2d(nn.AvgPool2d):\n",
    "    def forward(self, x):\n",
    "        # current version PyTorch does not support integer-based AvgPool\n",
    "        return super().forward(x.float()).to(torch.int8)\n",
    "\n",
    "# we use int8 quantization, which is quite popular\n",
    "feature_bitwidth = weight_bitwidth = 8\n",
    "quantized_model = copy.deepcopy(model_fused)\n",
    "quantized_backbone = []\n",
    "ptr = 0\n",
    "while ptr < len(quantized_model.backbone):\n",
    "    if isinstance(quantized_model.backbone[ptr], nn.Conv2d) and \\\n",
    "        isinstance(quantized_model.backbone[ptr + 1], nn.ReLU):\n",
    "        conv = quantized_model.backbone[ptr]\n",
    "        conv_name = f'backbone.{ptr}'\n",
    "        relu = quantized_model.backbone[ptr + 1]\n",
    "        relu_name = f'backbone.{ptr + 1}'\n",
    "\n",
    "        input_scale, input_zero_point = \\\n",
    "            get_quantization_scale_and_zero_point(\n",
    "                input_activation[conv_name], feature_bitwidth)\n",
    "\n",
    "        output_scale, output_zero_point = \\\n",
    "            get_quantization_scale_and_zero_point(\n",
    "                output_activation[relu_name], feature_bitwidth)\n",
    "\n",
    "        quantized_weight, weight_scale, weight_zero_point = \\\n",
    "            linear_quantize_weight_per_channel(conv.weight.data, weight_bitwidth)\n",
    "        quantized_bias, bias_scale, bias_zero_point = \\\n",
    "            linear_quantize_bias_per_output_channel(\n",
    "                conv.bias.data, weight_scale, input_scale)\n",
    "        shifted_quantized_bias = \\\n",
    "            shift_quantized_conv2d_bias(quantized_bias, quantized_weight,\n",
    "                                        input_zero_point)\n",
    "\n",
    "        quantized_conv = QuantizedConv2d(\n",
    "            quantized_weight, shifted_quantized_bias,\n",
    "            input_zero_point, output_zero_point,\n",
    "            input_scale, weight_scale, output_scale,\n",
    "            conv.stride, conv.padding, conv.dilation, conv.groups,\n",
    "            feature_bitwidth=feature_bitwidth, weight_bitwidth=weight_bitwidth\n",
    "        )\n",
    "\n",
    "        quantized_backbone.append(quantized_conv)\n",
    "        ptr += 2\n",
    "    elif isinstance(quantized_model.backbone[ptr], nn.MaxPool2d):\n",
    "        quantized_backbone.append(QuantizedMaxPool2d(\n",
    "            kernel_size=quantized_model.backbone[ptr].kernel_size,\n",
    "            stride=quantized_model.backbone[ptr].stride\n",
    "            ))\n",
    "        ptr += 1\n",
    "    elif isinstance(quantized_model.backbone[ptr], nn.AvgPool2d):\n",
    "        quantized_backbone.append(QuantizedAvgPool2d(\n",
    "            kernel_size=quantized_model.backbone[ptr].kernel_size,\n",
    "            stride=quantized_model.backbone[ptr].stride\n",
    "            ))\n",
    "        ptr += 1\n",
    "    else:\n",
    "        raise NotImplementedError(type(quantized_model.backbone[ptr]))  # should not happen\n",
    "quantized_model.backbone = nn.Sequential(*quantized_backbone)\n",
    "\n",
    "# finally, quantized the classifier\n",
    "fc_name = 'classifier'\n",
    "fc = model.classifier\n",
    "input_scale, input_zero_point = \\\n",
    "    get_quantization_scale_and_zero_point(\n",
    "        input_activation[fc_name], feature_bitwidth)\n",
    "\n",
    "output_scale, output_zero_point = \\\n",
    "    get_quantization_scale_and_zero_point(\n",
    "        output_activation[fc_name], feature_bitwidth)\n",
    "\n",
    "quantized_weight, weight_scale, weight_zero_point = \\\n",
    "    linear_quantize_weight_per_channel(fc.weight.data, weight_bitwidth)\n",
    "quantized_bias, bias_scale, bias_zero_point = \\\n",
    "    linear_quantize_bias_per_output_channel(\n",
    "        fc.bias.data, weight_scale, input_scale)\n",
    "shifted_quantized_bias = \\\n",
    "    shift_quantized_linear_bias(quantized_bias, quantized_weight,\n",
    "                                input_zero_point)\n",
    "\n",
    "quantized_model.classifier = QuantizedLinear(\n",
    "    quantized_weight, shifted_quantized_bias,\n",
    "    input_zero_point, output_zero_point,\n",
    "    input_scale, weight_scale, output_scale,\n",
    "    feature_bitwidth=feature_bitwidth, weight_bitwidth=weight_bitwidth\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YIPgF84IygCy"
   },
   "source": [
    "The quantization process is done! Let's print and visualize the model architecture and also verify the accuracy of the quantized model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vGkf1sf27uFj"
   },
   "source": [
    "### Question 9.1 (5 pts)\n",
    "\n",
    "To run the quantized model, we need an extra preprocessing to map the input data from range (0, 1) into `int8` range of (-128, 127). Fill in the code below to finish the extra preprocessing.\n",
    "\n",
    "**Hint**: you should find that the quantized model has roughly the same accuracy as the `fp32` counterpart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "id": "PEZT47BE6dXe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VGG(\n",
      "  (backbone): Sequential(\n",
      "    (0): QuantizedConv2d()\n",
      "    (1): QuantizedConv2d()\n",
      "    (2): QuantizedMaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (3): QuantizedConv2d()\n",
      "    (4): QuantizedConv2d()\n",
      "    (5): QuantizedMaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (6): QuantizedConv2d()\n",
      "    (7): QuantizedConv2d()\n",
      "    (8): QuantizedMaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (9): QuantizedConv2d()\n",
      "    (10): QuantizedConv2d()\n",
      "    (11): QuantizedMaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (12): QuantizedAvgPool2d(kernel_size=2, stride=2, padding=0)\n",
      "  )\n",
      "  (classifier): QuantizedLinear()\n",
      ")\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "ascii": false,
       "bar_format": null,
       "colour": null,
       "elapsed": 0.016817092895507812,
       "initial": 0,
       "n": 0,
       "ncols": null,
       "nrows": null,
       "postfix": null,
       "prefix": "eval",
       "rate": null,
       "total": 157,
       "unit": "it",
       "unit_divisor": 1000,
       "unit_scale": false
      },
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "eval:   0%|          | 0/157 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int8 model has accuracy=92.95%\n"
     ]
    }
   ],
   "source": [
    "print(quantized_model)\n",
    "\n",
    "def extra_preprocess(x):\n",
    "    # hint: you need to convert the original fp32 input of range (0, 1)\n",
    "    #  into int8 format of range (-128, 127)\n",
    "    ############### YOUR CODE STARTS HERE ###############\n",
    "    return ((x*255)-128).clamp(-128, 127).to(torch.int8)\n",
    "    ############### YOUR CODE ENDS HERE #################\n",
    "\n",
    "int8_model_accuracy = evaluate(quantized_model, dataloader['test'],\n",
    "                               extra_preprocess=[extra_preprocess])\n",
    "print(f\"int8 model has accuracy={int8_model_accuracy:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "61iwKRAA8A7c"
   },
   "source": [
    "## Question 9.2 (Bonus Question; 5 pts)\n",
    "\n",
    "Explain why there is no ReLU layer in the linear quantized model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8Ewbt01T8F1b"
   },
   "source": [
    "**Your Answer:** relu for quantized and float is the same\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HhSnPZpD7ye9"
   },
   "source": [
    "# Question 10 (5 pts)\n",
    "\n",
    "Please compare the advantages and disadvantages of k-means-based quantization and linear quantization. You can discuss from the perspective of accuracy, latency, hardware support, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mhlf55UM73yA"
   },
   "source": [
    "**Your Answer:** the matmul in kmeans is still float, so the accuracy is more higher. Every time we will lookup to codebook, the latency is slower, hardware support is more difficult. Linear quantization will be more hardware-friendly.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xxOBqoXoSUfE"
   },
   "source": [
    "# Feedback"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ajqZJes3SVc-"
   },
   "source": [
    "Please fill out this [feedback form](https://forms.gle/ZeCH5anNPrkd5wpp7) when you finished this lab. We would love to hear your thoughts or feedback on how we can improve this lab!"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "2tFjnZZVlIFL"
   ],
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "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.8.10"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "00fff45b663b47369df4498d4dbb0ea6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "04a3d093af94471a82901728bd1d0047": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5145c0622cec4fcdb3fe8c9a9c1c67da",
      "max": 20,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_e49093574063476eb0d16fac9ea864ff",
      "value": 20
     }
    },
    "09826ccf4f764dffb3f50c4734d0bded": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0a4c9a04d46d419581fd6b161954be1e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "0b59c0019d1340509ff7e2510fdf0181": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0d9c4ad64a8443b7b7def8be9f3ef017": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "0fd1df941349405aafb60066b796534f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_e71c40534bdc45cc8ede15e5d6e881e5",
      "placeholder": "​",
      "style": "IPY_MODEL_44def100781e4ab3be646243af253093",
      "value": " 20/20 [00:01&lt;00:00, 11.96it/s]"
     }
    },
    "164eb1e49ed34274bc7ef0ae03458b58": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_2b68c2d8660f4d909b0ecca7f6ac1a9e",
      "placeholder": "​",
      "style": "IPY_MODEL_0b59c0019d1340509ff7e2510fdf0181",
      "value": " 0/20 [00:00&lt;?, ?it/s]"
     }
    },
    "24aa08087bef412cbf86c6dbfd0d915a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "2b68c2d8660f4d909b0ecca7f6ac1a9e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "36dfec77928d413ab3d729596017161d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7c2bd46c3e604bc18c80c37233c9e382",
      "max": 20,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_e1eb202eb1f048559f66a77c337043f1",
      "value": 0
     }
    },
    "3f17773aebf049389df462c92ab81d70": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "44def100781e4ab3be646243af253093": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "46892d7217234937a2075b54eb53b21c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_80e4fe9caf854c4f8f6b8dd84279a0bb",
       "IPY_MODEL_04a3d093af94471a82901728bd1d0047",
       "IPY_MODEL_b816947748334439a1ac9c4e4ec972a3"
      ],
      "layout": "IPY_MODEL_d2ca4d4575a547ef813bcf67d06731bc"
     }
    },
    "47119da651ee448d8b6f566c3c18c2e7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_9a534e2321da4e4396a1d44bd41b0ad7",
       "IPY_MODEL_36dfec77928d413ab3d729596017161d",
       "IPY_MODEL_164eb1e49ed34274bc7ef0ae03458b58"
      ],
      "layout": "IPY_MODEL_daa14d9ba26e48f4901cccf72f2d16a4"
     }
    },
    "4a29e42982444cc2a8940dce0f8ef9b7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5145c0622cec4fcdb3fe8c9a9c1c67da": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "514f462dd0d34b94b02a8d4ee73ecb65": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "5fdca8a8df304221a45a6506c5ddb963": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6073486b74c1496dba43786273d9eb4b": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "64b23fc20bcc49c6b58b091338eea1f7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6d142ac2daed41cbaddef18787a9e227": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "6fa2cbe32b924f2ab8a5a8b423899687": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7a6d74a3063341888db38747c6583672",
      "placeholder": "​",
      "style": "IPY_MODEL_514f462dd0d34b94b02a8d4ee73ecb65",
      "value": "eval:  95%"
     }
    },
    "7a6d74a3063341888db38747c6583672": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7c2bd46c3e604bc18c80c37233c9e382": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7c3c8d1a58c64b08b74eca64c372cf70": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "80e4fe9caf854c4f8f6b8dd84279a0bb": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_e7555fa29fea435ba06492262ea23025",
      "placeholder": "​",
      "style": "IPY_MODEL_3f17773aebf049389df462c92ab81d70",
      "value": "eval:  95%"
     }
    },
    "9277f4e283444aa1921624f8c91a607b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_4a29e42982444cc2a8940dce0f8ef9b7",
      "placeholder": "​",
      "style": "IPY_MODEL_e3b66716fb3c44149723c966cbd81a67",
      "value": "eval:  95%"
     }
    },
    "96697b08aaa648fcaf3325fb1fb3b453": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_c56e25f6842c4b34994a4f96ceea2199",
      "max": 20,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_0a4c9a04d46d419581fd6b161954be1e",
      "value": 20
     }
    },
    "9a534e2321da4e4396a1d44bd41b0ad7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_b75c51a35def4818b928867e6cfb7a3a",
      "placeholder": "​",
      "style": "IPY_MODEL_00fff45b663b47369df4498d4dbb0ea6",
      "value": "eval:   0%"
     }
    },
    "9c444234c59a42a08b6fe57e00314d4d": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "9d01e8022c65423da1b59ef12645dd0f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_9c444234c59a42a08b6fe57e00314d4d",
      "max": 20,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_bfe5f3e25f144841b0b9c1d76241bcc9",
      "value": 20
     }
    },
    "ab33092059dd460a910bcb069e22f476": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "ad5b6c560bf343ce868a93239cd70d90": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_6fa2cbe32b924f2ab8a5a8b423899687",
       "IPY_MODEL_bedc4a062c8f4a62adb77df58443f8fa",
       "IPY_MODEL_e703cd82e6aa4e88956521fa81c2cee5"
      ],
      "layout": "IPY_MODEL_d04ec8a340184537a00bc74915c6cf00"
     }
    },
    "b75c51a35def4818b928867e6cfb7a3a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b816947748334439a1ac9c4e4ec972a3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5fdca8a8df304221a45a6506c5ddb963",
      "placeholder": "​",
      "style": "IPY_MODEL_7c3c8d1a58c64b08b74eca64c372cf70",
      "value": " 19/20 [00:01&lt;00:00, 11.12it/s]"
     }
    },
    "bedc4a062c8f4a62adb77df58443f8fa": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_6073486b74c1496dba43786273d9eb4b",
      "max": 20,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_c37c77e092c04a6e8305b820ec9af947",
      "value": 20
     }
    },
    "bfe5f3e25f144841b0b9c1d76241bcc9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "c05cde7977e74584bc77d59b7c0ebd13": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_9277f4e283444aa1921624f8c91a607b",
       "IPY_MODEL_96697b08aaa648fcaf3325fb1fb3b453",
       "IPY_MODEL_cced96ac1d80461a818bfe8018afbd86"
      ],
      "layout": "IPY_MODEL_6d142ac2daed41cbaddef18787a9e227"
     }
    },
    "c210b5e033154f4aa7014afb9ea0961e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "c37c77e092c04a6e8305b820ec9af947": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "c56e25f6842c4b34994a4f96ceea2199": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "cced96ac1d80461a818bfe8018afbd86": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_c210b5e033154f4aa7014afb9ea0961e",
      "placeholder": "​",
      "style": "IPY_MODEL_24aa08087bef412cbf86c6dbfd0d915a",
      "value": " 19/20 [00:01&lt;00:00, 11.98it/s]"
     }
    },
    "d04ec8a340184537a00bc74915c6cf00": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "d2ca4d4575a547ef813bcf67d06731bc": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "daa14d9ba26e48f4901cccf72f2d16a4": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e1eb202eb1f048559f66a77c337043f1": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "e3b66716fb3c44149723c966cbd81a67": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "e49093574063476eb0d16fac9ea864ff": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "e703cd82e6aa4e88956521fa81c2cee5": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_64b23fc20bcc49c6b58b091338eea1f7",
      "placeholder": "​",
      "style": "IPY_MODEL_09826ccf4f764dffb3f50c4734d0bded",
      "value": " 19/20 [00:09&lt;00:00,  7.57it/s]"
     }
    },
    "e71c40534bdc45cc8ede15e5d6e881e5": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e7555fa29fea435ba06492262ea23025": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "ec371339d3034321849d60c736bc561a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0d9c4ad64a8443b7b7def8be9f3ef017",
      "placeholder": "​",
      "style": "IPY_MODEL_fe48396262e1440ba8ab08bc985f3082",
      "value": "eval: 100%"
     }
    },
    "fd30b2e812f64490b6187b1c1f05e16a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_ec371339d3034321849d60c736bc561a",
       "IPY_MODEL_9d01e8022c65423da1b59ef12645dd0f",
       "IPY_MODEL_0fd1df941349405aafb60066b796534f"
      ],
      "layout": "IPY_MODEL_ab33092059dd460a910bcb069e22f476"
     }
    },
    "fe48396262e1440ba8ab08bc985f3082": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}