42 Resnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-19T08:56:20.085601Z",
     "start_time": "2020-04-19T08:56:20.075518Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import functional as F \n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch import optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-19T08:56:20.108424Z",
     "start_time": "2020-04-19T08:56:20.089474Z"
    }
   },
   "outputs": [],
   "source": [
    "class ResBlk(nn.Module):\n",
    "    \"\"\"\n",
    "    resnet block\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, ch_in, ch_out):\n",
    "        \"\"\"\n",
    "        :param ch_in:\n",
    "        :param ch_out:\n",
    "        \"\"\"\n",
    "        super(ResBlk, self).__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=1, padding=1)\n",
    "        self.bn1 = nn.BatchNorm2d(ch_out)\n",
    "        self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(ch_out)\n",
    "\n",
    "        self.extra = nn.Sequential()\n",
    "        if ch_out != ch_in:\n",
    "            # [b, ch_in, h, w] => [b, ch_out, h, w]\n",
    "            self.extra = nn.Sequential(\n",
    "                nn.Conv2d(ch_in, ch_out, kernel_size=1, stride=1),\n",
    "                nn.BatchNorm2d(ch_out)\n",
    "            )\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        :param x: [b, ch, h, w]\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        # short cut.\n",
    "        # extra module: [b, ch_in, h, w] => [b, ch_out, h, w]\n",
    "        # element-wise add:\n",
    "        out = self.extra(x) + out\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-19T08:56:20.124380Z",
     "start_time": "2020-04-19T08:56:20.111415Z"
    }
   },
   "outputs": [],
   "source": [
    "class ResNet18(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(ResNet18, self).__init__()\n",
    "\n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),\n",
    "            nn.BatchNorm2d(16)\n",
    "        )\n",
    "        # followed 4 blocks\n",
    "        # [b, 64, h, w] => [b, 128, h ,w]\n",
    "        self.blk1 = ResBlk(16, 16)\n",
    "        # [b, 128, h, w] => [b, 256, h, w]\n",
    "        self.blk2 = ResBlk(16, 32)\n",
    "        # # [b, 256, h, w] => [b, 512, h, w]\n",
    "        # self.blk3 = ResBlk(128, 256)\n",
    "        # # [b, 512, h, w] => [b, 1024, h, w]\n",
    "        # self.blk4 = ResBlk(256, 512)\n",
    "\n",
    "        self.outlayer = nn.Linear(32*32*32, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        :param x:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        x = F.relu(self.conv1(x))\n",
    "\n",
    "        # [b, 64, h, w] => [b, 1024, h, w]\n",
    "        x = self.blk1(x)\n",
    "        x = self.blk2(x)\n",
    "        # x = self.blk3(x)\n",
    "        # x = self.blk4(x)\n",
    "\n",
    "        # print(x.shape)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.outlayer(x)\n",
    "\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-19T08:56:23.013629Z",
     "start_time": "2020-04-19T08:56:22.735371Z"
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "\n",
    "#     blk = ResBlk(64, 128, stride=2)\n",
    "#     tmp = torch.randn(2, 64, 32, 32)\n",
    "#     out = blk(tmp)\n",
    "#     print('block:', out.shape)\n",
    "\n",
    "    x = torch.randn(2, 3, 32, 32)\n",
    "    model = ResNet18()\n",
    "    out = model(x)\n",
    "    print('resnet:', out.shape)\n",
    "\n",
    "if __name__=='__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-18T09:26:34.955066Z",
     "start_time": "2020-04-18T09:26:34.935552Z"
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    batchsz=32 \n",
    "    epochs=1000\n",
    "    \n",
    "    cifar_train=datasets.CIFAR10('./data/cifar',train=True,download=True,\n",
    "                                transform=transforms.Compose([\n",
    "                                    transforms.Resize((32,32)),\n",
    "                                    transforms.ToTensor()\n",
    "                                ]))\n",
    "    cifar_train=DataLoader(cifar_train,batch_size=batchsz,shuffle=True)\n",
    "    \n",
    "    cifar_test=datasets.CIFAR10('./data/cifar',train=False,download=True,\n",
    "                                transform=transforms.Compose([\n",
    "                                    transforms.Resize((32,32)),\n",
    "                                    transforms.ToTensor()\n",
    "                                ]))\n",
    "    cifar_test=DataLoader(cifar_test,batch_size=batchsz,shuffle=True)\n",
    "    \n",
    "    x,label=iter(cifar_train).next()\n",
    "    print('x:',x.shape,'label:',label.shape)\n",
    "    \n",
    "    device=torch.device('cuda')\n",
    "    model=ResNet18().to(device)\n",
    "    \n",
    "    criteon=nn.CrossEntropyLoss().to(device)\n",
    "    optimizer=optim.Adam(model.parameters(),lr=1e-3)\n",
    "    print(model)\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        \n",
    "        model.train() \n",
    "        for batchidx,(x,label) in enumerate(cifar_train):\n",
    "            # [b,3,32,32]\n",
    "            x,label=x.to(device),label.to(device)\n",
    "            \n",
    "            logits=model(x)\n",
    "            # logits: [b,10]\n",
    "            # label: [b]\n",
    "            # loss: tensor scaler\n",
    "            loss=criteon(logits,label)\n",
    "            \n",
    "            # backprop\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "        print('epoch={}, loss={}'.format(epoch,loss.item()))\n",
    "        \n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            # test\n",
    "            total_correct=0 \n",
    "            total_num=0 \n",
    "            for x,label in cifar_test:\n",
    "                x,label=x.to(device),label.to(device)\n",
    "                \n",
    "                # [b,10]\n",
    "                logits=model(x)\n",
    "                # [b]\n",
    "                pred=logits.argmax(dim=1)\n",
    "                # [b] vs [b] => scaler tensor\n",
    "                correct=torch.eq(pred,label).float().sum().item()\n",
    "                total_correct+=correct\n",
    "                total_num+=x.size(0)\n",
    "                # print(correct)\n",
    "                \n",
    "            acc=total_correct / total_num\n",
    "            print('acc:',acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-18T11:31:22.511967Z",
     "start_time": "2020-04-18T09:26:34.956657Z"
    }
   },
   "outputs": [],
   "source": [
    "if __name__=='__main__':\n",
    "    main()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}