quantize-demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- 这里是关于biac compensation方法的使用样例。您可以按照此样例将bias compensation应用于您的代码中，可以在完全不增加额外时间和空间复杂度的前提下，极大地降低量化层的输出误差，从而有效提升量化模型在低位宽量化条件下的任务性能。 -->\n",
    "Here is a demo of the bias compensation method. You can follow this example to apply bias compensation to your code. With no additional time and space complexity, it can greatly reduce the output error of the quantization layer, thereby effectively improving the task performance of the quantized model under low bit width quantization conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need to select a layer for quantization.\n",
    "Here, we select a layer of ViT-T model.\n",
    "In addition to selecting a layer of model, you can also choose blocks of model for compensation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import timm\n",
    "from torch import nn\n",
    "\n",
    "name = 'vit_tiny_patch16_224'\n",
    "vit = timm.create_model(name, pretrained=True)\n",
    "layer = vit.blocks[0].attn.qkv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we can apply quantizer and BC module to the layer.\n",
    "We utilize the quantization API to apply bias compensation to the quantized layer. \n",
    "The quantization API referenced form AutoQNN.\n",
    "If there is a post quantizer for the quantized layer, you can use the nn.Sequential module to combine the post quantizer and bias compensation module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(\n",
      "  in_features=192, out_features=576, bias=True\n",
      "  (quantized_weight_module): FixedPointQunatization()\n",
      "  (quantized_act0_post_module): BiasCompensation()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from bias_compensation.quantizers.BiasCompensation import BiasCompensation\n",
    "from bias_compensation.quantizers.fixedpointQ import FixedPointQunatization\n",
    "from bias_compensation.quantize.quantize import quantize_module_act,quantize_module_weight\n",
    "import copy\n",
    "\n",
    "layer = vit.blocks[0].attn.qkv # layer or block that you want to compensation for\n",
    "q_layer = copy.deepcopy(layer)\n",
    "channel_size = 576 # vector size for bc vector, which should be completely divided by match the output size\n",
    "channel_axis = (-1,) # the dims of output tensor\n",
    "# Obtain bc object, which is quantizer\n",
    "bc = BiasCompensation(channel_size=channel_size, channel_axis=channel_axis)\n",
    "quantizer = FixedPointQunatization(bitwidth=4)\n",
    "# Apply this quantizer to the layer output\n",
    "quantize_module_weight(q_layer,quantizer,'weight',PTQ=True)\n",
    "quantize_module_act(q_layer,bc,act_id=0,pre=False)\n",
    "print(q_layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3302728055.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_462/3302728055.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    import bias-compensation\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "import bias-compensation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f25d5a29510>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAD4CAYAAAAO9oqkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYzElEQVR4nO3df5RU5Z3n8fdnUGxRQATWUSB2zyyuYkJAehXxx6jMIMEkEkOiuBNaQ2RQOGsccwzqJuCvc3AOjok/RgY3HGGjIyqiqBgHUGKMi9I6vSAYhSiGRsROY8CMGEG/+0c9TQps6Oru6qrq7s/rnDp173Ofe+tbRVOfus+9dUsRgZmZdW5/UewCzMys+BwGZmbmMDAzM4eBmZnhMDAzM+CgYhfQUn369Iny8vJil2Fm1q688sorv4+Ivvu2t9swKC8vp7q6uthlmJm1K5Leaazdw0RmZuYwMDMzh4GZmdGOjxmYWcewa9cuamtr+fjjj4tdSodSVlZG//79Ofjgg3Pq7zAws6Kqra2le/fulJeXI6nY5XQIEUF9fT21tbVUVFTktI6HicysqD7++GN69+7tIMgjSfTu3btZe1sOAzMrOgdB/jX3NXUYmJmZjxmYWWkpn/ZUXre3ceZ5Tfbp0qULX/rSl/bMP/bYY2zcuJFZs2bx5JNPNvsxa2pqePfddxkzZkyz1y0Wh4FZvs3ome63F7cOy9mhhx5KTU3NXm0bN25s8fZqamqorq5uV2HQ5DCRpAGSnpO0TtJaSVem9hmSNkuqSbcxWetcK2mDpDcknZvVPjq1bZA0Lau9QtJLqX2BpK75fqJmZi21bds2xo4dy+DBgxk+fDirV68G4OWXX+bUU09l6NChjBgxgjfeeINPPvmEH//4xyxYsIAhQ4awYMGCIlefm1z2DHYDV0fEq5K6A69IWpqW3R4Rs7I7SxoEXAScCBwDLJN0XFp8N/B3QC2wStLiiFgH3Jq29aCk2cBE4J7WPjkzs1zs3LmTIUOGAFBRUcGiRYv2Wj59+nSGDh3KY489xrPPPsuECROoqanh+OOP51e/+hUHHXQQy5Yt47rrrmPhwoXceOONVFdXc9dddxXh2bRMk2EQEVuALWn6Q0mvA/0OsMr5wIMR8SfgbUkbgJPTsg0R8RaApAeB89P2zgEuTn3mATNwGJhZgTQ2TJTthRdeYOHChQCcc8451NfXs2PHDrZv305VVRXr169HErt27SpQxfnXrLOJJJUDQ4GXUtNUSaslzZXUK7X1AzZlrVab2vbX3hv4Q0Ts3qe9scefJKlaUnVdXV1zSjczy7sf/ehHnH322bz22ms88cQT7fpb1DmHgaTDgYXA9yNiB5lP7n8NDCGz53BbWxSYLSLmRERlRFT27fu5y3GbmbWJM844g/vvvx+AFStW0KdPH3r06MH27dvp1y/z2fW+++7b07979+58+OGHxSi1xXI6m0jSwWSC4P6IeBQgIrZmLb8XaDj/ajMwIGv1/qmN/bTXA0dIOijtHWT3N7NOJpdTQQttxowZfPe732Xw4MF069aNefPmAXDNNddQVVXFzTffzHnn/bnus88+m5kzZzJkyBCuvfZaLrzwwmKVnjNFxIE7ZL7GNg/YFhHfz2o/Oh1PQNJVwCkRcZGkE4EHyBwnOAZYDgwEBLwJjCTzZr8KuDgi1kp6GFiYdQB5dUT8y4HqqqysDP+4jZUkn1raLK+//jonnHBCscvokBp7bSW9EhGV+/bNZc/gNOA7wBpJNantOmC8pCFAABuBfwBIb+4PAevInIk0JSI+TUVMBZ4BugBzI2Jt2t4PgQcl3Qz8B/CzXJ+smZm1Xi5nE71A5lP9vpYcYJ1bgFsaaV/S2HrpDKOT9203M7PC8LWJzMzMYWBmZg4DMzPDYWBmZviqpWZWahpOzc3b9po+xbe2tpYpU6awbt06Pv30U8aMGcNtt93GIYcckrcyVqxYQdeuXRkxYgQAs2fPplu3bkyYMKFV2y0vL6e6upo+ffq0ajveMzCzTi0iuOCCCxg7dizr169n/fr17Ny5k2uuuSavj7NixQpefPHFPfOTJ09udRDkk/cMzKxTe/bZZykrK+PSSy8FMj90c/vtt3PssccycOBAfvOb3+y5+uhXv/pVfvCDH3DWWWdx+eWXs2rVKnbu3Mm4ceO44YYbgMwn9aqqKp544gl27drFww8/TFlZGbNnz6ZLly78/Oc/584772T58uUcfvjhXHzxxXv97sGaNWt466236NatG5MnT+Z3v/sdAD/5yU847bTTqK+vZ/z48WzevJlTTz2Vpr44nCvvGZhZp7Z27VqGDRu2V1uPHj0oLy9n9+7d+1kLbrnlFqqrq1m9ejW//OUv9/zGAUCfPn149dVXufzyy5k1axbl5eVMnjyZq666ipqaGs4444w9fY855hhqamqoqanhsssu45vf/CbHHnssV155JVdddRWrVq1i4cKFfO973wPghhtu4PTTT2ft2rV84xvf2BMWreU9AzOzFnjooYeYM2cOu3fvZsuWLaxbt47BgwcDcMEFFwAwbNgwHn300Zy29+tf/5p7772XF154AYBly5axbt26Pct37NjBH//4R55//vk92zzvvPPo1atXo9trLoeBmXVqgwYN4pFHHtmrbceOHbz33nv07t2bN998c097wyWq3377bWbNmsWqVavo1asXl1xyyV6Xr2448NylS5cD7l002LJlCxMnTmTx4sUcfvjhAHz22WesXLmSsrKyVj/HXHiYyMw6tZEjR/LRRx8xf/58AD799FOuvvpqpk6dSkVFBTU1NXz22Wds2rSJl19+GciExWGHHUbPnj3ZunUrTz/9dJOPs7/LWu/atYtvfetb3HrrrRx33HF72keNGsWdd965Z77hx3fOPPNMHnjgAQCefvppPvjggxY/92zeMzCz0lLgq71KYtGiRUyZMoWbbrqJuro6LrzwQq6//noigoqKCgYNGsQJJ5zASSedBMCXv/xlhg4dyvHHH8+AAQM47bTTmnycr33ta4wbN47HH398rzf5F198kerqaqZPn8706dMBWLJkCXfccQdTpkxh8ODB7N69mzPPPJPZs2czffp0xo8fz4knnsiIESP4whe+kJ/XIV9HogvNl7C2kuVLWDdLqV3C+sUXX2T8+PEsWrRoz5t/e5XvS1ibmXUaI0aM4J133il2GQXnYwZmZuYwMLPia6/D1aWsua+pw8DMiqqsrIz6+noHQh5FBPX19c06LdXHDMysqPr3709tbS11dXXFLqVDKSsro3///jn3dxiYWVEdfPDBVFRUFLuMTs/DRGZm5jAwMzOHgZmZ4TAwMzMcBmZmhsPAzMxwGJiZGQ4DMzPDYWBmZjgMzMwMh4GZmeEwMDMzcggDSQMkPSdpnaS1kq5M7UdKWippfbrvldol6Q5JGyStlnRS1raqUv/1kqqy2odJWpPWuUOS2uLJmplZ43LZM9gNXB0Rg4DhwBRJg4BpwPKIGAgsT/MAXwEGptsk4B7IhAcwHTgFOBmY3hAgqc9lWeuNbv1TMzOzXDUZBhGxJSJeTdMfAq8D/YDzgXmp2zxgbJo+H5gfGSuBIyQdDZwLLI2IbRHxAbAUGJ2W9YiIlZH5dYv5WdsyM7MCaNYxA0nlwFDgJeCoiNiSFr0HHJWm+wGbslarTW0Haq9tpN3MzAok5zCQdDiwEPh+ROzIXpY+0bf5b9ZJmiSpWlK1fxXJzCx/cgoDSQeTCYL7I+LR1Lw1DfGQ7t9P7ZuBAVmr909tB2rv30j750TEnIiojIjKvn375lK6mZnlIJeziQT8DHg9Iv45a9FioOGMoCrg8az2CemsouHA9jSc9AwwSlKvdOB4FPBMWrZD0vD0WBOytmVmZgWQy28gnwZ8B1gjqSa1XQfMBB6SNBF4B/h2WrYEGANsAD4CLgWIiG2SbgJWpX43RsS2NH0FcB9wKPB0upmZWYE0GQYR8QKwv/P+RzbSP4Ap+9nWXGBuI+3VwBebqsXMzNqGv4FsZmYOAzMzcxiYmRkOAzMzw2FgZmY4DMzMDIeBmZnhMDAzMxwGZmaGw8DMzHAYmJkZDgOz4pvRM3MzKyKHgZmZOQzMcuJP79bBOQzMzMxhYGZmDgMzM8NhYGZmOAzMzAyHgZmZ4TAwMzMcBmZmhsPAzMxwGJiZGQ4DMzPDYWBmZjgMzMwMh4GZmeEwMDMzHAZmZobDwMzMcBiYmRk5hIGkuZLel/RaVtsMSZsl1aTbmKxl10raIOkNSedmtY9ObRskTctqr5D0UmpfIKlrPp+gmZk1LZc9g/uA0Y203x4RQ9JtCYCkQcBFwIlpnX+R1EVSF+Bu4CvAIGB86gtwa9rWfwU+ACa25gmZmVnzNRkGEfE8sC3H7Z0PPBgRf4qIt4ENwMnptiEi3oqIT4AHgfMlCTgHeCStPw8Y27ynYGZmrdWaYwZTJa1Ow0i9Uls/YFNWn9rUtr/23sAfImL3Pu2NkjRJUrWk6rq6ulaUbmZm2VoaBvcAfw0MAbYAt+WroAOJiDkRURkRlX379i3EQ5qZdQoHtWSliNjaMC3pXuDJNLsZGJDVtX9qYz/t9cARkg5KewfZ/c3MrEBatGcg6eis2W8ADWcaLQYuknSIpApgIPAysAoYmM4c6krmIPPiiAjgOWBcWr8KeLwlNZmZWcs1uWcg6d+As4A+kmqB6cBZkoYAAWwE/gEgItZKeghYB+wGpkTEp2k7U4FngC7A3IhYmx7ih8CDkm4G/gP4Wb6enJmZ5abJMIiI8Y007/cNOyJuAW5ppH0JsKSR9rfInG1kZmZF4m8gm5mZw8DMzBwGZmaGw8DMzHAYmJkZDgMzM8NhYGZmOAzMzAyHgZmZ4TAwMzMcBmZmhsPAzMxwGJiZGQ4DMzPDYWBmZjgMzMwMh4GZmeEwMDMzHAZmZobDwMzMcBiYmRkOAzMzw2FgZmY4DMzMDIeBmZnhMDAzMxwGZmaGw8A6uxk9i12BWUlwGJi1JzN6OsCsTTgMzMzMYWBmZg4DMzMjhzCQNFfS+5Jey2o7UtJSSevTfa/ULkl3SNogabWkk7LWqUr910uqymofJmlNWucOScr3kzQzswPLZc/gPmD0Pm3TgOURMRBYnuYBvgIMTLdJwD2QCQ9gOnAKcDIwvSFAUp/Lstbb97HMzKyNNRkGEfE8sG2f5vOBeWl6HjA2q31+ZKwEjpB0NHAusDQitkXEB8BSYHRa1iMiVkZEAPOztmVmZgXS0mMGR0XEljT9HnBUmu4HbMrqV5vaDtRe20h7oyRNklQtqbqurq6FpZuZ2b5afQA5faKPPNSSy2PNiYjKiKjs27dvIR7SzKxTaGkYbE1DPKT791P7ZmBAVr/+qe1A7f0baTczswJqaRgsBhrOCKoCHs9qn5DOKhoObE/DSc8AoyT1SgeORwHPpGU7JA1PZxFNyNqWmZkVyEFNdZD0b8BZQB9JtWTOCpoJPCRpIvAO8O3UfQkwBtgAfARcChAR2yTdBKxK/W6MiIaD0leQOWPpUODpdDMzswJqMgwiYvx+Fo1spG8AU/aznbnA3Ebaq4EvNlWHmZm1HX8D2czMHAZmZuYwMDMzHAZmZobDwMzMcBiYmRkOAzMzw2FgZmY4DMzMDIeBmZnhMDAzMxwGZmaGw8DMzHAYmLWZ8mlPFbsEs5w5DMzMzGFgZmYOAzMzw2FgZmbk8LOXZta07IPFG8uKWIhZCzkMzNrQXiEx87wiVmJ2YB4mMjMzh4FZhzWjZ+ZmlgOHgXU8fgM0azaHgZmZ+QCyWaH4YLKVMoeBWQv52kPWkXiYyMzMHAZmZuYwMDMzHAZmZobDwMzMaGUYSNooaY2kGknVqe1ISUslrU/3vVK7JN0haYOk1ZJOytpOVeq/XlJV656SmZk1Vz5OLT07In6fNT8NWB4RMyVNS/M/BL4CDEy3U4B7gFMkHQlMByqBAF6RtDgiPshDbWZ5la/TSX2VUys1bTFMdD4wL03PA8Zmtc+PjJXAEZKOBs4FlkbEthQAS4HRbVCXmZntR2vDIIB/l/SKpEmp7aiI2JKm3wOOStP9gE1Z69amtv21f46kSZKqJVXX1dW1snQzM2vQ2mGi0yNis6T/AiyV9JvshRERkqKVj5G9vTnAHIDKysq8bdfMrLNr1Z5BRGxO9+8Di4CTga1p+Id0/37qvhkYkLV6/9S2v3azTsWXt7BianEYSDpMUveGaWAU8BqwGGg4I6gKeDxNLwYmpLOKhgPb03DSM8AoSb3SmUejUptZSfCbtHUGrRkmOgpYJKlhOw9ExC8krQIekjQReAf4duq/BBgDbAA+Ai4FiIhtkm4CVqV+N0bEtlbUZWZmzdTiMIiIt4AvN9JeD4xspD2AKfvZ1lxgbktrMTOz1vE3kM3MzGFgZmb+cRuzkuJfQ7NicRiYNcJnEFln42EiMzNzGFg7MaNn5mZtw69tp+dhIrPEQ0PWmTkMzEqUDyZbIXmYyMzMHAZmZuZhIrN2caygoUb/Kpq1Fe8ZmJmZ9wys8/HvD5t9nvcMzNqh8mlPtYvhLWs/HAZmZuYwMDMzHzMwa9f2HSryl9OspRwG1il4fN3swBwG1mF1xgDwmVLWUj5mYMXjK5GalQyHgZk1jwO8Q3IYWIfSMEzSGYeI9sevheXCxwys3fObXdN8OWxrivcMzMzMewZmnY33EqwxDgNrlzw0ZJZfDgNrVxwC+eXfSbAGDgPLr4bTDmdsb/Wm/AWqwvLwUefmA8hm1jaa86VCfwGx6LxnYLmZ0TMvn/Yb46Gf0uO9hM7HYWBmB/S5K6OWZdocEh2Lw8AKprE3FTMrDSUTBpJGAz8FugD/OyJmFrkkawUP/XR8Tf0bO+zbl5IIA0ldgLuBvwNqgVWSFkfEuuJWZvvyG4A1V5N/Mx5uKgklEQbAycCGiHgLQNKDwPmAw6ANtORTe8M4sVm+lU97as+HiNb8jTlUWkcRUewakDQOGB0R30vz3wFOiYip+/SbBExKs/8NeKMFD9cH+H0rym1LpVpbqdYFrq0lSrUucG0t0dy6jo2Ivvs2lsqeQU4iYg4wpzXbkFQdEZV5KimvSrW2Uq0LXFtLlGpd4NpaIl91lcqXzjYDA7Lm+6c2MzMrgFIJg1XAQEkVkroCFwGLi1yTmVmnURLDRBGxW9JU4Bkyp5bOjYi1bfRwrRpmamOlWlup1gWurSVKtS5wbS2Rl7pK4gCymZkVV6kME5mZWRE5DMzMrOOHgaQjJS2VtD7d9zpA3x6SaiXdVSq1STpW0quSaiStlTS5ROoaIun/pppWS7qwrevKtbbU7xeS/iDpyTauZ7SkNyRtkDStkeWHSFqQlr8kqbwt62lmbWemv63d6bs+BZNDbf8oaV3621ou6dgSqWuypDXp/+MLkgYVoq5casvq901JIal5p5tGRIe+Af8ETEvT04BbD9D3p8ADwF2lUhvQFTgkTR8ObASOKYG6jgMGpuljgC3AEaXwmqVlI4GvAU+2YS1dgN8Cf5X+nf4fMGifPlcAs9P0RcCCAv1t5VJbOTAYmA+MK0RdzajtbKBbmr68EK9bjnX1yJr+OvCLUnnNUr/uwPPASqCyOY/R4fcMyFzWYl6angeMbayTpGHAUcC/F6YsIIfaIuKTiPhTmj2EwuzN5VLXmxGxPk2/C7wPfO5bjcWoLdW0HPiwjWvZcxmViPgEaLiMSrbseh8BRkpSG9eVU20RsTEiVgOfFaCe5tb2XER8lGZXkvnuUSnUtSNr9jCgUGfg5PK3BnATcCvwcXMfoDOEwVERsSVNv0fmDX8vkv4CuA34QSELI4faACQNkLQa2ETmk/C7pVBXVn0nk/m08ts2rguaWVsb60fm36RBbWprtE9E7Aa2A71LpLZiaW5tE4Gn27SijJzqkjRF0m/J7KX+zwLUlVNtkk4CBkREiy7wVBLfM2gtScuAv2xk0fXZMxERkhpL8iuAJRFRm+8PbXmojYjYBAyWdAzwmKRHImJrsetK2zka+D9AVUTk5RNmvmqz9k/S3wOVwN8Uu5YGEXE3cLeki4H/BVQVuaSGD7T/DFzS0m10iDCIiL/d3zJJWyUdHRFb0hvX+410OxU4Q9IVZMblu0r6Y0Ts9yBNAWvL3ta7kl4DziAz5FDUuiT1AJ4Cro+Ila2pJ9+1FUgul1Fp6FMr6SCgJ1BfIrUVS061SfpbMh8A/iZrqLTodWV5ELinTSv6s6Zq6w58EViRPtD+JbBY0tcjojqXB+gMw0SL+XNyVwGP79shIv5HRHwhIsrJDBXNz0cQ5KM2Sf0lHZqmewGn07Krtea7rq7AIjKvVauCKd+1FVAul1HJrncc8GykI30lUFuxNFmbpKHAvwJfj4hCBX4udQ3Mmj0PWF8KtUXE9ojoExHl6X1sJZnXLqcgaNhIh76RGZ9dTuYfbRlwZGqvJPOLavv2v4TCnU3UZG1kfvBnNZmzB1YDk0qkrr8HdgE1WbchpVBbmv8VUAfsJDO+em4b1TMGeJPM8ZLrU9uN6T8iQBnwMLABeBn4q0L8beVY239Pr81/ktlbWVtCtS0Dtmb9bS0ukbp+CqxNNT0HnFgqr9k+fVfQzLOJfDkKMzPrFMNEZmbWBIeBmZk5DMzMzGFgZmY4DMzMDIeBmZnhMDAzM+D/A+n1S9o7UjRXAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "_ = plt.hist(layer.weight.data.cpu().flatten(),bins=100,label=\"Float\")\n",
    "_ = plt.hist(q_layer.weight.data.cpu().flatten(),bins=100,label=\"Quantized\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To set different quantizers for the quantized layer, you can follow the steps below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(\n",
      "  in_features=192, out_features=576, bias=True\n",
      "  (quantized_weight_module): Identity()\n",
      "  (quantized_act0_post_module): Identity()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "\n",
    "q_layer.quantized_weight_module = nn.Identity()\n",
    "q_layer.quantized_act0_post_module = nn.Identity()\n",
    "print(q_layer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To align the quantized and float layers using our BC approach, please follow these instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_layer.quantized_weight_module = quantizer\n",
    "q_layer.quantized_act0_post_module = bc\n",
    "calibra_data = torch.rand(1,1024,192)\n",
    "layer.eval()\n",
    "with torch.no_grad():\n",
    "    float_output = layer(calibra_data)\n",
    "    quantized_output = q_layer(calibra_data)\n",
    "    bc.update(float_output,quantized_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we evaluate the output error with and without BC to assess its impact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error without bc:  36148.8359375\n",
      "error with bc:  17170.2265625\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    quantized_output_bc = q_layer(calibra_data)\n",
    "error1 = torch.sum(torch.abs(float_output-quantized_output))\n",
    "error2 = torch.sum(torch.abs(float_output-quantized_output_bc))\n",
    "print(\"error without bc: \",error1.item())\n",
    "print(\"error with bc: \",error2.item())\n",
    "plt.bar([1],[error1.item()],width=0.2,label=\"w/o BC\")\n",
    "plt.bar([2],[error2.item()],width=0.2,label=\"w BC\")\n",
    "plt.plot([1.1,1.9],[error2.item(),error2.item()],'k--')\n",
    "plt.plot([1.1,1.15],[error1.item(),error1.item()],'k--')\n",
    "plt.annotate('', xy=(1.125, error1.item()), xytext=(1.125, error2.item()),\n",
    "             arrowprops=dict(arrowstyle='<-', linewidth=2, color='k'))\n",
    "plt.annotate(\"-%.2f%% Error\"%((error1.item()-error2.item())/error1.item()*100), xy=(1.15, (error1.item()+error2.item())/2),color='k')\n",
    "plt.annotate('%.2e'%(error1.item()), xy=(0.9, error1.item()*1.006),color='k')\n",
    "plt.annotate('%.2e'%(error2.item()), xy=(1.9, error2.item()*1.02),color='k')\n",
    "plt.legend()\n",
    "plt.ylabel(\"Output Error\")\n",
    "_ = plt.xticks([1,2],[\"w/o BC\",\"w BC\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}