quantization_resnet_cifar100-r2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "65b5a174",
   "metadata": {},
   "source": [
    "# Resnet18 CIFAR-10\n",
    "\n",
    "Quantize train resnet18 without PACT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3cdfa9b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "NOQUANT_TRAIN = False\n",
    "n_epochs = 200\n",
    "batches = 256\n",
    "device = 'cuda:1'\n",
    "mixup = True\n",
    "MOD=\"resnet20\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e95ac49f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import os\n",
    "import shutil\n",
    "import time\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "#import network.resnet_orig as resnet\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torch.utils.data.sampler import SubsetRandomSampler, RandomSampler, SequentialSampler\n",
    "from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, CosineAnnealingLR, ReduceLROnPlateau\n",
    "\n",
    "DATA_DIR = \"cifar100/\"\n",
    "print_freq = 50\n",
    "\n",
    "# vit imsize\n",
    "imsize = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "91238a6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_id</th>\n",
       "      <th>fine_label_names</th>\n",
       "      <th>fine_labels</th>\n",
       "      <th>coarse_label_names</th>\n",
       "      <th>coarse_labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>19_11_100000.jpg</td>\n",
       "      <td>cattle</td>\n",
       "      <td>19</td>\n",
       "      <td>large_omnivores_and_herbivores</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>29_15_100001.jpg</td>\n",
       "      <td>dinosaur</td>\n",
       "      <td>29</td>\n",
       "      <td>reptiles</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0_4_100002.jpg</td>\n",
       "      <td>apple</td>\n",
       "      <td>0</td>\n",
       "      <td>fruit_and_vegetables</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11_14_100003.jpg</td>\n",
       "      <td>boy</td>\n",
       "      <td>11</td>\n",
       "      <td>people</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1_1_100004.jpg</td>\n",
       "      <td>aquarium_fish</td>\n",
       "      <td>1</td>\n",
       "      <td>fish</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49995</th>\n",
       "      <td>80_16_149995.jpg</td>\n",
       "      <td>squirrel</td>\n",
       "      <td>80</td>\n",
       "      <td>small_mammals</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49996</th>\n",
       "      <td>7_7_149996.jpg</td>\n",
       "      <td>beetle</td>\n",
       "      <td>7</td>\n",
       "      <td>insects</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49997</th>\n",
       "      <td>3_8_149997.jpg</td>\n",
       "      <td>bear</td>\n",
       "      <td>3</td>\n",
       "      <td>large_carnivores</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49998</th>\n",
       "      <td>7_7_149998.jpg</td>\n",
       "      <td>beetle</td>\n",
       "      <td>7</td>\n",
       "      <td>insects</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49999</th>\n",
       "      <td>73_1_149999.jpg</td>\n",
       "      <td>shark</td>\n",
       "      <td>73</td>\n",
       "      <td>fish</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>50000 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               image_id fine_label_names  fine_labels  \\\n",
       "0      19_11_100000.jpg           cattle           19   \n",
       "1      29_15_100001.jpg         dinosaur           29   \n",
       "2        0_4_100002.jpg            apple            0   \n",
       "3      11_14_100003.jpg              boy           11   \n",
       "4        1_1_100004.jpg    aquarium_fish            1   \n",
       "...                 ...              ...          ...   \n",
       "49995  80_16_149995.jpg         squirrel           80   \n",
       "49996    7_7_149996.jpg           beetle            7   \n",
       "49997    3_8_149997.jpg             bear            3   \n",
       "49998    7_7_149998.jpg           beetle            7   \n",
       "49999   73_1_149999.jpg            shark           73   \n",
       "\n",
       "                   coarse_label_names  coarse_labels  \n",
       "0      large_omnivores_and_herbivores             11  \n",
       "1                            reptiles             15  \n",
       "2                fruit_and_vegetables              4  \n",
       "3                              people             14  \n",
       "4                                fish              1  \n",
       "...                               ...            ...  \n",
       "49995                   small_mammals             16  \n",
       "49996                         insects              7  \n",
       "49997                large_carnivores              8  \n",
       "49998                         insects              7  \n",
       "49999                            fish              1  \n",
       "\n",
       "[50000 rows x 5 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# prepare labels\n",
    "train_df = pd.read_csv(\"cifar100/train.csv\")\n",
    "val_df = pd.read_csv(\"cifar100/test.csv\")\n",
    "train_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "44be87f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class cifarDataset(Dataset):\n",
    "    def __init__(self,\n",
    "                 df,\n",
    "                 rand=False,\n",
    "                 transform=None,\n",
    "                 test=False\n",
    "                ):\n",
    "\n",
    "        self.df = df.reset_index(drop=True)\n",
    "        self.rand = rand\n",
    "        self.transform = transform\n",
    "        self.test = test\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.df.shape[0]\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        row = self.df.iloc[index]\n",
    "        img_id = row.image_id\n",
    "        \n",
    "        images = cv2.imread(os.path.join(DATA_DIR, img_id))\n",
    "        \n",
    "        # Load labels\n",
    "        label = row.fine_labels\n",
    "        \n",
    "        # aug\n",
    "        if self.transform is not None:\n",
    "            images = self.transform(image=images)['image']\n",
    "              \n",
    "        #images = images.astype(np.float32)\n",
    "        #images /= 255\n",
    "        images = images.transpose(2, 0, 1)\n",
    "        \n",
    "        label = label.astype(np.float32)\n",
    "        #label2 = label2.astype(np.float32)\n",
    "        return torch.tensor(images), torch.tensor(label),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cd5517a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ken/anaconda3/envs/pytorch/lib/python3.8/site-packages/albumentations/augmentations/dropout/cutout.py:49: FutureWarning: Cutout has been deprecated. Please use CoarseDropout\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import albumentations as A\n",
    "import albumentations\n",
    "\n",
    "transforms_train = albumentations.Compose([\n",
    "    albumentations.ShiftScaleRotate(scale_limit=0.3, rotate_limit=180,p=0.5),\n",
    "    A.Cutout(num_holes=12, max_h_size=4, max_w_size=4, fill_value=0, p=0.5),\n",
    "    albumentations.HorizontalFlip(p=0.5),   \n",
    "    albumentations.Resize(imsize, imsize, p=1.0), \n",
    "    albumentations.Normalize(mean=(0.485, 0.456, 0.406),\n",
    "                       std=(0.229, 0.224, 0.225), p=1),\n",
    "])\n",
    "\n",
    "transforms_val = albumentations.Compose([albumentations.Resize(imsize, imsize, p=1.0),\n",
    "                                         albumentations.Normalize(mean=(0.485, 0.456, 0.406),\n",
    "                       std=(0.229, 0.224, 0.225), p=1),])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e3726718",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x1000 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x1000 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x1000 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset_show = cifarDataset(train_df, transform=transforms_train)\n",
    "from pylab import rcParams\n",
    "rcParams['figure.figsize'] = 20,10\n",
    "for i in range(3):\n",
    "    f, axarr = plt.subplots(1,5)\n",
    "    for p in range(5):\n",
    "        idx = np.random.randint(0, len(dataset_show))\n",
    "        img, label = dataset_show[idx]\n",
    "        img = img.flip(0) #BGR2RGB\n",
    "        axarr[p].imshow(img.transpose(0,1).transpose(1,2))\n",
    "        axarr[p].set_title(str(label))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "be374443",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mixup import mixup, mixup_cross_entropy_loss\n",
    "\n",
    "\n",
    "def train(train_loader, model, optimizer, epoch):\n",
    "    \"\"\"\n",
    "        Run one train epoch\n",
    "    \"\"\"\n",
    "    criterion = mixup_cross_entropy_loss\n",
    "    batch_time = AverageMeter()\n",
    "    data_time = AverageMeter()\n",
    "    losses = AverageMeter()\n",
    "    top1 = AverageMeter()\n",
    "\n",
    "    # switch to train mode\n",
    "    model.train()\n",
    "\n",
    "    end = time.time()\n",
    "    lambda_alpha = 0.002\n",
    "    for i, (input, target) in enumerate(tqdm(train_loader)):\n",
    "\n",
    "        # measure data loading time\n",
    "        data_time.update(time.time() - end)\n",
    "\n",
    "        if not mixup:\n",
    "          alpha = 0\n",
    "        else:\n",
    "          alpha = 1\n",
    "          input_var, target_var = mixup(input, target.long(), 100)\n",
    "        \n",
    "        input_var = input_var.to(device)\n",
    "        target_var = target_var.to(device)\n",
    "\n",
    "        # compute output\n",
    "        output = model(input_var)\n",
    "        loss = criterion(output, target_var)\n",
    "\n",
    "        # L2 regularization\n",
    "        l2_alpha = 0.0\n",
    "        for name, param in model.named_parameters():\n",
    "            if \"alpha\" in name:\n",
    "                l2_alpha += torch.pow(param, 2)\n",
    "        loss += lambda_alpha * l2_alpha\n",
    "\n",
    "        # compute gradient and do SGD step\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        output = output.float()\n",
    "        loss = loss.float()\n",
    "        # measure accuracy and record loss\n",
    "        losses.update(loss.item(), input.size(0))\n",
    "        top1 = 0\n",
    "\n",
    "        # measure elapsed time\n",
    "        batch_time.update(time.time() - end)\n",
    "        end = time.time()\n",
    "\n",
    "    return losses.avg\n",
    "\n",
    "def validate(val_loader, model):\n",
    "    \"\"\"\n",
    "    Run evaluation\n",
    "    \"\"\"\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    batch_time = AverageMeter()\n",
    "    losses = AverageMeter()\n",
    "    top1 = AverageMeter()\n",
    "\n",
    "    # switch to evaluate mode\n",
    "    model.eval()\n",
    "\n",
    "    end = time.time()\n",
    "    with torch.no_grad():\n",
    "        for i, (input, target) in enumerate(val_loader):\n",
    "            target = target.long().to(device)\n",
    "            input_var = input.to(device)\n",
    "            target_var = target.to(device)\n",
    "\n",
    "            # compute output\n",
    "            output = model(input_var)\n",
    "            loss = criterion(output, target_var)\n",
    "\n",
    "            output = output.float()\n",
    "            loss = loss.float()\n",
    "\n",
    "            # measure accuracy and record loss\n",
    "            prec1 = accuracy(output.data, target)[0]\n",
    "            losses.update(loss.item(), input.size(0))\n",
    "            top1.update(prec1.item(), input.size(0))\n",
    "\n",
    "            # measure elapsed time\n",
    "            batch_time.update(time.time() - end)\n",
    "            end = time.time()\n",
    "\n",
    "            if i % print_freq == 0:\n",
    "                print('Test: [{0}/{1}]\\t'\n",
    "                      'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n",
    "                      'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n",
    "                      'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(\n",
    "                          i, len(val_loader), batch_time=batch_time, loss=losses,\n",
    "                          top1=top1))\n",
    "\n",
    "    print(' * Prec@1 {top1.avg:.3f}'\n",
    "          .format(top1=top1))\n",
    "    for name, param in model.named_parameters():\n",
    "        if \"alpha\" in name:\n",
    "            print(name, param.item())\n",
    "    return top1.avg, losses.avg\n",
    "\n",
    "def save_checkpoint(state, filename='checkpoint.pth'):\n",
    "    \"\"\"\n",
    "    Save the training model\n",
    "    \"\"\"\n",
    "    torch.save(state, filename)\n",
    "\n",
    "class AverageMeter(object):\n",
    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.val = 0\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.count = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.val = val\n",
    "        self.sum += val * n\n",
    "        self.count += n\n",
    "        self.avg = self.sum / self.count\n",
    "\n",
    "\n",
    "def accuracy(output, target, topk=(1,)):\n",
    "    \"\"\"Computes the precision@k for the specified values of k\"\"\"\n",
    "    maxk = max(topk)\n",
    "    batch_size = target.size(0)\n",
    "\n",
    "    _, pred = output.topk(maxk, 1, True, True)\n",
    "    pred = pred.t()\n",
    "    correct = pred.eq(target.view(1, -1).expand_as(pred))\n",
    "\n",
    "    res = []\n",
    "    for k in topk:\n",
    "        correct_k = correct[:k].view(-1).float().sum(0)\n",
    "        res.append(correct_k.mul_(100.0 / batch_size))\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6f005fd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = cifarDataset(train_df, transform=transforms_train)\n",
    "val_dataset = cifarDataset(val_df, transform=transforms_val, test=True)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "        train_dataset,\n",
    "        batch_size=batches, shuffle=True,\n",
    "        num_workers=8, pin_memory=True)\n",
    "\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    val_dataset,\n",
    "    batch_size=batches, shuffle=False,\n",
    "    num_workers=8, pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a4256dce",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.nn.init as init\n",
    "from torch.autograd import Variable\n",
    "from pact_utils import QuantizedLinear, QuantizedConv2d, PGConv2d\n",
    "\n",
    "\n",
    "def _weights_init(m):\n",
    "    classname = m.__class__.__name__\n",
    "    #print(classname)\n",
    "    if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):\n",
    "        init.kaiming_normal_(m.weight)\n",
    "\n",
    "class LambdaLayer(nn.Module):\n",
    "    def __init__(self, lambd):\n",
    "        super(LambdaLayer, self).__init__()\n",
    "        self.lambd = lambd\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.lambd(x)\n",
    "\n",
    "\n",
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, in_planes, planes, stride=1, k=8, expansion=1):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.k = k\n",
    "        self.expansion = expansion\n",
    "        self.conv1 = QuantizedConv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False, wbits=k, abits=k)\n",
    "        self.bn1 = nn.BatchNorm2d(planes)\n",
    "        # self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)\n",
    "        self.conv2 = QuantizedConv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False, wbits=k, abits=k)\n",
    "        self.bn2 = nn.BatchNorm2d(planes)\n",
    "        \n",
    "        if stride != 1 or in_planes != planes:\n",
    "              # original resnet shortcut\n",
    "              self.shortcut = nn.Sequential(\n",
    "                    # nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),\n",
    "                    QuantizedConv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False, wbits=k, abits=k),\n",
    "                    nn.BatchNorm2d(self.expansion * planes)\n",
    "              )\n",
    "        else: # nothing done if stride or inplanes do not differ\n",
    "          self.shortcut = nn.Sequential()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Relu is implemented as the input of conv2d\n",
    "        out = self.bn1(self.conv1(x))\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        out += self.shortcut(x)\n",
    "        out = F.relu(out)\n",
    "        return out\n",
    "\n",
    "\n",
    "class ResNet(nn.Module):\n",
    "    def __init__(self, block, num_blocks, num_classes=10, K=8):\n",
    "        super(ResNet, self).__init__()\n",
    "        self.in_planes = 64\n",
    "        self.k = K\n",
    "\n",
    "        self.conv1 = QuantizedConv2d(3, self.in_planes, kernel_size=3, stride=2, padding=1, bias=False, abits=8, wbits=8)\n",
    "        self.bn1 = nn.BatchNorm2d(self.in_planes)\n",
    "        self.alpha1 = nn.Parameter(torch.tensor(10.))\n",
    "        self.layer1 = self._make_layer(block, self.in_planes, num_blocks[0], stride=1, expansion=1)\n",
    "        self.layer2 = self._make_layer(block, self.in_planes*2, num_blocks[1], stride=2, expansion=1)\n",
    "        self.layer3 = self._make_layer(block, self.in_planes*2, num_blocks[2], stride=2, expansion=1)\n",
    "        self.layer4 = self._make_layer(block, self.in_planes*2, num_blocks[3], stride=2, expansion=1)\n",
    "\n",
    "        # self.linear = nn.Linear(64, num_classes)\n",
    "        self.linear = QuantizedLinear(self.in_planes, num_classes, abits=8, wbits=8)\n",
    "        self.apply(_weights_init)\n",
    "\n",
    "    def _make_layer(self, block, planes, num_blocks, stride, expansion):\n",
    "        strides = [stride] + [1]*(num_blocks-1)\n",
    "        layers = []\n",
    "        for stride in strides:\n",
    "            layers.append(block(self.in_planes, planes, stride, self.k, expansion))\n",
    "            self.in_planes = planes * block.expansion\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.bn1(self.conv1(x))\n",
    "        out = self.layer1(out)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        out = F.avg_pool2d(out, out.size()[3])\n",
    "        out = out.view(out.size(0), -1)\n",
    "        out = self.linear(out)\n",
    "        return out\n",
    "\n",
    "\n",
    "def resnet20(k=8):\n",
    "    print(\"bit width:\", k)\n",
    "    return ResNet(BasicBlock, [2, 2, 2, 2], K=k, num_classes=100)\n",
    "\n",
    "def resnet34(k=8):\n",
    "    print(\"bit width:\", k)\n",
    "    return ResNet(BasicBlock, [3, 4, 6, 3], K=k, num_classes=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "632f4e34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bit width: 8\n"
     ]
    }
   ],
   "source": [
    "net = resnet34(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "76268eda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0159,  0.3546, -0.5996,  2.8976, -2.3060, -1.0759, -0.4536,  1.3452,\n",
       "          1.4652, -1.7920, -1.8578,  0.6756,  0.2365,  0.7441, -1.1130,  1.8619,\n",
       "          1.4152, -0.2634,  2.9825,  3.5565, -2.3010, -0.0703,  1.0645, -2.0988,\n",
       "          1.8941, -1.9906,  1.3196, -1.0971, -2.4036, -1.0500, -1.9198, -0.4214,\n",
       "         -1.4188,  2.2801,  0.1816, -0.4762, -0.9053,  0.5614,  2.2353, -0.5695,\n",
       "          1.4704,  1.4688,  2.0324,  0.1263,  0.3110, -0.3370, -1.1871, -1.7126,\n",
       "         -1.1904,  2.2904,  4.2009,  0.3003,  0.5266, -0.2807,  1.3967, -0.0183,\n",
       "          0.2886, -1.4284,  1.0670,  1.5692,  2.8755,  0.7976, -3.1318,  1.7201,\n",
       "          0.2512, -0.8450,  0.3114, -1.3992, -0.3382, -0.8127,  0.5142, -0.5438,\n",
       "         -0.3835, -1.3268,  0.8579,  1.1396, -2.7219,  0.2730,  1.8145, -1.1032,\n",
       "         -0.1438,  0.6996,  0.5833, -1.9055, -0.3930, -0.1512,  1.5144, -1.0265,\n",
       "         -2.3549, -0.8149, -0.0886, -0.0648,  2.5307, -1.7056,  2.4634, -1.2333,\n",
       "         -1.1255,  0.8484,  1.1963,  2.5939]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.forward(torch.rand(1,3,32,32))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3f38958",
   "metadata": {},
   "source": [
    "# Train with quantization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf661401",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bit width: 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33marutema47\u001b[0m (\u001b[33mkeio-csg\u001b[0m). Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "wandb version 0.14.0 is available!  To upgrade, please run:\n",
       " $ pip install wandb --upgrade"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Tracking run with wandb version 0.13.9"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Run data is saved locally in <code>/home/ken/quantize_models_sandbox/wandb/run-20230329_112937-b0po5229</code>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "Syncing run <strong><a href=\"https://wandb.ai/keio-csg/quantize_resnet_cifar100/runs/b0po5229\" target=\"_blank\">resnet20_quantize_k6_cifar100_original_mixup</a></strong> to <a href=\"https://wandb.ai/keio-csg/quantize_resnet_cifar100\" target=\"_blank\">Weights & Biases</a> (<a href=\"https://wandb.me/run\" target=\"_blank\">docs</a>)<br/>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View project at <a href=\"https://wandb.ai/keio-csg/quantize_resnet_cifar100\" target=\"_blank\">https://wandb.ai/keio-csg/quantize_resnet_cifar100</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       " View run at <a href=\"https://wandb.ai/keio-csg/quantize_resnet_cifar100/runs/b0po5229\" target=\"_blank\">https://wandb.ai/keio-csg/quantize_resnet_cifar100/runs/b0po5229</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current lr 1.00000e-06\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17cf7f8a35e848bebb4cf4f3837f5174",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.338 (0.338)\tLoss 5.5044 (5.5044)\tPrec@1 0.781 (0.781)\n",
      " * Prec@1 1.260\n",
      "alpha1 9.999813079833984\n",
      "Best prec1 :  1.26\n",
      "current lr 3.34000e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3967052a0e644999b4afc9b80063db74",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.342 (0.342)\tLoss 3.8919 (3.8919)\tPrec@1 10.938 (10.938)\n",
      " * Prec@1 12.770\n",
      "alpha1 9.93449592590332\n",
      "Best prec1 :  12.77\n",
      "current lr 6.67000e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "362f28b345454350a5331ef337994844",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.314 (0.314)\tLoss 3.6566 (3.6566)\tPrec@1 16.797 (16.797)\n",
      " * Prec@1 15.070\n",
      "alpha1 9.804883003234863\n",
      "Best prec1 :  15.07\n",
      "current lr 1.00000e-03\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7b2373b482294bd192702b8526fd220b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.348 (0.348)\tLoss 3.6205 (3.6205)\tPrec@1 17.188 (17.188)\n",
      " * Prec@1 16.160\n",
      "alpha1 9.612518310546875\n",
      "Best prec1 :  16.16\n",
      "current lr 9.99938e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e09f9b7b43246289c5d83fd0f2130f7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.333 (0.333)\tLoss 3.3408 (3.3408)\tPrec@1 20.703 (20.703)\n",
      " * Prec@1 20.930\n",
      "alpha1 9.422268867492676\n",
      "Best prec1 :  20.93\n",
      "current lr 9.99754e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6914eb7025204e57a0d7834de40bb5b1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.316 (0.316)\tLoss 3.0365 (3.0365)\tPrec@1 28.516 (28.516)\n",
      " * Prec@1 24.070\n",
      "alpha1 9.233827590942383\n",
      "Best prec1 :  24.07\n",
      "current lr 9.99445e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "929a7eb5ef694a8b87ef715178c32178",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.305 (0.305)\tLoss 2.9463 (2.9463)\tPrec@1 23.828 (23.828)\n",
      " * Prec@1 27.160\n",
      "alpha1 9.047001838684082\n",
      "Best prec1 :  27.16\n",
      "current lr 9.99014e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "682cd9104e3544a4949b9e2af416b3e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.303 (0.303)\tLoss 2.8257 (2.8257)\tPrec@1 30.859 (30.859)\n",
      " * Prec@1 27.710\n",
      "alpha1 8.861658096313477\n",
      "Best prec1 :  27.71\n",
      "current lr 9.98460e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a3221cdf78b5417b91b5ada9787d254f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.299 (0.299)\tLoss 2.6667 (2.6667)\tPrec@1 33.594 (33.594)\n",
      " * Prec@1 29.780\n",
      "alpha1 8.677701950073242\n",
      "Best prec1 :  29.78\n",
      "current lr 9.97783e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e57e9f677f646b48330fa3fae2ab38e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.323 (0.323)\tLoss 2.6376 (2.6376)\tPrec@1 36.719 (36.719)\n",
      " * Prec@1 30.790\n",
      "alpha1 8.495048522949219\n",
      "Best prec1 :  30.79\n",
      "current lr 9.96983e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22b057bd49ed4ab3a03ebbd499bef396",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.347 (0.347)\tLoss 2.7129 (2.7129)\tPrec@1 37.500 (37.500)\n",
      " * Prec@1 30.880\n",
      "alpha1 8.313639640808105\n",
      "Best prec1 :  30.88\n",
      "current lr 9.96061e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fa69d3eccf164854b6d6964120b89673",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.334 (0.334)\tLoss 2.5443 (2.5443)\tPrec@1 36.719 (36.719)\n",
      " * Prec@1 34.170\n",
      "alpha1 8.133419036865234\n",
      "Best prec1 :  34.17\n",
      "current lr 9.95017e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5b4f07834b448628a2fb4aa4359cb32",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.321 (0.321)\tLoss 2.5780 (2.5780)\tPrec@1 37.109 (37.109)\n",
      " * Prec@1 34.420\n",
      "alpha1 7.954357147216797\n",
      "Best prec1 :  34.42\n",
      "current lr 9.93850e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac5ef405cdc5400682be05b18b9868f1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.353 (0.353)\tLoss 2.4990 (2.4990)\tPrec@1 38.281 (38.281)\n",
      " * Prec@1 35.490\n",
      "alpha1 7.7764058113098145\n",
      "Best prec1 :  35.49\n",
      "current lr 9.92562e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d6d14b9140141509895b766e4f6f514",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.333 (0.333)\tLoss 2.4630 (2.4630)\tPrec@1 41.016 (41.016)\n",
      " * Prec@1 36.070\n",
      "alpha1 7.599544525146484\n",
      "Best prec1 :  36.07\n",
      "current lr 9.91152e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c4c8c919c1924898acac1c2c66dbc821",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.364 (0.364)\tLoss 2.3593 (2.3593)\tPrec@1 43.359 (43.359)\n",
      " * Prec@1 38.280\n",
      "alpha1 7.423750877380371\n",
      "Best prec1 :  38.28\n",
      "current lr 9.89622e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "be27eea297ac490ab54bde847cdf50c4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.306 (0.306)\tLoss 2.3310 (2.3310)\tPrec@1 39.453 (39.453)\n",
      " * Prec@1 38.390\n",
      "alpha1 7.249009132385254\n",
      "Best prec1 :  38.39\n",
      "current lr 9.87970e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e1f8e8a0a6324d31805135a222851de0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.293 (0.293)\tLoss 2.3706 (2.3706)\tPrec@1 39.453 (39.453)\n",
      " * Prec@1 37.940\n",
      "alpha1 7.075309753417969\n",
      "Best prec1 :  38.39\n",
      "current lr 9.86199e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "68646e9eef8e4706ae073523d2a4470b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.310 (0.310)\tLoss 2.6585 (2.6585)\tPrec@1 42.188 (42.188)\n",
      " * Prec@1 38.840\n",
      "alpha1 6.902646541595459\n",
      "Best prec1 :  38.84\n",
      "current lr 9.84307e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "817db1dd5fb44d5d9ed6eb4ef633c353",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.331 (0.331)\tLoss 2.1811 (2.1811)\tPrec@1 45.703 (45.703)\n",
      " * Prec@1 41.650\n",
      "alpha1 6.73101806640625\n",
      "Best prec1 :  41.65\n",
      "current lr 9.82296e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c99ac97399c84cf8ae64580c4978d6c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.348 (0.348)\tLoss 2.2797 (2.2797)\tPrec@1 43.750 (43.750)\n",
      " * Prec@1 41.250\n",
      "alpha1 6.560426712036133\n",
      "Best prec1 :  41.65\n",
      "current lr 9.80167e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "53014fac51c84a05b3bc0f7ecec723ab",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.374 (0.374)\tLoss 2.0859 (2.0859)\tPrec@1 49.219 (49.219)\n",
      " * Prec@1 42.760\n",
      "alpha1 6.390881061553955\n",
      "Best prec1 :  42.76\n",
      "current lr 9.77919e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8434f86750cb41589c67b54898bee977",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.343 (0.343)\tLoss 2.0441 (2.0441)\tPrec@1 49.219 (49.219)\n",
      " * Prec@1 43.680\n",
      "alpha1 6.222391605377197\n",
      "Best prec1 :  43.68\n",
      "current lr 9.75553e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d56997c3df6f4ebfb7771ec1f36fe6c1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.320 (0.320)\tLoss 2.1846 (2.1846)\tPrec@1 45.312 (45.312)\n",
      " * Prec@1 43.060\n",
      "alpha1 6.054969310760498\n",
      "Best prec1 :  43.68\n",
      "current lr 9.73070e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dafed29b68c34772b39daa18f189990a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.331 (0.331)\tLoss 2.0810 (2.0810)\tPrec@1 48.828 (48.828)\n",
      " * Prec@1 44.350\n",
      "alpha1 5.888631820678711\n",
      "Best prec1 :  44.35\n",
      "current lr 9.70470e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "33370fd9cf934dd49fcffbf34d57d02e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.351 (0.351)\tLoss 2.7491 (2.7491)\tPrec@1 41.797 (41.797)\n",
      " * Prec@1 42.210\n",
      "alpha1 5.723397731781006\n",
      "Best prec1 :  44.35\n",
      "current lr 9.67754e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "80564fe5fc1943abbdf26765b814d6b3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.312 (0.312)\tLoss 2.0220 (2.0220)\tPrec@1 47.266 (47.266)\n",
      " * Prec@1 45.680\n",
      "alpha1 5.559289455413818\n",
      "Best prec1 :  45.68\n",
      "current lr 9.64923e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47fb6aecaff245a7aee11181c5fb7d5c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.320 (0.320)\tLoss 2.0364 (2.0364)\tPrec@1 50.781 (50.781)\n",
      " * Prec@1 46.220\n",
      "alpha1 5.396329879760742\n",
      "Best prec1 :  46.22\n",
      "current lr 9.61978e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a3c66b161654f2ab205bdf8e661c551",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.387 (0.387)\tLoss 2.0098 (2.0098)\tPrec@1 49.219 (49.219)\n",
      " * Prec@1 45.570\n",
      "alpha1 5.234546661376953\n",
      "Best prec1 :  46.22\n",
      "current lr 9.58918e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fee09833184b46a9a13cc370d4f48260",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.333 (0.333)\tLoss 1.9588 (1.9588)\tPrec@1 50.781 (50.781)\n",
      " * Prec@1 45.710\n",
      "alpha1 5.073968410491943\n",
      "Best prec1 :  46.22\n",
      "current lr 9.55746e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e17193e5424e41589edb9b3c921e8225",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.363 (0.363)\tLoss 2.0254 (2.0254)\tPrec@1 53.125 (53.125)\n",
      " * Prec@1 45.970\n",
      "alpha1 4.914625644683838\n",
      "Best prec1 :  46.22\n",
      "current lr 9.52461e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "508292ecec6441e58d6141b437a5c584",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.338 (0.338)\tLoss 2.4491 (2.4491)\tPrec@1 48.828 (48.828)\n",
      " * Prec@1 46.280\n",
      "alpha1 4.756550312042236\n",
      "Best prec1 :  46.28\n",
      "current lr 9.49065e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ee32e80b97684a9b9d4ab1adf6b97659",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.361 (0.361)\tLoss 1.7902 (1.7902)\tPrec@1 53.125 (53.125)\n",
      " * Prec@1 48.120\n",
      "alpha1 4.59977912902832\n",
      "Best prec1 :  48.12\n",
      "current lr 9.45558e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5990bfe601bf4b0a958b041439104167",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [0/40]\tTime 0.336 (0.336)\tLoss 1.9338 (1.9338)\tPrec@1 51.953 (51.953)\n",
      " * Prec@1 48.100\n",
      "alpha1 4.44434928894043\n",
      "Best prec1 :  48.12\n",
      "current lr 9.41941e-04\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e238f16d29f44b5589034940332b1d1a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/196 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from timm.scheduler import CosineLRScheduler\n",
    "\n",
    "for k in range(6,9):\n",
    "    if MOD == \"resnet18\" or MOD==\"resnet20\":\n",
    "        net = resnet20(k=k)\n",
    "    elif MOD==\"resnet34\":\n",
    "        net = resnet34(k=k)\n",
    "\n",
    "    model = net.to(device)\n",
    "\n",
    "    # Track experiment with wandb\n",
    "    import wandb\n",
    "    watermark = \"{}_quantize_k{}_cifar100_original\".format(MOD, k)\n",
    "    if mixup:\n",
    "        watermark += \"_mixup\"\n",
    "\n",
    "    # mess with wandb\n",
    "    wandb.init(project=\"quantize_resnet_cifar100\", name=watermark)\n",
    "\n",
    "    # optimizer for pact\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "    scheduler = CosineLRScheduler(optimizer, t_initial=n_epochs, lr_min=1e-6, \n",
    "                          warmup_t=3, warmup_lr_init=1e-6, warmup_prefix=True)\n",
    "\n",
    "    best_prec1 = 0\n",
    "    os.makedirs(\"models\", exist_ok=True)\n",
    "\n",
    "    for epoch in range(n_epochs):\n",
    "        scheduler.step(epoch)\n",
    "        # train for one epoch\n",
    "        print('current lr {:.5e}'.format(optimizer.param_groups[0]['lr']))\n",
    "        tloss = train(train_loader, model, optimizer, epoch)         \n",
    "\n",
    "        # evaluate on validation set\n",
    "        prec1, valloss = validate(val_loader, model)\n",
    "\n",
    "        # wandb\n",
    "        wandb.log({'epoch': epoch, \"prec\":prec1, \"train_loss\": tloss, 'val_loss': valloss, \"lr\": optimizer.param_groups[0][\"lr\"],})\n",
    "\n",
    "        # remember best prec@1 and save checkpoint\n",
    "        is_best = prec1 > best_prec1\n",
    "        best_prec1 = max(prec1, best_prec1)\n",
    "\n",
    "        print(\"Best prec1 : \", best_prec1)\n",
    "        if is_best:\n",
    "            torch.save(model.state_dict(), os.path.join(f'models/{watermark}.pth'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcba9662",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}