train.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training an CNN in HAWQ \n",
    "This notebook has been modified to implement quantization aware training in HAWQ. \n",
    "\n",
    "Link to the original notebook [here]([url_here](https://github.com/julesmuhizi/pytorch_hls4ml/blob/master/MNIST_CNN.ipynb))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.datasets as dset\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import os\n",
    "from torchinfo import summary\n",
    "import tqdm.notebook as tqdm\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sn\n",
    "import pandas as pd\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hawq.utils.quantization_utils.quant_modules import QuantConv2d, QuantLinear, QuantAct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define Model in PyTorch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(\n",
    "            in_channels=1,              \n",
    "            out_channels=16,            \n",
    "            kernel_size=5,              \n",
    "            stride=1,                   \n",
    "            padding=2,\n",
    "        )\n",
    "        self.conv2 = nn.Conv2d(\n",
    "            in_channels=16, \n",
    "            out_channels=32, \n",
    "            kernel_size=5, \n",
    "            stride=1, \n",
    "            padding=2\n",
    "        )\n",
    "        \n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool = nn.MaxPool2d(kernel_size=2)\n",
    "        self.flatten = nn.Flatten(1,3)\n",
    "        \n",
    "        # fully connected layer, output 10 classes\n",
    "        self.out = nn.Linear(32 * 7 * 7, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool(x)\n",
    "\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool(x)\n",
    "\n",
    "        # flatten the output of conv2 to (batch_size, 32 * 7 * 7)\n",
    "        x = self.flatten(x)\n",
    "        output = self.out(x)\n",
    "        return output  # return x for visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "==========================================================================================\n",
       "Layer (type:depth-idx)                   Output Shape              Param #\n",
       "==========================================================================================\n",
       "CNN                                      [1, 10]                   --\n",
       "├─Conv2d: 1-1                            [1, 16, 28, 28]           416\n",
       "├─ReLU: 1-2                              [1, 16, 28, 28]           --\n",
       "├─MaxPool2d: 1-3                         [1, 16, 14, 14]           --\n",
       "├─Conv2d: 1-4                            [1, 32, 14, 14]           12,832\n",
       "├─ReLU: 1-5                              [1, 32, 14, 14]           --\n",
       "├─MaxPool2d: 1-6                         [1, 32, 7, 7]             --\n",
       "├─Flatten: 1-7                           [1, 1568]                 --\n",
       "├─Linear: 1-8                            [1, 10]                   15,690\n",
       "==========================================================================================\n",
       "Total params: 28,938\n",
       "Trainable params: 28,938\n",
       "Non-trainable params: 0\n",
       "Total mult-adds (M): 2.86\n",
       "==========================================================================================\n",
       "Input size (MB): 0.00\n",
       "Forward/backward pass size (MB): 0.15\n",
       "Params size (MB): 0.12\n",
       "Estimated Total Size (MB): 0.27\n",
       "=========================================================================================="
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = CNN()\n",
    "model = model.to(device)\n",
    "summary(model, input_size=(1,1,28,28)) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define Model in HAWQ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Q_CNN(nn.Module):\n",
    "    def __init__(self, model):\n",
    "        super(Q_CNN, self).__init__()\n",
    "        \n",
    "        self.quant_input = QuantAct(activation_bit=12) \n",
    "        self.q_relu_1 = QuantAct(activation_bit=8) \n",
    "        self.q_relu_2 = QuantAct(activation_bit=8) \n",
    "        \n",
    "        # create quantize Conv2d with parameters of the original layer \n",
    "        conv1 = getattr(model, \"conv1\")\n",
    "        q_conv1 = QuantConv2d(weight_bit=4, bias_bit=16) \n",
    "        q_conv1.set_param(conv1)\n",
    "        setattr(self, \"conv1\", q_conv1)\n",
    "\n",
    "        # create quantize Conv2d with parameters of the original layer \n",
    "        conv2 = getattr(model, \"conv2\")\n",
    "        q_conv2 = QuantConv2d(weight_bit=4, bias_bit=16) \n",
    "        q_conv2.set_param(conv2)\n",
    "        setattr(self, \"conv2\", q_conv2)\n",
    "        \n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool = nn.MaxPool2d(kernel_size=2)\n",
    "        self.flatten = nn.Flatten(1,3)\n",
    "        \n",
    "        # fully connected layer, output 10 classes\n",
    "        out = getattr(model, \"out\")\n",
    "        q_out = QuantLinear(weight_bit=4, bias_bit=4)\n",
    "        q_out.set_param(out)\n",
    "        setattr(self, \"out\", q_out)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        x, p_sf = self.quant_input(x)\n",
    "\n",
    "        x, w_sf = self.conv1(x, p_sf)\n",
    "        x = self.relu(x)\n",
    "        x, p_sf = self.q_relu_1(x, p_sf, w_sf)\n",
    "        x = self.max_pool(x)\n",
    "\n",
    "        x, w_sf = self.conv2(x, p_sf)\n",
    "        x = self.relu(x)\n",
    "        x, p_sf = self.q_relu_2(x, p_sf, w_sf)\n",
    "        x = self.max_pool(x)\n",
    "\n",
    "        # flatten the output of conv2 to (batch_size, 32 * 7 * 7)\n",
    "        x = self.flatten(x)\n",
    "        output = self.out(x, p_sf)\n",
    "        return output  # return x for visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Q_CNN(\n",
       "  (quant_input): QuantAct(activation_bit=12, full_precision_flag=False, quant_mode=symmetric, Act_min: 0.00, Act_max: 0.00)\n",
       "  (q_relu_1): QuantAct(activation_bit=8, full_precision_flag=False, quant_mode=symmetric, Act_min: 0.00, Act_max: 0.00)\n",
       "  (q_relu_2): QuantAct(activation_bit=8, full_precision_flag=False, quant_mode=symmetric, Act_min: 0.00, Act_max: 0.00)\n",
       "  (conv1): (QuantConv2d(\n",
       "    (conv): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "  ) weight_bit=4, full_precision_flag=False, quant_mode=symmetric)\n",
       "  (conv2): (QuantConv2d(\n",
       "    (conv): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "  ) weight_bit=4, full_precision_flag=False, quant_mode=symmetric)\n",
       "  (relu): ReLU()\n",
       "  (max_pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (flatten): Flatten(start_dim=1, end_dim=3)\n",
       "  (out): (QuantLinear() weight_bit=4, full_precision_flag=False, quantize_fn=symmetric)\n",
       ")"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Q_CNN(model)\n",
    "model.to(device)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup loss and optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup data loaders "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = '../datasets/mnist'\n",
    "if not os.path.exists(root):\n",
    "    os.mkdir(root)\n",
    "\n",
    "trans = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))])\n",
    "train_set = dset.MNIST(root=root, train=True, transform=trans, download=False)\n",
    "test_set = dset.MNIST(root=root, train=False, transform=trans, download=False)\n",
    "\n",
    "train_batch_size = 100\n",
    "test_batch_size = 1\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    dataset=train_set,\n",
    "    batch_size=train_batch_size,\n",
    "    shuffle=True\n",
    ")\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    dataset=test_set,\n",
    "    batch_size=test_batch_size,\n",
    "    shuffle=False\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7b46b445953243db970d6a873f6a2a7a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,   1] loss: 0.000\tacc.: 0.950\n",
      "[1, 101] loss: 0.004\tacc.: 0.975\n",
      "[1, 201] loss: 0.004\tacc.: 0.976\n",
      "[1, 301] loss: 0.004\tacc.: 0.976\n",
      "[1, 401] loss: 0.004\tacc.: 0.976\n",
      "[1, 501] loss: 0.004\tacc.: 0.977\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "59c1b20a376a4c90a83689cdd423d5c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2,   1] loss: 0.000\tacc.: 0.970\n",
      "[2, 101] loss: 0.004\tacc.: 0.977\n",
      "[2, 201] loss: 0.005\tacc.: 0.972\n",
      "[2, 301] loss: 0.004\tacc.: 0.979\n",
      "[2, 401] loss: 0.004\tacc.: 0.975\n",
      "[2, 501] loss: 0.004\tacc.: 0.979\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "728b029c823b4efd9769835471e9541f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3,   1] loss: 0.000\tacc.: 0.970\n",
      "[3, 101] loss: 0.004\tacc.: 0.975\n",
      "[3, 201] loss: 0.004\tacc.: 0.978\n",
      "[3, 301] loss: 0.004\tacc.: 0.978\n",
      "[3, 401] loss: 0.004\tacc.: 0.973\n",
      "[3, 501] loss: 0.004\tacc.: 0.977\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "42867620d10045f487d15ae526349435",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4,   1] loss: 0.000\tacc.: 0.970\n",
      "[4, 101] loss: 0.004\tacc.: 0.975\n",
      "[4, 201] loss: 0.004\tacc.: 0.976\n",
      "[4, 301] loss: 0.004\tacc.: 0.977\n",
      "[4, 401] loss: 0.004\tacc.: 0.977\n",
      "[4, 501] loss: 0.004\tacc.: 0.975\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d905d2d9a4c84fb98cc62c4d1a3b2993",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5,   1] loss: 0.000\tacc.: 1.000\n",
      "[5, 101] loss: 0.004\tacc.: 0.976\n",
      "[5, 201] loss: 0.004\tacc.: 0.976\n",
      "[5, 301] loss: 0.004\tacc.: 0.974\n",
      "[5, 401] loss: 0.004\tacc.: 0.976\n",
      "[5, 501] loss: 0.004\tacc.: 0.976\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6fe42e515a104e479dc7bab4d2c283ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6,   1] loss: 0.000\tacc.: 0.990\n",
      "[6, 101] loss: 0.004\tacc.: 0.975\n",
      "[6, 201] loss: 0.004\tacc.: 0.977\n",
      "[6, 301] loss: 0.004\tacc.: 0.974\n",
      "[6, 401] loss: 0.004\tacc.: 0.976\n",
      "[6, 501] loss: 0.004\tacc.: 0.977\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fbbb6dbe54264beeaf90f680394da646",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7,   1] loss: 0.000\tacc.: 0.970\n",
      "[7, 101] loss: 0.004\tacc.: 0.975\n",
      "[7, 201] loss: 0.004\tacc.: 0.978\n",
      "[7, 301] loss: 0.004\tacc.: 0.976\n",
      "[7, 401] loss: 0.004\tacc.: 0.977\n",
      "[7, 501] loss: 0.004\tacc.: 0.975\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2b03f2490634c608af70a2788118ee6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8,   1] loss: 0.000\tacc.: 0.950\n",
      "[8, 101] loss: 0.004\tacc.: 0.975\n",
      "[8, 201] loss: 0.004\tacc.: 0.978\n",
      "[8, 301] loss: 0.004\tacc.: 0.975\n",
      "[8, 401] loss: 0.004\tacc.: 0.973\n",
      "[8, 501] loss: 0.004\tacc.: 0.976\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ea71940761f453093e747b8d99de6dd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9,   1] loss: 0.000\tacc.: 0.980\n",
      "[9, 101] loss: 0.004\tacc.: 0.977\n",
      "[9, 201] loss: 0.004\tacc.: 0.977\n",
      "[9, 301] loss: 0.005\tacc.: 0.974\n",
      "[9, 401] loss: 0.004\tacc.: 0.974\n",
      "[9, 501] loss: 0.004\tacc.: 0.975\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "96d2d9ed9b9348a1a7bc4ce3f762ec7d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/600 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10,   1] loss: 0.000\tacc.: 0.990\n",
      "[10, 101] loss: 0.004\tacc.: 0.977\n",
      "[10, 201] loss: 0.004\tacc.: 0.977\n",
      "[10, 301] loss: 0.004\tacc.: 0.974\n",
      "[10, 401] loss: 0.004\tacc.: 0.978\n",
      "[10, 501] loss: 0.004\tacc.: 0.973\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "PATH = 'checkpoints/mnist_q_cnn.pth'\n",
    "TRAIN = not os.path.isfile(PATH)\n",
    "\n",
    "if TRAIN:\n",
    "    os.makedirs('checkpoints', exist_ok=1)\n",
    "    for epoch in range(10):  # loop over the dataset multiple times\n",
    "        running_loss = 0.0\n",
    "        correct, total = 0, 0\n",
    "        for i, data in tqdm.tqdm(enumerate(train_loader, 0), total = len(train_loader)):\n",
    "            # get the inputs; data is a list of [inputs, labels]\n",
    "            inputs, labels = data\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "            # zero the parameter gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # forward + backward + optimize\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            correct += (torch.argmax(outputs, dim=1) == labels).type(torch.int8).sum()\n",
    "            total += len(labels)\n",
    "            # print statistics\n",
    "            if i % 100 == 0:    # print every 100 mini-batches\n",
    "                print(f'[{epoch + 1}, {i + 1:3d}] loss: {running_loss / 2000:.3f}\\tacc.: {correct/total:.3f}')\n",
    "                running_loss = 0.0\n",
    "                correct, total = 0, 0\n",
    "\n",
    "    save_model = model.to('cpu')\n",
    "    torch.save(save_model, PATH)\n",
    "    print('Finished Training')\n",
    "else:\n",
    "    model = torch.load(PATH)\n",
    "\n",
    "model = model.to(device)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 97 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "y_true = []\n",
    "y_pred = []\n",
    "# since we're not training, we don't need to calculate the gradients for our outputs\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        images, labels = data\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        # calculate outputs by running images through the network\n",
    "        outputs = model(images)\n",
    "        # the class with the highest energy is what we choose as prediction\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        y_true.append(labels.cpu().numpy())\n",
    "        y_pred.append(predicted.cpu().numpy())\n",
    "\n",
    "print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "confusion_mtx = confusion_matrix(y_true, y_pred)\n",
    "df_cm = pd.DataFrame(confusion_mtx, range(len(confusion_mtx)), range(len(confusion_mtx)))\n",
    "# plt.figure(figsize=(10,7))\n",
    "sn.set(font_scale=1) # for label size\n",
    "sn.heatmap(df_cm, annot=True, cmap=\"Blues\", annot_kws={\"size\": 5}) # font size\n",
    "plt.title(\"Pyotrch Model Confusion Matrix\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Export to QONNX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hawq.utils.export import ExportManager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exporting model...\n",
      "Optimizing...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of hawq2qonnx::Quant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model saved to: checkpoints/cnn.onnx\n"
     ]
    }
   ],
   "source": [
    "manager = ExportManager(model)\n",
    "manager.export(torch.randn([1,1,28,28]), \"checkpoints/cnn.onnx\") "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualize QONNX Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import netron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Serving 'checkpoints/cnn.onnx' at http://localhost:8081\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('localhost', 8081)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "netron.start(\"checkpoints/cnn.onnx\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convert Model to HLS "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hls4ml\n",
    "from qonnx.core.modelwrapper import ModelWrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "onnx_model = ModelWrapper(\"checkpoints/cnn.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interpreting Model ...\n",
      "Output layers:  ['Mul_2']\n",
      "Input shape: [None, 1, 28, 28]\n",
      "Topology:\n",
      "Layer name: Quant_0, layer type: Quant, current shape: [[16, 5, 5, 1]]\n",
      "Layer name: Quant_1, layer type: Quant, current shape: [[32, 5, 5, 16]]\n",
      "Layer name: Quant_2, layer type: Quant, current shape: [[1568, 10]]\n",
      "Layer name: Quant_3, layer type: Quant, current shape: [[10]]\n",
      "Layer name: Transpose_0, layer type: Transpose, current shape: [[1568, 10]]\n",
      "Layer name: Div_0, layer type: Merge, current shape: [[1, 28, 28, 1]]\n",
      "Layer name: Conv_0, layer type: Conv, current shape: [[1, 28, 28, 1], [16, 5, 5, 1]]\n",
      "Layer name: Mul_0, layer type: Merge, current shape: [[1, 28, 28, 16]]\n",
      "Layer name: Relu_0, layer type: Activation, current shape: [[1, 28, 28, 16]]\n",
      "Layer name: MaxPool_0, layer type: MaxPooling2D, current shape: [[1, 28, 28, 16]]\n",
      "Layer name: Div_1, layer type: Merge, current shape: [[1, 14, 14, 16]]\n",
      "Layer name: Conv_1, layer type: Conv, current shape: [[1, 14, 14, 16], [32, 5, 5, 16]]\n",
      "Layer name: Mul_1, layer type: Merge, current shape: [[1, 14, 14, 32]]\n",
      "Layer name: Relu_1, layer type: Activation, current shape: [[1, 14, 14, 32]]\n",
      "Layer name: MaxPool_1, layer type: MaxPooling2D, current shape: [[1, 14, 14, 32]]\n",
      "Layer name: Transpose_1, layer type: Transpose, current shape: [[1, 7, 7, 32]]\n",
      "Layer name: Flatten_0, layer type: Reshape, current shape: [[1, 32, 7, 7]]\n",
      "Layer name: Div_2, layer type: Merge, current shape: [[1, 1568]]\n",
      "Layer name: MatMul_0, layer type: MatMul, current shape: [[1, 1568], [1568, 10]]\n",
      "Layer name: Add_0, layer type: Merge, current shape: [[1, 10], [10]]\n",
      "Layer name: Mul_2, layer type: Merge, current shape: [[1, 10]]\n",
      "Creating HLS model\n",
      "WARNING: Cannot use \"Latency\" model strategy for Conv2D_Conv_0 layer. Switching to \"Resource\" strategy.\n",
      "Writing HLS project\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "model_name = \"checkpoints/cnn.onnx\"\n",
    "\n",
    "config = hls4ml.utils.config_from_onnx_model(model_name, granularity='model')\n",
    "hls_model = hls4ml.converters.convert_from_onnx_model(model_name, hls_config=config)\n",
    "hls_model.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "hawq-env",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "89cb113a68cf14a73f12d4255aa79f45215601e5c33515e01fafc14720bd49e0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}