├── .gitignore ├── DenseNet.ipynb ├── LeNet.ipynb ├── README.md ├── ResNet.ipynb └── VGG.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | checkpoint 2 | datasets 3 | .ipynb_checkpoints 4 | 5 | -------------------------------------------------------------------------------- /DenseNet.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "ExecuteTime": { 8 | "end_time": "2019-03-10T06:36:58.925963Z", 9 | "start_time": "2019-03-10T06:36:58.445609Z" 10 | } 11 | }, 12 | "outputs": [], 13 | "source": [ 14 | "from __future__ import print_function\n", 15 | "\n", 16 | "import os\n", 17 | "import math\n", 18 | "import torch\n", 19 | "import torch.nn as nn\n", 20 | "import torch.optim as optim\n", 21 | "import torchvision\n", 22 | "import torchvision.transforms as transforms" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 2, 28 | "metadata": { 29 | "ExecuteTime": { 30 | "end_time": "2019-03-10T06:37:00.995398Z", 31 | "start_time": "2019-03-10T06:37:00.989231Z" 32 | } 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "transform = transforms.Compose([\n", 37 | " transforms.RandomHorizontalFlip(),\n", 38 | " transforms.ToTensor(),\n", 39 | " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", 40 | "])" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 3, 46 | "metadata": { 47 | "ExecuteTime": { 48 | "end_time": "2019-03-10T06:37:15.121613Z", 49 | "start_time": "2019-03-10T06:37:02.238040Z" 50 | } 51 | }, 52 | "outputs": [ 53 | { 54 | "name": "stdout", 55 | "output_type": "stream", 56 | "text": [ 57 | "Files already downloaded and verified\n", 58 | "Files already downloaded and verified\n" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "train_set = torchvision.datasets.CIFAR10('./datasets', train=True,\n", 64 | " download=True, transform=transform)\n", 65 | "test_set = torchvision.datasets.CIFAR10('./datasets', train=False,\n", 66 | " download=True, transform=transform)\n", 67 | "\n", 68 | "train_loader = torch.utils.data.DataLoader(train_set, batch_size=64,\n", 69 | " shuffle=True, num_workers=4)\n", 70 | "test_loader = torch.utils.data.DataLoader(test_set, batch_size=64,\n", 71 | " shuffle=False, num_workers=4)\n", 72 | "\n", 73 | "classes = ('plane', 'car', 'bird', 'cat', 'deer',\n", 74 | " 'dog', 'frog', 'horse', 'ship', 'truck')" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 5, 80 | "metadata": { 81 | "ExecuteTime": { 82 | "end_time": "2019-03-10T06:37:20.597561Z", 83 | "start_time": "2019-03-10T06:37:20.081517Z" 84 | } 85 | }, 86 | "outputs": [ 87 | { 88 | "data": { 89 | "image/png": "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\n", 90 | "text/plain": [ 91 | "
" 92 | ] 93 | }, 94 | "metadata": {}, 95 | "output_type": "display_data" 96 | } 97 | ], 98 | "source": [ 99 | "import matplotlib.pyplot as plt\n", 100 | "import numpy as np\n", 101 | "\n", 102 | "def imshow(img):\n", 103 | " img = img / 2 + 0.5\n", 104 | " plt.imshow(np.transpose(img.numpy(), (1, 2, 0)))\n", 105 | " plt.show()\n", 106 | " \n", 107 | "image_iter = iter(train_loader)\n", 108 | "images, _ = image_iter.next()\n", 109 | "imshow(torchvision.utils.make_grid(images[:4]))" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 6, 115 | "metadata": { 116 | "ExecuteTime": { 117 | "end_time": "2019-03-10T06:37:22.702227Z", 118 | "start_time": "2019-03-10T06:37:22.659175Z" 119 | } 120 | }, 121 | "outputs": [ 122 | { 123 | "name": "stdout", 124 | "output_type": "stream", 125 | "text": [ 126 | "cuda:2\n" 127 | ] 128 | } 129 | ], 130 | "source": [ 131 | "device = 'cuda:2' if torch.cuda.is_available() else 'cpu'\n", 132 | "# device = torch.device('cpu')\n", 133 | "print(device)" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": {}, 139 | "source": [ 140 | "## DenseNet\n", 141 | "![DenseNet](http://img.cdn.iblue.tech/image/20190304/PXj7daLTqQA5.png?imageslim)" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 7, 147 | "metadata": { 148 | "ExecuteTime": { 149 | "end_time": "2019-03-10T06:37:24.461794Z", 150 | "start_time": "2019-03-10T06:37:24.448611Z" 151 | } 152 | }, 153 | "outputs": [], 154 | "source": [ 155 | "class Bottleneck(nn.Module):\n", 156 | " \"\"\"\n", 157 | " Dense Block\n", 158 | " 这里的growth_rate=out_channels, 就是每个Block自己输出的通道数。\n", 159 | " 先通过1x1卷积层，将通道数缩小为4 * growth_rate，然后再通过3x3卷积层降低到growth_rate。\n", 160 | " \"\"\"\n", 161 | " expansion = 4\n", 162 | " \n", 163 | " def __init__(self, in_channels, growth_rate):\n", 164 | " super(Bottleneck, self).__init__()\n", 165 | " zip_channels = self.expansion * growth_rate\n", 166 | " self.features = nn.Sequential(\n", 167 | " nn.BatchNorm2d(in_channels),\n", 168 | " nn.ReLU(True),\n", 169 | " nn.Conv2d(in_channels, zip_channels, kernel_size=1, bias=False),\n", 170 | " nn.BatchNorm2d(zip_channels),\n", 171 | " nn.ReLU(True),\n", 172 | " nn.Conv2d(zip_channels, growth_rate, kernel_size=3, padding=1, bias=False)\n", 173 | " )\n", 174 | " \n", 175 | " def forward(self, x):\n", 176 | " out = self.features(x)\n", 177 | " out = torch.cat([out, x], 1)\n", 178 | " return out " 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 8, 184 | "metadata": { 185 | "ExecuteTime": { 186 | "end_time": "2019-03-10T06:37:25.307213Z", 187 | "start_time": "2019-03-10T06:37:25.299166Z" 188 | } 189 | }, 190 | "outputs": [], 191 | "source": [ 192 | "class Transition(nn.Module):\n", 193 | " \"\"\"\n", 194 | " 改变维数的Transition层\n", 195 | " 先通过1x1的卷积层减少channels，再通过2x2的平均池化层缩小feature-map\n", 196 | " \"\"\"\n", 197 | " def __init__(self, in_channels, out_channels):\n", 198 | " super(Transition, self).__init__()\n", 199 | " self.features = nn.Sequential(\n", 200 | " nn.BatchNorm2d(in_channels),\n", 201 | " nn.ReLU(True),\n", 202 | " nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),\n", 203 | " nn.AvgPool2d(2)\n", 204 | " )\n", 205 | " \n", 206 | " def forward(self, x):\n", 207 | " out = self.features(x)\n", 208 | " return out" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 9, 214 | "metadata": { 215 | "ExecuteTime": { 216 | "end_time": "2019-03-10T06:37:26.475641Z", 217 | "start_time": "2019-03-10T06:37:26.457792Z" 218 | } 219 | }, 220 | "outputs": [], 221 | "source": [ 222 | "class DenseNet(nn.Module):\n", 223 | " \"\"\"\n", 224 | " Dense Net\n", 225 | " paper中growth_rate取12，维度压缩的参数θ，即reduction取0.5\n", 226 | " 且初始化方法为kaiming_normal()\n", 227 | " num_blocks为每段网络中的DenseBlock数量\n", 228 | " DenseNet和ResNet一样也是六段式网络（一段卷积+四段Dense+平均池化层），最后FC层。\n", 229 | " 第一段将维数从3变到2 * growth_rate\n", 230 | " \n", 231 | " (3, 32, 32) -> [Conv2d] -> (24, 32, 32) -> [layer1] -> (48, 16, 16) -> [layer2]\n", 232 | " ->(96, 8, 8) -> [layer3] -> (192, 4, 4) -> [layer4] -> (384, 4, 4) -> [AvgPool]\n", 233 | " ->(384, 1, 1) -> [Linear] -> (10)\n", 234 | " \n", 235 | " \"\"\"\n", 236 | " def __init__(self, num_blocks, growth_rate=12, reduction=0.5, num_classes=10):\n", 237 | " super(DenseNet, self).__init__()\n", 238 | " self.growth_rate = growth_rate\n", 239 | " self.reduction = reduction\n", 240 | " \n", 241 | " num_channels = 2 * growth_rate\n", 242 | " \n", 243 | " self.features = nn.Conv2d(3, num_channels, kernel_size=3, padding=1, bias=False)\n", 244 | " self.layer1, num_channels = self._make_dense_layer(num_channels, num_blocks[0])\n", 245 | " self.layer2, num_channels = self._make_dense_layer(num_channels, num_blocks[1])\n", 246 | " self.layer3, num_channels = self._make_dense_layer(num_channels, num_blocks[2])\n", 247 | " self.layer4, num_channels = self._make_dense_layer(num_channels, num_blocks[3], transition=False)\n", 248 | " self.avg_pool = nn.Sequential(\n", 249 | " nn.BatchNorm2d(num_channels),\n", 250 | " nn.ReLU(True),\n", 251 | " nn.AvgPool2d(4),\n", 252 | " )\n", 253 | " self.classifier = nn.Linear(num_channels, num_classes)\n", 254 | " \n", 255 | " self._initialize_weight()\n", 256 | " \n", 257 | " def _make_dense_layer(self, in_channels, nblock, transition=True):\n", 258 | " layers = []\n", 259 | " for i in range(nblock):\n", 260 | " layers += [Bottleneck(in_channels, self.growth_rate)]\n", 261 | " in_channels += self.growth_rate\n", 262 | " out_channels = in_channels\n", 263 | " if transition:\n", 264 | " out_channels = int(math.floor(in_channels * self.reduction))\n", 265 | " layers += [Transition(in_channels, out_channels)]\n", 266 | " return nn.Sequential(*layers), out_channels\n", 267 | " \n", 268 | " def _initialize_weight(self):\n", 269 | " for m in self.modules():\n", 270 | " if isinstance(m, nn.Conv2d):\n", 271 | " nn.init.kaiming_normal_(m.weight.data)\n", 272 | " if m.bias is not None:\n", 273 | " m.bias.data.zero_()\n", 274 | " \n", 275 | " def forward(self, x):\n", 276 | " out = self.features(x)\n", 277 | " out = self.layer1(out)\n", 278 | " out = self.layer2(out)\n", 279 | " out = self.layer3(out)\n", 280 | " out = self.layer4(out)\n", 281 | " out = self.avg_pool(out)\n", 282 | " out = out.view(out.size(0), -1)\n", 283 | " out = self.classifier(out)\n", 284 | " return out" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 10, 290 | "metadata": { 291 | "ExecuteTime": { 292 | "end_time": "2019-03-10T06:37:27.864891Z", 293 | "start_time": "2019-03-10T06:37:27.857600Z" 294 | } 295 | }, 296 | "outputs": [], 297 | "source": [ 298 | "def DenseNet121():\n", 299 | " return DenseNet([6,12,24,16], growth_rate=32)\n", 300 | "\n", 301 | "def DenseNet169():\n", 302 | " return DenseNet([6,12,32,32], growth_rate=32)\n", 303 | "\n", 304 | "def DenseNet201():\n", 305 | " return DenseNet([6,12,48,32], growth_rate=32)\n", 306 | "\n", 307 | "def DenseNet161():\n", 308 | " return DenseNet([6,12,36,24], growth_rate=48)\n", 309 | "\n", 310 | "def densenet_cifar():\n", 311 | " return DenseNet([6,12,24,16], growth_rate=12)" 312 | ] 313 | }, 314 | { 315 | "cell_type": "code", 316 | "execution_count": 11, 317 | "metadata": { 318 | "ExecuteTime": { 319 | "end_time": "2019-03-10T06:37:36.085763Z", 320 | "start_time": "2019-03-10T06:37:29.508243Z" 321 | } 322 | }, 323 | "outputs": [ 324 | { 325 | "name": "stdout", 326 | "output_type": "stream", 327 | "text": [ 328 | "DenseNet(\n", 329 | " (features): Conv2d(3, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 330 | " (layer1): Sequential(\n", 331 | " (0): Bottleneck(\n", 332 | " (features): Sequential(\n", 333 | " (0): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 334 | " (1): ReLU(inplace)\n", 335 | " (2): Conv2d(24, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 336 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 337 | " (4): ReLU(inplace)\n", 338 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 339 | " )\n", 340 | " )\n", 341 | " (1): Bottleneck(\n", 342 | " (features): Sequential(\n", 343 | " (0): BatchNorm2d(36, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 344 | " (1): ReLU(inplace)\n", 345 | " (2): Conv2d(36, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 346 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 347 | " (4): ReLU(inplace)\n", 348 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 349 | " )\n", 350 | " )\n", 351 | " (2): Bottleneck(\n", 352 | " (features): Sequential(\n", 353 | " (0): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 354 | " (1): ReLU(inplace)\n", 355 | " (2): Conv2d(48, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 356 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 357 | " (4): ReLU(inplace)\n", 358 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 359 | " )\n", 360 | " )\n", 361 | " (3): Bottleneck(\n", 362 | " (features): Sequential(\n", 363 | " (0): BatchNorm2d(60, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 364 | " (1): ReLU(inplace)\n", 365 | " (2): Conv2d(60, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 366 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 367 | " (4): ReLU(inplace)\n", 368 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 369 | " )\n", 370 | " )\n", 371 | " (4): Bottleneck(\n", 372 | " (features): Sequential(\n", 373 | " (0): BatchNorm2d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 374 | " (1): ReLU(inplace)\n", 375 | " (2): Conv2d(72, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 376 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 377 | " (4): ReLU(inplace)\n", 378 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 379 | " )\n", 380 | " )\n", 381 | " (5): Bottleneck(\n", 382 | " (features): Sequential(\n", 383 | " (0): BatchNorm2d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 384 | " (1): ReLU(inplace)\n", 385 | " (2): Conv2d(84, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 386 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 387 | " (4): ReLU(inplace)\n", 388 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 389 | " )\n", 390 | " )\n", 391 | " (6): Transition(\n", 392 | " (features): Sequential(\n", 393 | " (0): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 394 | " (1): ReLU(inplace)\n", 395 | " (2): Conv2d(96, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 396 | " (3): AvgPool2d(kernel_size=2, stride=2, padding=0)\n", 397 | " )\n", 398 | " )\n", 399 | " )\n", 400 | " (layer2): Sequential(\n", 401 | " (0): Bottleneck(\n", 402 | " (features): Sequential(\n", 403 | " (0): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 404 | " (1): ReLU(inplace)\n", 405 | " (2): Conv2d(48, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 406 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 407 | " (4): ReLU(inplace)\n", 408 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 409 | " )\n", 410 | " )\n", 411 | " (1): Bottleneck(\n", 412 | " (features): Sequential(\n", 413 | " (0): BatchNorm2d(60, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 414 | " (1): ReLU(inplace)\n", 415 | " (2): Conv2d(60, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 416 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 417 | " (4): ReLU(inplace)\n", 418 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 419 | " )\n", 420 | " )\n", 421 | " (2): Bottleneck(\n", 422 | " (features): Sequential(\n", 423 | " (0): BatchNorm2d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 424 | " (1): ReLU(inplace)\n", 425 | " (2): Conv2d(72, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 426 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 427 | " (4): ReLU(inplace)\n", 428 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 429 | " )\n", 430 | " )\n", 431 | " (3): Bottleneck(\n", 432 | " (features): Sequential(\n", 433 | " (0): BatchNorm2d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 434 | " (1): ReLU(inplace)\n", 435 | " (2): Conv2d(84, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 436 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 437 | " (4): ReLU(inplace)\n", 438 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 439 | " )\n", 440 | " )\n", 441 | " (4): Bottleneck(\n", 442 | " (features): Sequential(\n", 443 | " (0): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 444 | " (1): ReLU(inplace)\n", 445 | " (2): Conv2d(96, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 446 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 447 | " (4): ReLU(inplace)\n", 448 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 449 | " )\n", 450 | " )\n", 451 | " (5): Bottleneck(\n", 452 | " (features): Sequential(\n", 453 | " (0): BatchNorm2d(108, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 454 | " (1): ReLU(inplace)\n", 455 | " (2): Conv2d(108, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 456 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 457 | " (4): ReLU(inplace)\n", 458 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 459 | " )\n", 460 | " )\n", 461 | " (6): Bottleneck(\n", 462 | " (features): Sequential(\n", 463 | " (0): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 464 | " (1): ReLU(inplace)\n", 465 | " (2): Conv2d(120, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 466 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 467 | " (4): ReLU(inplace)\n", 468 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 469 | " )\n", 470 | " )\n", 471 | " (7): Bottleneck(\n", 472 | " (features): Sequential(\n", 473 | " (0): BatchNorm2d(132, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 474 | " (1): ReLU(inplace)\n", 475 | " (2): Conv2d(132, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 476 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 477 | " (4): ReLU(inplace)\n", 478 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 479 | " )\n", 480 | " )\n", 481 | " (8): Bottleneck(\n", 482 | " (features): Sequential(\n", 483 | " (0): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 484 | " (1): ReLU(inplace)\n", 485 | " (2): Conv2d(144, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 486 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 487 | " (4): ReLU(inplace)\n", 488 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 489 | " )\n", 490 | " )\n", 491 | " (9): Bottleneck(\n", 492 | " (features): Sequential(\n", 493 | " (0): BatchNorm2d(156, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 494 | " (1): ReLU(inplace)\n", 495 | " (2): Conv2d(156, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 496 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 497 | " (4): ReLU(inplace)\n", 498 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 499 | " )\n", 500 | " )\n", 501 | " (10): Bottleneck(\n", 502 | " (features): Sequential(\n", 503 | " (0): BatchNorm2d(168, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 504 | " (1): ReLU(inplace)\n", 505 | " (2): Conv2d(168, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 506 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 507 | " (4): ReLU(inplace)\n", 508 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 509 | " )\n", 510 | " )\n", 511 | " (11): Bottleneck(\n", 512 | " (features): Sequential(\n", 513 | " (0): BatchNorm2d(180, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 514 | " (1): ReLU(inplace)\n", 515 | " (2): Conv2d(180, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 516 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 517 | " (4): ReLU(inplace)\n", 518 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 519 | " )\n", 520 | " )\n", 521 | " (12): Transition(\n", 522 | " (features): Sequential(\n", 523 | " (0): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 524 | " (1): ReLU(inplace)\n", 525 | " (2): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 526 | " (3): AvgPool2d(kernel_size=2, stride=2, padding=0)\n", 527 | " )\n", 528 | " )\n", 529 | " )\n", 530 | " (layer3): Sequential(\n", 531 | " (0): Bottleneck(\n", 532 | " (features): Sequential(\n", 533 | " (0): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 534 | " (1): ReLU(inplace)\n", 535 | " (2): Conv2d(96, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 536 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 537 | " (4): ReLU(inplace)\n", 538 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 539 | " )\n", 540 | " )\n", 541 | " (1): Bottleneck(\n", 542 | " (features): Sequential(\n", 543 | " (0): BatchNorm2d(108, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 544 | " (1): ReLU(inplace)\n", 545 | " (2): Conv2d(108, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 546 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 547 | " (4): ReLU(inplace)\n", 548 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 549 | " )\n", 550 | " )\n", 551 | " (2): Bottleneck(\n", 552 | " (features): Sequential(\n", 553 | " (0): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 554 | " (1): ReLU(inplace)\n", 555 | " (2): Conv2d(120, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 556 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 557 | " (4): ReLU(inplace)\n", 558 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 559 | " )\n", 560 | " )\n", 561 | " (3): Bottleneck(\n", 562 | " (features): Sequential(\n", 563 | " (0): BatchNorm2d(132, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 564 | " (1): ReLU(inplace)\n", 565 | " (2): Conv2d(132, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 566 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 567 | " (4): ReLU(inplace)\n", 568 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 569 | " )\n", 570 | " )\n", 571 | " (4): Bottleneck(\n", 572 | " (features): Sequential(\n", 573 | " (0): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 574 | " (1): ReLU(inplace)\n", 575 | " (2): Conv2d(144, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 576 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 577 | " (4): ReLU(inplace)\n", 578 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 579 | " )\n", 580 | " )\n", 581 | " (5): Bottleneck(\n", 582 | " (features): Sequential(\n", 583 | " (0): BatchNorm2d(156, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 584 | " (1): ReLU(inplace)\n", 585 | " (2): Conv2d(156, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 586 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 587 | " (4): ReLU(inplace)\n", 588 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 589 | " )\n", 590 | " )\n", 591 | " (6): Bottleneck(\n", 592 | " (features): Sequential(\n", 593 | " (0): BatchNorm2d(168, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 594 | " (1): ReLU(inplace)\n", 595 | " (2): Conv2d(168, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 596 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 597 | " (4): ReLU(inplace)\n", 598 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 599 | " )\n", 600 | " )\n", 601 | " (7): Bottleneck(\n", 602 | " (features): Sequential(\n", 603 | " (0): BatchNorm2d(180, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 604 | " (1): ReLU(inplace)\n", 605 | " (2): Conv2d(180, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 606 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 607 | " (4): ReLU(inplace)\n", 608 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 609 | " )\n", 610 | " )\n", 611 | " (8): Bottleneck(\n", 612 | " (features): Sequential(\n", 613 | " (0): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 614 | " (1): ReLU(inplace)\n", 615 | " (2): Conv2d(192, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 616 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 617 | " (4): ReLU(inplace)\n", 618 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 619 | " )\n", 620 | " )\n", 621 | " (9): Bottleneck(\n", 622 | " (features): Sequential(\n", 623 | " (0): BatchNorm2d(204, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 624 | " (1): ReLU(inplace)\n", 625 | " (2): Conv2d(204, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 626 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 627 | " (4): ReLU(inplace)\n", 628 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 629 | " )\n", 630 | " )\n", 631 | " (10): Bottleneck(\n", 632 | " (features): Sequential(\n", 633 | " (0): BatchNorm2d(216, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 634 | " (1): ReLU(inplace)\n", 635 | " (2): Conv2d(216, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 636 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 637 | " (4): ReLU(inplace)\n", 638 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 639 | " )\n", 640 | " )\n", 641 | " (11): Bottleneck(\n", 642 | " (features): Sequential(\n", 643 | " (0): BatchNorm2d(228, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 644 | " (1): ReLU(inplace)\n", 645 | " (2): Conv2d(228, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 646 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 647 | " (4): ReLU(inplace)\n", 648 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 649 | " )\n", 650 | " )\n", 651 | " (12): Bottleneck(\n", 652 | " (features): Sequential(\n", 653 | " (0): BatchNorm2d(240, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 654 | " (1): ReLU(inplace)\n", 655 | " (2): Conv2d(240, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 656 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 657 | " (4): ReLU(inplace)\n", 658 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 659 | " )\n", 660 | " )\n", 661 | " (13): Bottleneck(\n", 662 | " (features): Sequential(\n", 663 | " (0): BatchNorm2d(252, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 664 | " (1): ReLU(inplace)\n", 665 | " (2): Conv2d(252, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 666 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 667 | " (4): ReLU(inplace)\n", 668 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 669 | " )\n", 670 | " )\n", 671 | " (14): Bottleneck(\n", 672 | " (features): Sequential(\n", 673 | " (0): BatchNorm2d(264, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 674 | " (1): ReLU(inplace)\n", 675 | " (2): Conv2d(264, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 676 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 677 | " (4): ReLU(inplace)\n", 678 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 679 | " )\n", 680 | " )\n", 681 | " (15): Bottleneck(\n", 682 | " (features): Sequential(\n", 683 | " (0): BatchNorm2d(276, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 684 | " (1): ReLU(inplace)\n", 685 | " (2): Conv2d(276, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 686 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 687 | " (4): ReLU(inplace)\n", 688 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 689 | " )\n", 690 | " )\n", 691 | " (16): Bottleneck(\n", 692 | " (features): Sequential(\n", 693 | " (0): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 694 | " (1): ReLU(inplace)\n", 695 | " (2): Conv2d(288, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 696 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 697 | " (4): ReLU(inplace)\n", 698 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 699 | " )\n", 700 | " )\n", 701 | " (17): Bottleneck(\n", 702 | " (features): Sequential(\n", 703 | " (0): BatchNorm2d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 704 | " (1): ReLU(inplace)\n", 705 | " (2): Conv2d(300, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 706 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 707 | " (4): ReLU(inplace)\n", 708 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 709 | " )\n", 710 | " )\n", 711 | " (18): Bottleneck(\n", 712 | " (features): Sequential(\n", 713 | " (0): BatchNorm2d(312, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 714 | " (1): ReLU(inplace)\n", 715 | " (2): Conv2d(312, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 716 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 717 | " (4): ReLU(inplace)\n", 718 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 719 | " )\n", 720 | " )\n", 721 | " (19): Bottleneck(\n", 722 | " (features): Sequential(\n", 723 | " (0): BatchNorm2d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 724 | " (1): ReLU(inplace)\n", 725 | " (2): Conv2d(324, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 726 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 727 | " (4): ReLU(inplace)\n", 728 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 729 | " )\n", 730 | " )\n", 731 | " (20): Bottleneck(\n", 732 | " (features): Sequential(\n", 733 | " (0): BatchNorm2d(336, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 734 | " (1): ReLU(inplace)\n", 735 | " (2): Conv2d(336, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 736 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 737 | " (4): ReLU(inplace)\n", 738 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 739 | " )\n", 740 | " )\n", 741 | " (21): Bottleneck(\n", 742 | " (features): Sequential(\n", 743 | " (0): BatchNorm2d(348, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 744 | " (1): ReLU(inplace)\n", 745 | " (2): Conv2d(348, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 746 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 747 | " (4): ReLU(inplace)\n", 748 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 749 | " )\n", 750 | " )\n", 751 | " (22): Bottleneck(\n", 752 | " (features): Sequential(\n", 753 | " (0): BatchNorm2d(360, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 754 | " (1): ReLU(inplace)\n", 755 | " (2): Conv2d(360, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 756 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 757 | " (4): ReLU(inplace)\n", 758 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 759 | " )\n", 760 | " )\n", 761 | " (23): Bottleneck(\n", 762 | " (features): Sequential(\n", 763 | " (0): BatchNorm2d(372, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 764 | " (1): ReLU(inplace)\n", 765 | " (2): Conv2d(372, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 766 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 767 | " (4): ReLU(inplace)\n", 768 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 769 | " )\n", 770 | " )\n", 771 | " (24): Transition(\n", 772 | " (features): Sequential(\n", 773 | " (0): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 774 | " (1): ReLU(inplace)\n", 775 | " (2): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 776 | " (3): AvgPool2d(kernel_size=2, stride=2, padding=0)\n", 777 | " )\n", 778 | " )\n", 779 | " )\n", 780 | " (layer4): Sequential(\n", 781 | " (0): Bottleneck(\n", 782 | " (features): Sequential(\n", 783 | " (0): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 784 | " (1): ReLU(inplace)\n", 785 | " (2): Conv2d(192, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 786 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 787 | " (4): ReLU(inplace)\n", 788 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 789 | " )\n", 790 | " )\n", 791 | " (1): Bottleneck(\n", 792 | " (features): Sequential(\n", 793 | " (0): BatchNorm2d(204, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 794 | " (1): ReLU(inplace)\n", 795 | " (2): Conv2d(204, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 796 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 797 | " (4): ReLU(inplace)\n", 798 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 799 | " )\n", 800 | " )\n", 801 | " (2): Bottleneck(\n", 802 | " (features): Sequential(\n", 803 | " (0): BatchNorm2d(216, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 804 | " (1): ReLU(inplace)\n", 805 | " (2): Conv2d(216, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 806 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 807 | " (4): ReLU(inplace)\n", 808 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 809 | " )\n", 810 | " )\n", 811 | " (3): Bottleneck(\n", 812 | " (features): Sequential(\n", 813 | " (0): BatchNorm2d(228, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 814 | " (1): ReLU(inplace)\n", 815 | " (2): Conv2d(228, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 816 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 817 | " (4): ReLU(inplace)\n", 818 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 819 | " )\n", 820 | " )\n", 821 | " (4): Bottleneck(\n", 822 | " (features): Sequential(\n", 823 | " (0): BatchNorm2d(240, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 824 | " (1): ReLU(inplace)\n", 825 | " (2): Conv2d(240, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 826 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 827 | " (4): ReLU(inplace)\n", 828 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 829 | " )\n", 830 | " )\n", 831 | " (5): Bottleneck(\n", 832 | " (features): Sequential(\n", 833 | " (0): BatchNorm2d(252, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 834 | " (1): ReLU(inplace)\n", 835 | " (2): Conv2d(252, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 836 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 837 | " (4): ReLU(inplace)\n", 838 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 839 | " )\n", 840 | " )\n", 841 | " (6): Bottleneck(\n", 842 | " (features): Sequential(\n", 843 | " (0): BatchNorm2d(264, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 844 | " (1): ReLU(inplace)\n", 845 | " (2): Conv2d(264, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 846 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 847 | " (4): ReLU(inplace)\n", 848 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 849 | " )\n", 850 | " )\n", 851 | " (7): Bottleneck(\n", 852 | " (features): Sequential(\n", 853 | " (0): BatchNorm2d(276, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 854 | " (1): ReLU(inplace)\n", 855 | " (2): Conv2d(276, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 856 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 857 | " (4): ReLU(inplace)\n", 858 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 859 | " )\n", 860 | " )\n", 861 | " (8): Bottleneck(\n", 862 | " (features): Sequential(\n", 863 | " (0): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 864 | " (1): ReLU(inplace)\n", 865 | " (2): Conv2d(288, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 866 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 867 | " (4): ReLU(inplace)\n", 868 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 869 | " )\n", 870 | " )\n", 871 | " (9): Bottleneck(\n", 872 | " (features): Sequential(\n", 873 | " (0): BatchNorm2d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 874 | " (1): ReLU(inplace)\n", 875 | " (2): Conv2d(300, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 876 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 877 | " (4): ReLU(inplace)\n", 878 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 879 | " )\n", 880 | " )\n", 881 | " (10): Bottleneck(\n", 882 | " (features): Sequential(\n", 883 | " (0): BatchNorm2d(312, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 884 | " (1): ReLU(inplace)\n", 885 | " (2): Conv2d(312, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 886 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 887 | " (4): ReLU(inplace)\n", 888 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 889 | " )\n", 890 | " )\n", 891 | " (11): Bottleneck(\n", 892 | " (features): Sequential(\n", 893 | " (0): BatchNorm2d(324, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 894 | " (1): ReLU(inplace)\n", 895 | " (2): Conv2d(324, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 896 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 897 | " (4): ReLU(inplace)\n", 898 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 899 | " )\n", 900 | " )\n", 901 | " (12): Bottleneck(\n", 902 | " (features): Sequential(\n", 903 | " (0): BatchNorm2d(336, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 904 | " (1): ReLU(inplace)\n", 905 | " (2): Conv2d(336, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 906 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 907 | " (4): ReLU(inplace)\n", 908 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 909 | " )\n", 910 | " )\n", 911 | " (13): Bottleneck(\n", 912 | " (features): Sequential(\n", 913 | " (0): BatchNorm2d(348, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 914 | " (1): ReLU(inplace)\n", 915 | " (2): Conv2d(348, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 916 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 917 | " (4): ReLU(inplace)\n", 918 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 919 | " )\n", 920 | " )\n", 921 | " (14): Bottleneck(\n", 922 | " (features): Sequential(\n", 923 | " (0): BatchNorm2d(360, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 924 | " (1): ReLU(inplace)\n", 925 | " (2): Conv2d(360, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 926 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 927 | " (4): ReLU(inplace)\n", 928 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 929 | " )\n", 930 | " )\n", 931 | " (15): Bottleneck(\n", 932 | " (features): Sequential(\n", 933 | " (0): BatchNorm2d(372, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 934 | " (1): ReLU(inplace)\n", 935 | " (2): Conv2d(372, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 936 | " (3): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 937 | " (4): ReLU(inplace)\n", 938 | " (5): Conv2d(48, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 939 | " )\n", 940 | " )\n", 941 | " )\n", 942 | " (avg_pool): Sequential(\n", 943 | " (0): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 944 | " (1): ReLU(inplace)\n", 945 | " (2): AvgPool2d(kernel_size=4, stride=4, padding=0)\n", 946 | " )\n", 947 | " (classifier): Linear(in_features=384, out_features=10, bias=True)\n", 948 | ")\n" 949 | ] 950 | } 951 | ], 952 | "source": [ 953 | "net = densenet_cifar().to(device)\n", 954 | "print(net)\n", 955 | "if device == 'cuda':\n", 956 | " net = nn.DataParallel(net)\n", 957 | " # 当计算图不会改变的时候（每次输入形状相同，模型不改变）的情况下可以提高性能，反之则降低性能\n", 958 | " torch.backends.cudnn.benchmark = True" 959 | ] 960 | }, 961 | { 962 | "cell_type": "code", 963 | "execution_count": 12, 964 | "metadata": { 965 | "ExecuteTime": { 966 | "end_time": "2019-03-10T06:37:40.936979Z", 967 | "start_time": "2019-03-10T06:37:40.858613Z" 968 | } 969 | }, 970 | "outputs": [ 971 | { 972 | "name": "stdout", 973 | "output_type": "stream", 974 | "text": [ 975 | "torch.Size([1, 10])\n" 976 | ] 977 | } 978 | ], 979 | "source": [ 980 | "# 测试\n", 981 | "x = torch.randn(1, 3, 32, 32).to(device)\n", 982 | "y = net(x)\n", 983 | "print(y.shape)" 984 | ] 985 | }, 986 | { 987 | "cell_type": "code", 988 | "execution_count": 13, 989 | "metadata": { 990 | "ExecuteTime": { 991 | "end_time": "2019-03-10T06:37:42.230333Z", 992 | "start_time": "2019-03-10T06:37:42.219996Z" 993 | } 994 | }, 995 | "outputs": [], 996 | "source": [ 997 | "lr = 1e-1\n", 998 | "momentum = 0.9\n", 999 | "weight_decay = 1e-4\n", 1000 | "\n", 1001 | "criterion = nn.CrossEntropyLoss()\n", 1002 | "optimizer = optim.SGD(net.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)\n", 1003 | "# 论文原文的batch_size设置为64，epoch为300，在训练到50%和75%的epoch的时候，衰减学习率为原先的1/10\n", 1004 | "scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[150, 225])" 1005 | ] 1006 | }, 1007 | { 1008 | "cell_type": "code", 1009 | "execution_count": 19, 1010 | "metadata": { 1011 | "ExecuteTime": { 1012 | "end_time": "2019-03-10T06:38:20.361979Z", 1013 | "start_time": "2019-03-10T06:38:20.350814Z" 1014 | } 1015 | }, 1016 | "outputs": [], 1017 | "source": [ 1018 | "# Training\n", 1019 | "def train(epoch):\n", 1020 | " net.train()\n", 1021 | " train_loss = 0\n", 1022 | " correct = 0\n", 1023 | " total = 0\n", 1024 | " for batch_idx, (inputs, targets) in enumerate(train_loader):\n", 1025 | " inputs, targets = inputs.to(device), targets.to(device)\n", 1026 | " optimizer.zero_grad()\n", 1027 | " outputs = net(inputs)\n", 1028 | " loss = criterion(outputs, targets)\n", 1029 | " loss.backward()\n", 1030 | " optimizer.step()\n", 1031 | "\n", 1032 | " train_loss += loss.item()\n", 1033 | " _, predicted = outputs.max(1)\n", 1034 | " total += targets.size(0)\n", 1035 | " correct += predicted.eq(targets).sum().item()\n", 1036 | " acc = 100.*correct/total\n", 1037 | " loss = train_loss / batch_idx\n", 1038 | " print('Epoch: %d, train loss: %.6f, acc: %.3f%% (%d/%d)' % (epoch, loss, acc, correct, total))\n", 1039 | " return loss" 1040 | ] 1041 | }, 1042 | { 1043 | "cell_type": "code", 1044 | "execution_count": 15, 1045 | "metadata": { 1046 | "ExecuteTime": { 1047 | "end_time": "2019-03-10T06:37:44.945716Z", 1048 | "start_time": "2019-03-10T06:37:44.937493Z" 1049 | } 1050 | }, 1051 | "outputs": [], 1052 | "source": [ 1053 | "def test(epoch):\n", 1054 | " net.eval()\n", 1055 | " test_loss = 0\n", 1056 | " correct = 0\n", 1057 | " total = 0\n", 1058 | " with torch.no_grad():\n", 1059 | " for batch_idx, (inputs, targets) in enumerate(test_loader):\n", 1060 | " inputs, targets = inputs.to(device), targets.to(device)\n", 1061 | " outputs = net(inputs)\n", 1062 | " loss = criterion(outputs, targets)\n", 1063 | "\n", 1064 | " test_loss += loss.item()\n", 1065 | " _, predicted = outputs.max(1)\n", 1066 | " total += targets.size(0)\n", 1067 | " correct += predicted.eq(targets).sum().item()\n", 1068 | " acc = 100.*correct/total\n", 1069 | " loss = test_loss / batch_idx\n", 1070 | " print('Epoch: %d, test loss: %.6f, acc: %.3f%% (%d/%d)' % (epoch, loss, acc, correct, total))\n", 1071 | " return loss" 1072 | ] 1073 | }, 1074 | { 1075 | "cell_type": "code", 1076 | "execution_count": 16, 1077 | "metadata": { 1078 | "ExecuteTime": { 1079 | "end_time": "2019-03-10T06:37:46.495365Z", 1080 | "start_time": "2019-03-10T06:37:46.488802Z" 1081 | } 1082 | }, 1083 | "outputs": [ 1084 | { 1085 | "name": "stdout", 1086 | "output_type": "stream", 1087 | "text": [ 1088 | "start_epoch: 0\n" 1089 | ] 1090 | } 1091 | ], 1092 | "source": [ 1093 | "load_model = False\n", 1094 | "if load_model:\n", 1095 | " checkpoint = torch.load('./checkpoint/densenet.ckpt')\n", 1096 | " net.load_state_dict(checkpoint['net'])\n", 1097 | " start_epoch = checkpoint['epoch']\n", 1098 | "else:\n", 1099 | " start_epoch = 0\n", 1100 | "print('start_epoch: %s' % start_epoch)" 1101 | ] 1102 | }, 1103 | { 1104 | "cell_type": "code", 1105 | "execution_count": 17, 1106 | "metadata": { 1107 | "ExecuteTime": { 1108 | "end_time": "2019-03-10T06:37:48.406359Z", 1109 | "start_time": "2019-03-10T06:37:48.399900Z" 1110 | } 1111 | }, 1112 | "outputs": [], 1113 | "source": [ 1114 | "def plot_loss(train_losses, test_losses):\n", 1115 | " plt.plot(range(len(train_losses)), train_losses)\n", 1116 | " plt.plot(range(len(test_losses)), test_losses)\n", 1117 | " plt.xlabel('epoch')\n", 1118 | " plt.ylabel('loss')\n", 1119 | " plt.show()\n", 1120 | "train_losses = []\n", 1121 | "test_losses = []" 1122 | ] 1123 | }, 1124 | { 1125 | "cell_type": "code", 1126 | "execution_count": null, 1127 | "metadata": { 1128 | "ExecuteTime": { 1129 | "start_time": "2019-03-10T06:38:35.801Z" 1130 | } 1131 | }, 1132 | "outputs": [ 1133 | { 1134 | "name": "stdout", 1135 | "output_type": "stream", 1136 | "text": [ 1137 | "Epoch: 0, train loss: 1.163450, acc: 58.200% (29100/50000)\n", 1138 | "Epoch: 0, test loss: 0.997180, acc: 65.310% (6531/10000)\n", 1139 | "Epoch: 1, train loss: 0.760592, acc: 73.428% (36714/50000)\n", 1140 | "Epoch: 1, test loss: 0.711551, acc: 75.480% (7548/10000)\n", 1141 | "Epoch: 2, train loss: 0.603602, acc: 79.096% (39548/50000)\n", 1142 | "Epoch: 2, test loss: 0.659617, acc: 77.300% (7730/10000)\n", 1143 | "Epoch: 3, train loss: 0.527196, acc: 81.718% (40859/50000)\n", 1144 | "Epoch: 3, test loss: 0.709168, acc: 76.320% (7632/10000)\n", 1145 | "Epoch: 4, train loss: 0.475196, acc: 83.478% (41739/50000)\n", 1146 | "Epoch: 4, test loss: 0.562845, acc: 80.480% (8048/10000)\n", 1147 | "Epoch: 5, train loss: 0.434821, acc: 84.848% (42424/50000)\n", 1148 | "Epoch: 5, test loss: 0.483382, acc: 83.640% (8364/10000)\n", 1149 | "Epoch: 6, train loss: 0.408296, acc: 85.716% (42858/50000)\n", 1150 | "Epoch: 6, test loss: 0.473439, acc: 83.720% (8372/10000)\n", 1151 | "Epoch: 7, train loss: 0.385241, acc: 86.788% (43394/50000)\n", 1152 | "Epoch: 7, test loss: 0.442325, acc: 84.650% (8465/10000)\n", 1153 | "Epoch: 8, train loss: 0.367403, acc: 87.112% (43556/50000)\n", 1154 | "Epoch: 8, test loss: 0.503534, acc: 83.140% (8314/10000)\n", 1155 | "Epoch: 9, train loss: 0.346510, acc: 87.904% (43952/50000)\n", 1156 | "Epoch: 9, test loss: 0.533034, acc: 82.230% (8223/10000)\n", 1157 | "Epoch: 10, train loss: 0.339283, acc: 88.162% (44081/50000)\n", 1158 | "Epoch: 10, test loss: 0.462903, acc: 84.160% (8416/10000)\n", 1159 | "Epoch: 11, train loss: 0.327718, acc: 88.554% (44277/50000)\n", 1160 | "Epoch: 11, test loss: 0.534060, acc: 82.450% (8245/10000)\n", 1161 | "Epoch: 12, train loss: 0.319798, acc: 88.876% (44438/50000)\n", 1162 | "Epoch: 12, test loss: 0.465962, acc: 84.740% (8474/10000)\n", 1163 | "Epoch: 13, train loss: 0.311612, acc: 88.990% (44495/50000)\n", 1164 | "Epoch: 13, test loss: 0.463318, acc: 84.800% (8480/10000)\n", 1165 | "Epoch: 14, train loss: 0.302549, acc: 89.312% (44656/50000)\n", 1166 | "Epoch: 14, test loss: 0.500942, acc: 83.400% (8340/10000)\n", 1167 | "Epoch: 15, train loss: 0.292496, acc: 89.814% (44907/50000)\n", 1168 | "Epoch: 15, test loss: 0.431447, acc: 86.090% (8609/10000)\n", 1169 | "Epoch: 16, train loss: 0.290126, acc: 90.010% (45005/50000)\n", 1170 | "Epoch: 16, test loss: 0.470429, acc: 84.940% (8494/10000)\n", 1171 | "Epoch: 17, train loss: 0.287817, acc: 89.946% (44973/50000)\n", 1172 | "Epoch: 17, test loss: 0.428431, acc: 85.810% (8581/10000)\n", 1173 | "Epoch: 18, train loss: 0.279154, acc: 90.290% (45145/50000)\n", 1174 | "Epoch: 18, test loss: 0.502699, acc: 83.720% (8372/10000)\n", 1175 | "Epoch: 19, train loss: 0.273938, acc: 90.538% (45269/50000)\n", 1176 | "Epoch: 19, test loss: 0.517967, acc: 83.230% (8323/10000)\n", 1177 | "Epoch: 20, train loss: 0.275465, acc: 90.272% (45136/50000)\n", 1178 | "Epoch: 20, test loss: 0.481754, acc: 84.510% (8451/10000)\n", 1179 | "Epoch: 21, train loss: 0.261919, acc: 90.798% (45399/50000)\n", 1180 | "Epoch: 21, test loss: 0.439584, acc: 85.180% (8518/10000)\n", 1181 | "Epoch: 22, train loss: 0.261067, acc: 90.662% (45331/50000)\n", 1182 | "Epoch: 22, test loss: 0.512850, acc: 83.710% (8371/10000)\n", 1183 | "Epoch: 23, train loss: 0.257232, acc: 90.938% (45469/50000)\n", 1184 | "Epoch: 23, test loss: 0.411300, acc: 86.800% (8680/10000)\n", 1185 | "Epoch: 24, train loss: 0.248675, acc: 91.314% (45657/50000)\n", 1186 | "Epoch: 24, test loss: 0.419502, acc: 86.570% (8657/10000)\n", 1187 | "Epoch: 25, train loss: 0.247615, acc: 91.298% (45649/50000)\n", 1188 | "Epoch: 25, test loss: 0.445411, acc: 85.870% (8587/10000)\n", 1189 | "Epoch: 26, train loss: 0.247457, acc: 91.364% (45682/50000)\n", 1190 | "Epoch: 26, test loss: 0.445146, acc: 85.310% (8531/10000)\n", 1191 | "Epoch: 27, train loss: 0.246592, acc: 91.348% (45674/50000)\n", 1192 | "Epoch: 27, test loss: 0.402280, acc: 86.770% (8677/10000)\n", 1193 | "Epoch: 28, train loss: 0.238067, acc: 91.732% (45866/50000)\n", 1194 | "Epoch: 28, test loss: 0.433439, acc: 85.800% (8580/10000)\n", 1195 | "Epoch: 29, train loss: 0.235148, acc: 91.764% (45882/50000)\n", 1196 | "Epoch: 29, test loss: 0.437050, acc: 85.710% (8571/10000)\n", 1197 | "Epoch: 30, train loss: 0.230329, acc: 91.894% (45947/50000)\n", 1198 | "Epoch: 30, test loss: 0.426187, acc: 86.050% (8605/10000)\n", 1199 | "Epoch: 31, train loss: 0.230735, acc: 91.998% (45999/50000)\n", 1200 | "Epoch: 31, test loss: 0.418511, acc: 86.370% (8637/10000)\n", 1201 | "Epoch: 32, train loss: 0.234096, acc: 91.856% (45928/50000)\n", 1202 | "Epoch: 32, test loss: 0.402072, acc: 86.890% (8689/10000)\n", 1203 | "Epoch: 33, train loss: 0.223134, acc: 92.096% (46048/50000)\n", 1204 | "Epoch: 33, test loss: 0.427554, acc: 86.200% (8620/10000)\n", 1205 | "Epoch: 34, train loss: 0.222646, acc: 92.278% (46139/50000)\n", 1206 | "Epoch: 34, test loss: 0.434365, acc: 86.070% (8607/10000)\n", 1207 | "Epoch: 35, train loss: 0.224359, acc: 92.066% (46033/50000)\n", 1208 | "Epoch: 35, test loss: 0.425330, acc: 86.440% (8644/10000)\n", 1209 | "Epoch: 36, train loss: 0.223161, acc: 92.114% (46057/50000)\n", 1210 | "Epoch: 36, test loss: 0.398629, acc: 87.330% (8733/10000)\n", 1211 | "Epoch: 37, train loss: 0.215266, acc: 92.472% (46236/50000)\n", 1212 | "Epoch: 37, test loss: 0.414481, acc: 86.780% (8678/10000)\n", 1213 | "Epoch: 38, train loss: 0.215169, acc: 92.472% (46236/50000)\n", 1214 | "Epoch: 38, test loss: 0.451899, acc: 85.870% (8587/10000)\n", 1215 | "Epoch: 39, train loss: 0.215403, acc: 92.316% (46158/50000)\n", 1216 | "Epoch: 39, test loss: 0.384561, acc: 87.320% (8732/10000)\n", 1217 | "Epoch: 40, train loss: 0.215092, acc: 92.374% (46187/50000)\n", 1218 | "Epoch: 40, test loss: 0.389011, acc: 87.300% (8730/10000)\n", 1219 | "Epoch: 41, train loss: 0.210861, acc: 92.496% (46248/50000)\n", 1220 | "Epoch: 41, test loss: 0.439580, acc: 86.220% (8622/10000)\n", 1221 | "Epoch: 42, train loss: 0.209750, acc: 92.658% (46329/50000)\n", 1222 | "Epoch: 42, test loss: 0.436366, acc: 85.990% (8599/10000)\n", 1223 | "Epoch: 43, train loss: 0.213210, acc: 92.528% (46264/50000)\n", 1224 | "Epoch: 43, test loss: 0.491584, acc: 84.610% (8461/10000)\n", 1225 | "Epoch: 44, train loss: 0.210037, acc: 92.576% (46288/50000)\n", 1226 | "Epoch: 44, test loss: 0.392140, acc: 87.410% (8741/10000)\n", 1227 | "Epoch: 45, train loss: 0.203262, acc: 92.816% (46408/50000)\n", 1228 | "Epoch: 45, test loss: 0.479671, acc: 85.530% (8553/10000)\n", 1229 | "Epoch: 46, train loss: 0.205852, acc: 92.744% (46372/50000)\n", 1230 | "Epoch: 46, test loss: 0.379090, acc: 87.820% (8782/10000)\n", 1231 | "Epoch: 47, train loss: 0.202170, acc: 92.892% (46446/50000)\n", 1232 | "Epoch: 47, test loss: 0.384574, acc: 87.790% (8779/10000)\n", 1233 | "Epoch: 48, train loss: 0.201121, acc: 92.830% (46415/50000)\n", 1234 | "Epoch: 48, test loss: 0.439120, acc: 85.880% (8588/10000)\n", 1235 | "Epoch: 49, train loss: 0.203012, acc: 92.916% (46458/50000)\n", 1236 | "Epoch: 49, test loss: 0.418860, acc: 86.790% (8679/10000)\n", 1237 | "Epoch: 50, train loss: 0.200329, acc: 92.936% (46468/50000)\n", 1238 | "Epoch: 50, test loss: 0.402644, acc: 87.330% (8733/10000)\n", 1239 | "Epoch: 51, train loss: 0.200843, acc: 92.880% (46440/50000)\n", 1240 | "Epoch: 51, test loss: 0.437531, acc: 86.370% (8637/10000)\n", 1241 | "Epoch: 52, train loss: 0.200076, acc: 92.936% (46468/50000)\n", 1242 | "Epoch: 52, test loss: 0.401407, acc: 87.010% (8701/10000)\n", 1243 | "Epoch: 53, train loss: 0.193615, acc: 93.288% (46644/50000)\n", 1244 | "Epoch: 53, test loss: 0.404564, acc: 87.300% (8730/10000)\n", 1245 | "Epoch: 54, train loss: 0.196320, acc: 93.202% (46601/50000)\n", 1246 | "Epoch: 54, test loss: 0.449464, acc: 85.890% (8589/10000)\n", 1247 | "Epoch: 55, train loss: 0.198791, acc: 93.134% (46567/50000)\n", 1248 | "Epoch: 55, test loss: 0.414952, acc: 86.890% (8689/10000)\n", 1249 | "Epoch: 56, train loss: 0.190236, acc: 93.390% (46695/50000)\n", 1250 | "Epoch: 56, test loss: 0.384960, acc: 87.650% (8765/10000)\n", 1251 | "Epoch: 57, train loss: 0.193136, acc: 93.260% (46630/50000)\n", 1252 | "Epoch: 57, test loss: 0.401555, acc: 87.320% (8732/10000)\n", 1253 | "Epoch: 58, train loss: 0.192281, acc: 93.198% (46599/50000)\n", 1254 | "Epoch: 58, test loss: 0.373700, acc: 88.580% (8858/10000)\n", 1255 | "Epoch: 59, train loss: 0.192742, acc: 93.172% (46586/50000)\n", 1256 | "Epoch: 59, test loss: 0.393383, acc: 87.220% (8722/10000)\n", 1257 | "Epoch: 60, train loss: 0.191544, acc: 93.314% (46657/50000)\n", 1258 | "Epoch: 60, test loss: 0.365382, acc: 88.270% (8827/10000)\n", 1259 | "Epoch: 61, train loss: 0.189115, acc: 93.356% (46678/50000)\n", 1260 | "Epoch: 61, test loss: 0.391923, acc: 87.360% (8736/10000)\n", 1261 | "Epoch: 62, train loss: 0.186783, acc: 93.390% (46695/50000)\n", 1262 | "Epoch: 62, test loss: 0.369696, acc: 88.360% (8836/10000)\n", 1263 | "Epoch: 63, train loss: 0.186200, acc: 93.500% (46750/50000)\n", 1264 | "Epoch: 63, test loss: 0.364365, acc: 88.210% (8821/10000)\n", 1265 | "Epoch: 64, train loss: 0.182635, acc: 93.626% (46813/50000)\n", 1266 | "Epoch: 64, test loss: 0.436828, acc: 86.370% (8637/10000)\n", 1267 | "Epoch: 65, train loss: 0.185962, acc: 93.460% (46730/50000)\n", 1268 | "Epoch: 65, test loss: 0.364839, acc: 88.200% (8820/10000)\n", 1269 | "Epoch: 66, train loss: 0.188501, acc: 93.366% (46683/50000)\n", 1270 | "Epoch: 66, test loss: 0.353688, acc: 88.430% (8843/10000)\n", 1271 | "Epoch: 67, train loss: 0.183773, acc: 93.372% (46686/50000)\n", 1272 | "Epoch: 67, test loss: 0.406098, acc: 87.110% (8711/10000)\n", 1273 | "Epoch: 68, train loss: 0.188085, acc: 93.454% (46727/50000)\n", 1274 | "Epoch: 68, test loss: 0.428011, acc: 86.370% (8637/10000)\n", 1275 | "Epoch: 69, train loss: 0.184473, acc: 93.428% (46714/50000)\n", 1276 | "Epoch: 69, test loss: 0.440631, acc: 85.610% (8561/10000)\n" 1277 | ] 1278 | }, 1279 | { 1280 | "name": "stdout", 1281 | "output_type": "stream", 1282 | "text": [ 1283 | "Epoch: 70, train loss: 0.190518, acc: 93.348% (46674/50000)\n", 1284 | "Epoch: 70, test loss: 0.395305, acc: 87.630% (8763/10000)\n", 1285 | "Epoch: 71, train loss: 0.180591, acc: 93.672% (46836/50000)\n", 1286 | "Epoch: 71, test loss: 0.397041, acc: 87.480% (8748/10000)\n", 1287 | "Epoch: 72, train loss: 0.186582, acc: 93.296% (46648/50000)\n", 1288 | "Epoch: 72, test loss: 0.403386, acc: 87.430% (8743/10000)\n", 1289 | "Epoch: 73, train loss: 0.177998, acc: 93.672% (46836/50000)\n", 1290 | "Epoch: 73, test loss: 0.358342, acc: 89.000% (8900/10000)\n", 1291 | "Epoch: 74, train loss: 0.178711, acc: 93.772% (46886/50000)\n", 1292 | "Epoch: 74, test loss: 0.414994, acc: 86.800% (8680/10000)\n", 1293 | "Epoch: 75, train loss: 0.182259, acc: 93.660% (46830/50000)\n", 1294 | "Epoch: 75, test loss: 0.390513, acc: 87.500% (8750/10000)\n", 1295 | "Epoch: 76, train loss: 0.179840, acc: 93.656% (46828/50000)\n", 1296 | "Epoch: 76, test loss: 0.380237, acc: 87.490% (8749/10000)\n", 1297 | "Epoch: 77, train loss: 0.177745, acc: 93.726% (46863/50000)\n", 1298 | "Epoch: 77, test loss: 0.407836, acc: 87.260% (8726/10000)\n", 1299 | "Epoch: 78, train loss: 0.176663, acc: 93.830% (46915/50000)\n", 1300 | "Epoch: 78, test loss: 0.366478, acc: 88.370% (8837/10000)\n", 1301 | "Epoch: 79, train loss: 0.178827, acc: 93.686% (46843/50000)\n", 1302 | "Epoch: 79, test loss: 0.378901, acc: 88.190% (8819/10000)\n", 1303 | "Epoch: 80, train loss: 0.175411, acc: 93.810% (46905/50000)\n", 1304 | "Epoch: 80, test loss: 0.367366, acc: 88.220% (8822/10000)\n", 1305 | "Epoch: 81, train loss: 0.175882, acc: 93.840% (46920/50000)\n", 1306 | "Epoch: 81, test loss: 0.402270, acc: 87.780% (8778/10000)\n", 1307 | "Epoch: 82, train loss: 0.173315, acc: 93.884% (46942/50000)\n", 1308 | "Epoch: 82, test loss: 0.411755, acc: 87.150% (8715/10000)\n", 1309 | "Epoch: 83, train loss: 0.174519, acc: 93.908% (46954/50000)\n", 1310 | "Epoch: 83, test loss: 0.408960, acc: 87.590% (8759/10000)\n", 1311 | "Epoch: 84, train loss: 0.178256, acc: 93.708% (46854/50000)\n", 1312 | "Epoch: 84, test loss: 0.388544, acc: 87.710% (8771/10000)\n", 1313 | "Epoch: 85, train loss: 0.171125, acc: 93.970% (46985/50000)\n", 1314 | "Epoch: 85, test loss: 0.374656, acc: 88.130% (8813/10000)\n", 1315 | "Epoch: 86, train loss: 0.169920, acc: 94.032% (47016/50000)\n", 1316 | "Epoch: 86, test loss: 0.438311, acc: 86.710% (8671/10000)\n", 1317 | "Epoch: 87, train loss: 0.175878, acc: 93.784% (46892/50000)\n", 1318 | "Epoch: 87, test loss: 0.443856, acc: 86.430% (8643/10000)\n", 1319 | "Epoch: 88, train loss: 0.174463, acc: 93.786% (46893/50000)\n", 1320 | "Epoch: 88, test loss: 0.451225, acc: 85.940% (8594/10000)\n", 1321 | "Epoch: 89, train loss: 0.169302, acc: 94.066% (47033/50000)\n", 1322 | "Epoch: 89, test loss: 0.452899, acc: 86.120% (8612/10000)\n", 1323 | "Epoch: 90, train loss: 0.176469, acc: 93.740% (46870/50000)\n", 1324 | "Epoch: 90, test loss: 0.395858, acc: 87.770% (8777/10000)\n", 1325 | "Epoch: 91, train loss: 0.171365, acc: 94.012% (47006/50000)\n", 1326 | "Epoch: 91, test loss: 0.381760, acc: 88.110% (8811/10000)\n", 1327 | "Epoch: 92, train loss: 0.170339, acc: 93.966% (46983/50000)\n", 1328 | "Epoch: 92, test loss: 0.400659, acc: 87.400% (8740/10000)\n", 1329 | "Epoch: 93, train loss: 0.168131, acc: 94.092% (47046/50000)\n", 1330 | "Epoch: 93, test loss: 0.418207, acc: 87.520% (8752/10000)\n", 1331 | "Epoch: 94, train loss: 0.169679, acc: 93.890% (46945/50000)\n", 1332 | "Epoch: 94, test loss: 0.362521, acc: 88.440% (8844/10000)\n", 1333 | "Epoch: 95, train loss: 0.165586, acc: 94.198% (47099/50000)\n", 1334 | "Epoch: 95, test loss: 0.456406, acc: 85.770% (8577/10000)\n", 1335 | "Epoch: 96, train loss: 0.167556, acc: 94.054% (47027/50000)\n", 1336 | "Epoch: 96, test loss: 0.484698, acc: 85.600% (8560/10000)\n", 1337 | "Epoch: 97, train loss: 0.171873, acc: 93.996% (46998/50000)\n", 1338 | "Epoch: 97, test loss: 0.398942, acc: 87.620% (8762/10000)\n", 1339 | "Epoch: 98, train loss: 0.168484, acc: 94.032% (47016/50000)\n", 1340 | "Epoch: 98, test loss: 0.354388, acc: 88.420% (8842/10000)\n", 1341 | "Epoch: 99, train loss: 0.157964, acc: 94.342% (47171/50000)\n", 1342 | "Epoch: 99, test loss: 0.409620, acc: 86.980% (8698/10000)\n", 1343 | "Epoch: 100, train loss: 0.167940, acc: 94.006% (47003/50000)\n", 1344 | "Epoch: 100, test loss: 0.436890, acc: 86.550% (8655/10000)\n", 1345 | "Epoch: 101, train loss: 0.162496, acc: 94.280% (47140/50000)\n", 1346 | "Epoch: 101, test loss: 0.370831, acc: 88.310% (8831/10000)\n", 1347 | "Epoch: 102, train loss: 0.165663, acc: 94.170% (47085/50000)\n", 1348 | "Epoch: 102, test loss: 0.399711, acc: 87.620% (8762/10000)\n", 1349 | "Epoch: 103, train loss: 0.165349, acc: 94.258% (47129/50000)\n", 1350 | "Epoch: 103, test loss: 0.416701, acc: 87.460% (8746/10000)\n", 1351 | "Epoch: 104, train loss: 0.167460, acc: 94.130% (47065/50000)\n", 1352 | "Epoch: 104, test loss: 0.394473, acc: 87.560% (8756/10000)\n", 1353 | "Epoch: 105, train loss: 0.165087, acc: 94.184% (47092/50000)\n", 1354 | "Epoch: 105, test loss: 0.454670, acc: 86.270% (8627/10000)\n", 1355 | "Epoch: 106, train loss: 0.169107, acc: 94.136% (47068/50000)\n", 1356 | "Epoch: 106, test loss: 0.421102, acc: 86.870% (8687/10000)\n", 1357 | "Epoch: 107, train loss: 0.159941, acc: 94.458% (47229/50000)\n", 1358 | "Epoch: 107, test loss: 0.381169, acc: 87.840% (8784/10000)\n", 1359 | "Epoch: 108, train loss: 0.167445, acc: 93.972% (46986/50000)\n", 1360 | "Epoch: 108, test loss: 0.396727, acc: 87.650% (8765/10000)\n", 1361 | "Epoch: 109, train loss: 0.157955, acc: 94.352% (47176/50000)\n", 1362 | "Epoch: 109, test loss: 0.399741, acc: 87.530% (8753/10000)\n", 1363 | "Epoch: 110, train loss: 0.157987, acc: 94.492% (47246/50000)\n", 1364 | "Epoch: 110, test loss: 0.379473, acc: 88.320% (8832/10000)\n", 1365 | "Epoch: 111, train loss: 0.162990, acc: 94.306% (47153/50000)\n", 1366 | "Epoch: 111, test loss: 0.371665, acc: 88.210% (8821/10000)\n", 1367 | "Epoch: 113, train loss: 0.165190, acc: 94.220% (47110/50000)\n", 1368 | "Epoch: 113, test loss: 0.448385, acc: 86.550% (8655/10000)\n", 1369 | "Epoch: 114, train loss: 0.159916, acc: 94.452% (47226/50000)\n", 1370 | "Epoch: 114, test loss: 0.391885, acc: 87.550% (8755/10000)\n", 1371 | "Epoch: 115, train loss: 0.162782, acc: 94.238% (47119/50000)\n", 1372 | "Epoch: 115, test loss: 0.377588, acc: 88.250% (8825/10000)\n", 1373 | "Epoch: 116, train loss: 0.161163, acc: 94.402% (47201/50000)\n", 1374 | "Epoch: 116, test loss: 0.417416, acc: 87.190% (8719/10000)\n", 1375 | "Epoch: 117, train loss: 0.159608, acc: 94.318% (47159/50000)\n", 1376 | "Epoch: 117, test loss: 0.423486, acc: 86.980% (8698/10000)\n", 1377 | "Epoch: 118, train loss: 0.162347, acc: 94.198% (47099/50000)\n", 1378 | "Epoch: 118, test loss: 0.381501, acc: 88.070% (8807/10000)\n", 1379 | "Epoch: 119, train loss: 0.157091, acc: 94.434% (47217/50000)\n", 1380 | "Epoch: 119, test loss: 0.380827, acc: 88.120% (8812/10000)\n", 1381 | "Epoch: 120, train loss: 0.160581, acc: 94.422% (47211/50000)\n", 1382 | "Epoch: 120, test loss: 0.353156, acc: 88.830% (8883/10000)\n", 1383 | "Epoch: 121, train loss: 0.153720, acc: 94.620% (47310/50000)\n", 1384 | "Epoch: 121, test loss: 0.391231, acc: 88.140% (8814/10000)\n", 1385 | "Epoch: 122, train loss: 0.165775, acc: 94.140% (47070/50000)\n", 1386 | "Epoch: 122, test loss: 0.434104, acc: 87.060% (8706/10000)\n", 1387 | "Epoch: 123, train loss: 0.157356, acc: 94.496% (47248/50000)\n", 1388 | "Epoch: 123, test loss: 0.363281, acc: 88.950% (8895/10000)\n", 1389 | "Epoch: 124, train loss: 0.162741, acc: 94.334% (47167/50000)\n", 1390 | "Epoch: 124, test loss: 0.371202, acc: 88.470% (8847/10000)\n", 1391 | "Epoch: 125, train loss: 0.162040, acc: 94.318% (47159/50000)\n", 1392 | "Epoch: 125, test loss: 0.347948, acc: 89.000% (8900/10000)\n", 1393 | "Epoch: 126, train loss: 0.155738, acc: 94.504% (47252/50000)\n", 1394 | "Epoch: 126, test loss: 0.369481, acc: 88.830% (8883/10000)\n", 1395 | "Epoch: 127, train loss: 0.156015, acc: 94.516% (47258/50000)\n", 1396 | "Epoch: 127, test loss: 0.413035, acc: 87.080% (8708/10000)\n", 1397 | "Epoch: 128, train loss: 0.157268, acc: 94.510% (47255/50000)\n", 1398 | "Epoch: 128, test loss: 0.389190, acc: 88.140% (8814/10000)\n", 1399 | "Epoch: 129, train loss: 0.157166, acc: 94.500% (47250/50000)\n", 1400 | "Epoch: 129, test loss: 0.387965, acc: 88.060% (8806/10000)\n", 1401 | "Epoch: 130, train loss: 0.152862, acc: 94.724% (47362/50000)\n", 1402 | "Epoch: 130, test loss: 0.410131, acc: 87.340% (8734/10000)\n", 1403 | "Epoch: 131, train loss: 0.158108, acc: 94.398% (47199/50000)\n", 1404 | "Epoch: 131, test loss: 0.423115, acc: 86.750% (8675/10000)\n", 1405 | "Epoch: 132, train loss: 0.152104, acc: 94.566% (47283/50000)\n", 1406 | "Epoch: 132, test loss: 0.404911, acc: 87.430% (8743/10000)\n", 1407 | "Epoch: 133, train loss: 0.163074, acc: 94.318% (47159/50000)\n", 1408 | "Epoch: 133, test loss: 0.322532, acc: 89.690% (8969/10000)\n", 1409 | "Epoch: 134, train loss: 0.149949, acc: 94.730% (47365/50000)\n", 1410 | "Epoch: 134, test loss: 0.381461, acc: 88.380% (8838/10000)\n", 1411 | "Epoch: 135, train loss: 0.155651, acc: 94.586% (47293/50000)\n", 1412 | "Epoch: 135, test loss: 0.414663, acc: 87.360% (8736/10000)\n", 1413 | "Epoch: 136, train loss: 0.157767, acc: 94.384% (47192/50000)\n", 1414 | "Epoch: 136, test loss: 0.485150, acc: 86.210% (8621/10000)\n", 1415 | "Epoch: 137, train loss: 0.153841, acc: 94.642% (47321/50000)\n", 1416 | "Epoch: 137, test loss: 0.484472, acc: 86.230% (8623/10000)\n", 1417 | "Epoch: 138, train loss: 0.161892, acc: 94.260% (47130/50000)\n", 1418 | "Epoch: 138, test loss: 0.398709, acc: 87.670% (8767/10000)\n", 1419 | "Epoch: 139, train loss: 0.154665, acc: 94.620% (47310/50000)\n", 1420 | "Epoch: 139, test loss: 0.483041, acc: 86.080% (8608/10000)\n" 1421 | ] 1422 | }, 1423 | { 1424 | "name": "stdout", 1425 | "output_type": "stream", 1426 | "text": [ 1427 | "Epoch: 140, train loss: 0.155879, acc: 94.494% (47247/50000)\n", 1428 | "Epoch: 140, test loss: 0.430733, acc: 86.960% (8696/10000)\n", 1429 | "Epoch: 141, train loss: 0.151579, acc: 94.602% (47301/50000)\n", 1430 | "Epoch: 141, test loss: 0.395767, acc: 87.710% (8771/10000)\n", 1431 | "Epoch: 142, train loss: 0.156757, acc: 94.566% (47283/50000)\n", 1432 | "Epoch: 142, test loss: 0.444177, acc: 86.650% (8665/10000)\n", 1433 | "Epoch: 143, train loss: 0.148703, acc: 94.826% (47413/50000)\n", 1434 | "Epoch: 143, test loss: 0.459451, acc: 86.780% (8678/10000)\n", 1435 | "Epoch: 144, train loss: 0.149935, acc: 94.794% (47397/50000)\n", 1436 | "Epoch: 144, test loss: 0.378492, acc: 88.170% (8817/10000)\n", 1437 | "Epoch: 145, train loss: 0.155332, acc: 94.592% (47296/50000)\n", 1438 | "Epoch: 145, test loss: 0.422908, acc: 87.470% (8747/10000)\n", 1439 | "Epoch: 146, train loss: 0.155353, acc: 94.492% (47246/50000)\n", 1440 | "Epoch: 146, test loss: 0.362810, acc: 88.470% (8847/10000)\n", 1441 | "Epoch: 147, train loss: 0.153319, acc: 94.538% (47269/50000)\n", 1442 | "Epoch: 147, test loss: 0.385522, acc: 88.000% (8800/10000)\n", 1443 | "Epoch: 148, train loss: 0.148969, acc: 94.758% (47379/50000)\n", 1444 | "Epoch: 148, test loss: 0.383983, acc: 88.500% (8850/10000)\n", 1445 | "Epoch: 149, train loss: 0.062339, acc: 97.912% (48956/50000)\n", 1446 | "Epoch: 149, test loss: 0.263980, acc: 91.920% (9192/10000)\n", 1447 | "Epoch: 150, train loss: 0.029127, acc: 99.284% (49642/50000)\n", 1448 | "Epoch: 150, test loss: 0.260401, acc: 92.040% (9204/10000)\n", 1449 | "Epoch: 151, train loss: 0.020880, acc: 99.522% (49761/50000)\n", 1450 | "Epoch: 151, test loss: 0.261280, acc: 92.230% (9223/10000)\n", 1451 | "Epoch: 152, train loss: 0.015673, acc: 99.730% (49865/50000)\n", 1452 | "Epoch: 152, test loss: 0.266151, acc: 92.410% (9241/10000)\n", 1453 | "Epoch: 153, train loss: 0.011921, acc: 99.816% (49908/50000)\n", 1454 | "Epoch: 153, test loss: 0.270290, acc: 92.500% (9250/10000)\n", 1455 | "Epoch: 154, train loss: 0.009829, acc: 99.856% (49928/50000)\n", 1456 | "Epoch: 154, test loss: 0.270581, acc: 92.490% (9249/10000)\n", 1457 | "Epoch: 155, train loss: 0.008475, acc: 99.894% (49947/50000)\n", 1458 | "Epoch: 155, test loss: 0.275643, acc: 92.560% (9256/10000)\n", 1459 | "Epoch: 156, train loss: 0.007364, acc: 99.910% (49955/50000)\n", 1460 | "Epoch: 156, test loss: 0.280351, acc: 92.440% (9244/10000)\n", 1461 | "Epoch: 157, train loss: 0.006517, acc: 99.936% (49968/50000)\n", 1462 | "Epoch: 157, test loss: 0.274400, acc: 92.570% (9257/10000)\n", 1463 | "Epoch: 158, train loss: 0.005648, acc: 99.946% (49973/50000)\n", 1464 | "Epoch: 158, test loss: 0.276397, acc: 92.360% (9236/10000)\n", 1465 | "Epoch: 159, train loss: 0.004809, acc: 99.982% (49991/50000)\n", 1466 | "Epoch: 159, test loss: 0.288880, acc: 92.390% (9239/10000)\n", 1467 | "Epoch: 160, train loss: 0.004366, acc: 99.968% (49984/50000)\n", 1468 | "Epoch: 160, test loss: 0.291416, acc: 92.500% (9250/10000)\n", 1469 | "Epoch: 161, train loss: 0.004154, acc: 99.980% (49990/50000)\n", 1470 | "Epoch: 161, test loss: 0.285466, acc: 92.620% (9262/10000)\n", 1471 | "Epoch: 162, train loss: 0.003930, acc: 99.982% (49991/50000)\n", 1472 | "Epoch: 162, test loss: 0.293289, acc: 92.490% (9249/10000)\n", 1473 | "Epoch: 163, train loss: 0.003504, acc: 99.992% (49996/50000)\n", 1474 | "Epoch: 163, test loss: 0.286675, acc: 92.690% (9269/10000)\n", 1475 | "Epoch: 164, train loss: 0.003440, acc: 99.986% (49993/50000)\n", 1476 | "Epoch: 164, test loss: 0.286325, acc: 92.490% (9249/10000)\n", 1477 | "Epoch: 165, train loss: 0.003243, acc: 99.982% (49991/50000)\n", 1478 | "Epoch: 165, test loss: 0.291497, acc: 92.430% (9243/10000)\n", 1479 | "Epoch: 166, train loss: 0.003280, acc: 99.980% (49990/50000)\n", 1480 | "Epoch: 166, test loss: 0.299244, acc: 92.640% (9264/10000)\n", 1481 | "Epoch: 167, train loss: 0.002968, acc: 99.990% (49995/50000)\n", 1482 | "Epoch: 167, test loss: 0.294573, acc: 92.800% (9280/10000)\n", 1483 | "Epoch: 168, train loss: 0.002828, acc: 99.982% (49991/50000)\n", 1484 | "Epoch: 168, test loss: 0.293774, acc: 92.770% (9277/10000)\n", 1485 | "Epoch: 169, train loss: 0.002668, acc: 99.998% (49999/50000)\n", 1486 | "Epoch: 169, test loss: 0.290554, acc: 92.630% (9263/10000)\n", 1487 | "Epoch: 170, train loss: 0.002496, acc: 99.994% (49997/50000)\n", 1488 | "Epoch: 170, test loss: 0.290370, acc: 92.510% (9251/10000)\n", 1489 | "Epoch: 171, train loss: 0.002408, acc: 99.994% (49997/50000)\n", 1490 | "Epoch: 171, test loss: 0.300495, acc: 92.500% (9250/10000)\n", 1491 | "Epoch: 172, train loss: 0.002200, acc: 99.998% (49999/50000)\n", 1492 | "Epoch: 172, test loss: 0.292341, acc: 92.580% (9258/10000)\n", 1493 | "Epoch: 173, train loss: 0.002207, acc: 99.998% (49999/50000)\n", 1494 | "Epoch: 173, test loss: 0.292034, acc: 92.650% (9265/10000)\n", 1495 | "Epoch: 174, train loss: 0.002378, acc: 99.994% (49997/50000)\n", 1496 | "Epoch: 174, test loss: 0.299515, acc: 92.520% (9252/10000)\n", 1497 | "Epoch: 175, train loss: 0.002254, acc: 99.994% (49997/50000)\n", 1498 | "Epoch: 175, test loss: 0.294994, acc: 92.460% (9246/10000)\n", 1499 | "Epoch: 176, train loss: 0.002231, acc: 99.996% (49998/50000)\n", 1500 | "Epoch: 176, test loss: 0.295152, acc: 92.720% (9272/10000)\n", 1501 | "Epoch: 177, train loss: 0.002173, acc: 99.996% (49998/50000)\n", 1502 | "Epoch: 177, test loss: 0.301303, acc: 92.600% (9260/10000)\n", 1503 | "Epoch: 178, train loss: 0.002279, acc: 99.990% (49995/50000)\n", 1504 | "Epoch: 178, test loss: 0.298958, acc: 92.720% (9272/10000)\n", 1505 | "Epoch: 179, train loss: 0.002329, acc: 99.988% (49994/50000)\n", 1506 | "Epoch: 179, test loss: 0.292918, acc: 92.850% (9285/10000)\n", 1507 | "Epoch: 180, train loss: 0.002436, acc: 99.986% (49993/50000)\n", 1508 | "Epoch: 180, test loss: 0.295259, acc: 92.760% (9276/10000)\n", 1509 | "Epoch: 181, train loss: 0.002086, acc: 99.992% (49996/50000)\n", 1510 | "Epoch: 181, test loss: 0.300273, acc: 92.540% (9254/10000)\n", 1511 | "Epoch: 182, train loss: 0.002103, acc: 99.998% (49999/50000)\n", 1512 | "Epoch: 182, test loss: 0.296968, acc: 92.640% (9264/10000)\n", 1513 | "Epoch: 183, train loss: 0.002037, acc: 99.990% (49995/50000)\n", 1514 | "Epoch: 183, test loss: 0.299436, acc: 92.500% (9250/10000)\n", 1515 | "Epoch: 184, train loss: 0.001864, acc: 99.994% (49997/50000)\n", 1516 | "Epoch: 184, test loss: 0.298051, acc: 92.700% (9270/10000)\n", 1517 | "Epoch: 185, train loss: 0.001954, acc: 99.992% (49996/50000)\n", 1518 | "Epoch: 185, test loss: 0.297904, acc: 92.640% (9264/10000)\n", 1519 | "Epoch: 186, train loss: 0.001920, acc: 99.990% (49995/50000)\n", 1520 | "Epoch: 186, test loss: 0.290781, acc: 92.600% (9260/10000)\n", 1521 | "Epoch: 187, train loss: 0.001757, acc: 99.996% (49998/50000)\n", 1522 | "Epoch: 187, test loss: 0.292783, acc: 92.670% (9267/10000)\n", 1523 | "Epoch: 188, train loss: 0.001774, acc: 99.996% (49998/50000)\n", 1524 | "Epoch: 188, test loss: 0.298439, acc: 92.640% (9264/10000)\n", 1525 | "Epoch: 189, train loss: 0.001993, acc: 99.986% (49993/50000)\n", 1526 | "Epoch: 189, test loss: 0.298943, acc: 92.580% (9258/10000)\n", 1527 | "Epoch: 190, train loss: 0.001812, acc: 99.992% (49996/50000)\n", 1528 | "Epoch: 190, test loss: 0.295284, acc: 92.720% (9272/10000)\n", 1529 | "Epoch: 191, train loss: 0.001711, acc: 100.000% (50000/50000)\n", 1530 | "Epoch: 191, test loss: 0.298296, acc: 92.560% (9256/10000)\n", 1531 | "Epoch: 192, train loss: 0.001664, acc: 100.000% (50000/50000)\n", 1532 | "Epoch: 192, test loss: 0.301590, acc: 92.510% (9251/10000)\n", 1533 | "Epoch: 193, train loss: 0.001635, acc: 99.998% (49999/50000)\n", 1534 | "Epoch: 193, test loss: 0.293102, acc: 92.700% (9270/10000)\n", 1535 | "Epoch: 194, train loss: 0.001711, acc: 99.990% (49995/50000)\n", 1536 | "Epoch: 194, test loss: 0.295347, acc: 92.650% (9265/10000)\n", 1537 | "Epoch: 195, train loss: 0.001605, acc: 100.000% (50000/50000)\n", 1538 | "Epoch: 195, test loss: 0.300421, acc: 92.520% (9252/10000)\n", 1539 | "Epoch: 196, train loss: 0.001486, acc: 99.998% (49999/50000)\n", 1540 | "Epoch: 196, test loss: 0.294230, acc: 92.610% (9261/10000)\n", 1541 | "Epoch: 197, train loss: 0.001727, acc: 99.996% (49998/50000)\n", 1542 | "Epoch: 197, test loss: 0.298494, acc: 92.650% (9265/10000)\n", 1543 | "Epoch: 198, train loss: 0.001785, acc: 99.992% (49996/50000)\n", 1544 | "Epoch: 198, test loss: 0.305580, acc: 92.540% (9254/10000)\n", 1545 | "Epoch: 199, train loss: 0.001707, acc: 99.996% (49998/50000)\n", 1546 | "Epoch: 199, test loss: 0.297951, acc: 92.690% (9269/10000)\n", 1547 | "Epoch: 200, train loss: 0.001558, acc: 100.000% (50000/50000)\n", 1548 | "Epoch: 200, test loss: 0.298765, acc: 92.690% (9269/10000)\n", 1549 | "Epoch: 201, train loss: 0.001527, acc: 99.996% (49998/50000)\n", 1550 | "Epoch: 201, test loss: 0.290905, acc: 92.810% (9281/10000)\n", 1551 | "Epoch: 202, train loss: 0.001636, acc: 99.994% (49997/50000)\n", 1552 | "Epoch: 202, test loss: 0.293313, acc: 92.760% (9276/10000)\n", 1553 | "Epoch: 203, train loss: 0.001755, acc: 99.990% (49995/50000)\n", 1554 | "Epoch: 203, test loss: 0.312466, acc: 92.640% (9264/10000)\n", 1555 | "Epoch: 204, train loss: 0.001600, acc: 99.998% (49999/50000)\n", 1556 | "Epoch: 204, test loss: 0.297926, acc: 92.690% (9269/10000)\n", 1557 | "Epoch: 205, train loss: 0.001477, acc: 99.996% (49998/50000)\n", 1558 | "Epoch: 205, test loss: 0.294550, acc: 92.480% (9248/10000)\n", 1559 | "Epoch: 206, train loss: 0.001533, acc: 99.996% (49998/50000)\n" 1560 | ] 1561 | } 1562 | ], 1563 | "source": [ 1564 | "for epoch in range(start_epoch, 300):\n", 1565 | " scheduler.step()\n", 1566 | " train_loss = train(epoch)\n", 1567 | " test_loss = test(epoch)\n", 1568 | " train_losses.append(train_loss)\n", 1569 | " test_losses.append(test_loss)\n", 1570 | " start_epoch = epoch" 1571 | ] 1572 | }, 1573 | { 1574 | "cell_type": "code", 1575 | "execution_count": 21, 1576 | "metadata": { 1577 | "ExecuteTime": { 1578 | "end_time": "2019-03-10T15:24:46.535636Z", 1579 | "start_time": "2019-03-10T15:24:46.342824Z" 1580 | } 1581 | }, 1582 | "outputs": [ 1583 | { 1584 | "data": { 1585 | "image/png": "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\n", 1586 | "text/plain": [ 1587 | "
" 1588 | ] 1589 | }, 1590 | "metadata": {}, 1591 | "output_type": "display_data" 1592 | } 1593 | ], 1594 | "source": [ 1595 | "plot_loss(train_losses, test_losses)" 1596 | ] 1597 | }, 1598 | { 1599 | "cell_type": "code", 1600 | "execution_count": 22, 1601 | "metadata": { 1602 | "ExecuteTime": { 1603 | "end_time": "2019-03-11T02:34:09.460821Z", 1604 | "start_time": "2019-03-11T02:34:09.168667Z" 1605 | } 1606 | }, 1607 | "outputs": [], 1608 | "source": [ 1609 | "save_model = True\n", 1610 | "if save_model:\n", 1611 | " state = {\n", 1612 | " 'net': net.state_dict(),\n", 1613 | " 'epoch': epoch,\n", 1614 | " }\n", 1615 | " os.makedirs('checkpoint', exist_ok=True)\n", 1616 | " torch.save(state, './checkpoint/densenet.ckpt')" 1617 | ] 1618 | }, 1619 | { 1620 | "cell_type": "code", 1621 | "execution_count": 23, 1622 | "metadata": { 1623 | "ExecuteTime": { 1624 | "end_time": "2019-03-11T02:34:27.123350Z", 1625 | "start_time": "2019-03-11T02:34:17.760205Z" 1626 | } 1627 | }, 1628 | "outputs": [ 1629 | { 1630 | "data": { 1631 | "image/png": "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\n", 1632 | "text/plain": [ 1633 | "
" 1634 | ] 1635 | }, 1636 | "metadata": {}, 1637 | "output_type": "display_data" 1638 | }, 1639 | { 1640 | "name": "stdout", 1641 | "output_type": "stream", 1642 | "text": [ 1643 | "GroundTruth: cat ship ship plane\n", 1644 | "Predicted: cat ship ship plane\n", 1645 | "Accuracy of the network on the 10000 test images: 92 %\n", 1646 | "Accuracy of plane : 96 %\n", 1647 | "Accuracy of car : 96 %\n", 1648 | "Accuracy of bird : 89 %\n", 1649 | "Accuracy of cat : 80 %\n", 1650 | "Accuracy of deer : 94 %\n", 1651 | "Accuracy of dog : 91 %\n", 1652 | "Accuracy of frog : 92 %\n", 1653 | "Accuracy of horse : 93 %\n", 1654 | "Accuracy of ship : 98 %\n", 1655 | "Accuracy of truck : 96 %\n" 1656 | ] 1657 | } 1658 | ], 1659 | "source": [ 1660 | "dataiter = iter(test_loader)\n", 1661 | "images, labels = dataiter.next()\n", 1662 | "images = images[:4]\n", 1663 | "labels = labels[:4]\n", 1664 | "# print images\n", 1665 | "imshow(torchvision.utils.make_grid(images))\n", 1666 | "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))\n", 1667 | "\n", 1668 | "outputs = net(images.to(device))\n", 1669 | "_, predicted = torch.max(outputs.cpu(), 1)\n", 1670 | "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n", 1671 | " for j in range(4)))\n", 1672 | "correct = 0\n", 1673 | "total = 0\n", 1674 | "with torch.no_grad():\n", 1675 | " for data in test_loader:\n", 1676 | " images, labels = data\n", 1677 | " images, labels = images.to(device), labels.to(device)\n", 1678 | " outputs = net(images)\n", 1679 | " _, predicted = torch.max(outputs.data, 1)\n", 1680 | " total += labels.size(0)\n", 1681 | " correct += (predicted == labels).sum().item()\n", 1682 | "\n", 1683 | "print('Accuracy of the network on the 10000 test images: %d %%' % (\n", 1684 | " 100 * correct / total))\n", 1685 | "\n", 1686 | "class_correct = list(0. for i in range(10))\n", 1687 | "class_total = list(0. for i in range(10))\n", 1688 | "with torch.no_grad():\n", 1689 | " for data in test_loader:\n", 1690 | " images, labels = data\n", 1691 | " images, labels = images.to(device), labels.to(device)\n", 1692 | " outputs = net(images)\n", 1693 | " _, predicted = torch.max(outputs, 1)\n", 1694 | " c = (predicted == labels).squeeze()\n", 1695 | " for i in range(4):\n", 1696 | " label = labels[i]\n", 1697 | " class_correct[label] += c[i].item()\n", 1698 | " class_total[label] += 1\n", 1699 | "\n", 1700 | "\n", 1701 | "for i in range(10):\n", 1702 | " print('Accuracy of %5s : %2d %%' % (\n", 1703 | " classes[i], 100 * class_correct[i] / class_total[i]))" 1704 | ] 1705 | } 1706 | ], 1707 | "metadata": { 1708 | "kernelspec": { 1709 | "display_name": "Python 3", 1710 | "language": "python", 1711 | "name": "python3" 1712 | }, 1713 | "language_info": { 1714 | "codemirror_mode": { 1715 | "name": "ipython", 1716 | "version": 3 1717 | }, 1718 | "file_extension": ".py", 1719 | "mimetype": "text/x-python", 1720 | "name": "python", 1721 | "nbconvert_exporter": "python", 1722 | "pygments_lexer": "ipython3", 1723 | "version": "3.6.3" 1724 | } 1725 | }, 1726 | "nbformat": 4, 1727 | "nbformat_minor": 2 1728 | } 1729 | -------------------------------------------------------------------------------- /LeNet.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "from __future__ import print_function\n", 10 | "\n", 11 | "import torch\n", 12 | "import torch.nn as nn\n", 13 | "import torch.optim as optim\n", 14 | "import torch.nn.functional as F\n", 15 | "import torchvision\n", 16 | "import torchvision.transforms as transforms" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 2, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "transform = transforms.Compose([\n", 26 | " transforms.ToTensor(),\n", 27 | " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", 28 | "])" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 3, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "name": "stdout", 38 | "output_type": "stream", 39 | "text": [ 40 | "Files already downloaded and verified\n", 41 | "Files already downloaded and verified\n" 42 | ] 43 | } 44 | ], 45 | "source": [ 46 | "train_set = torchvision.datasets.CIFAR10('./datasets', train=True, \n", 47 | " download=True, transform=transform)\n", 48 | "test_set = torchvision.datasets.CIFAR10('./datasets', train=False, \n", 49 | " download=True, transform=transform)\n", 50 | "\n", 51 | "train_loader = torch.utils.data.DataLoader(train_set, batch_size=4, \n", 52 | " shuffle=True, num_workers=2)\n", 53 | "test_loader = torch.utils.data.DataLoader(test_set, batch_size=4, \n", 54 | " shuffle=False, num_workers=2)\n", 55 | "\n", 56 | "classes = ('plane', 'car', 'bird', 'cat', 'deer',\n", 57 | " 'dog', 'frog', 'horse', 'ship', 'truck')" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 5, 63 | "metadata": {}, 64 | "outputs": [ 65 | { 66 | "data": { 67 | "image/png": "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\n", 68 | "text/plain": [ 69 | "
" 70 | ] 71 | }, 72 | "metadata": {}, 73 | "output_type": "display_data" 74 | } 75 | ], 76 | "source": [ 77 | "import matplotlib.pyplot as plt\n", 78 | "import numpy as np\n", 79 | "\n", 80 | "def imshow(img):\n", 81 | " img = img / 2 + 0.5\n", 82 | " plt.imshow(np.transpose(img.numpy(), (1, 2, 0)))\n", 83 | " \n", 84 | "image_iter = iter(train_loader)\n", 85 | "images, _ = image_iter.next()\n", 86 | "imshow(torchvision.utils.make_grid(images[:4]))" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 6, 92 | "metadata": {}, 93 | "outputs": [ 94 | { 95 | "name": "stdout", 96 | "output_type": "stream", 97 | "text": [ 98 | "cuda:0\n" 99 | ] 100 | } 101 | ], 102 | "source": [ 103 | "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n", 104 | "# device = torch.device('cpu')\n", 105 | "print(device)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 7, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "class LeNet(nn.Module):\n", 115 | " \n", 116 | " def __init__(self, num_classes=10):\n", 117 | " super(Net, self).__init__()\n", 118 | " self.features = nn.Sequential(\n", 119 | " nn.Conv2d(in_channels=3, out_channels=6, kernel_size=5),\n", 120 | " nn.ReLU(inplace=True),\n", 121 | " nn.MaxPool2d(kernel_size=2, stride=2),\n", 122 | " nn.Conv2d(6, 16, 5),\n", 123 | " nn.ReLU(True),\n", 124 | " nn.MaxPool2d(2, 2),\n", 125 | " )\n", 126 | " self.classifier = nn.Sequential(\n", 127 | " nn.Linear(16 * 5 * 5, 120),\n", 128 | " nn.ReLU(True),\n", 129 | " nn.Linear(120, 84),\n", 130 | " nn.ReLU(True),\n", 131 | " nn.Linear(84, num_classes),\n", 132 | " )\n", 133 | " \n", 134 | " def forward(self, x):\n", 135 | " x = self.features(x)\n", 136 | " x = x.view(-1, 16 * 5 * 5)\n", 137 | " x = self.classifier(x)\n", 138 | " return x" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 8, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "Net(\n", 151 | " (features): Sequential(\n", 152 | " (0): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n", 153 | " (1): ReLU(inplace)\n", 154 | " (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", 155 | " (3): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n", 156 | " (4): ReLU(inplace)\n", 157 | " (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", 158 | " )\n", 159 | " (classifier): Sequential(\n", 160 | " (0): Linear(in_features=400, out_features=120, bias=True)\n", 161 | " (1): ReLU(inplace)\n", 162 | " (2): Linear(in_features=120, out_features=84, bias=True)\n", 163 | " (3): ReLU(inplace)\n", 164 | " (4): Linear(in_features=84, out_features=10, bias=True)\n", 165 | " )\n", 166 | ")\n" 167 | ] 168 | } 169 | ], 170 | "source": [ 171 | "net = LeNet().to(device)\n", 172 | "print(net)" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 9, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "learning_rate = 1e-3\n", 182 | "momentum = 0.9\n", 183 | "criterion = nn.CrossEntropyLoss()\n", 184 | "optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 10, 190 | "metadata": {}, 191 | "outputs": [ 192 | { 193 | "name": "stdout", 194 | "output_type": "stream", 195 | "text": [ 196 | "[1, 2000] loss: 2.200\n", 197 | "[1, 4000] loss: 4.062\n", 198 | "[1, 6000] loss: 5.725\n", 199 | "[1, 8000] loss: 7.295\n", 200 | "[1, 10000] loss: 8.812\n", 201 | "[1, 12000] loss: 10.266\n", 202 | "[2, 2000] loss: 1.373\n", 203 | "[2, 4000] loss: 2.728\n", 204 | "[2, 6000] loss: 4.054\n", 205 | "[2, 8000] loss: 5.368\n", 206 | "[2, 10000] loss: 6.659\n", 207 | "[2, 12000] loss: 7.946\n", 208 | "Finished Training\n" 209 | ] 210 | } 211 | ], 212 | "source": [ 213 | "for epoch in range(2):\n", 214 | " running_loss = 0.0\n", 215 | " for i, data in enumerate(train_loader, 0):\n", 216 | " inputs, labels = data\n", 217 | " inputs, labels = inputs.to(device), labels.to(device)\n", 218 | " optimizer.zero_grad()\n", 219 | " outputs = net(inputs)\n", 220 | " loss = criterion(outputs, labels)\n", 221 | " loss.backward()\n", 222 | " optimizer.step()\n", 223 | " \n", 224 | " running_loss += loss.item()\n", 225 | " if i % 2000 == 1999: # print every 2000 mini-batches\n", 226 | " print('[%d, %5d] loss: %.3f' %\n", 227 | " (epoch + 1, i + 1, running_loss / 2000))\n", 228 | " running_loss = 0.0\n", 229 | " \n", 230 | "print('Finished Training')" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 11, 236 | "metadata": {}, 237 | "outputs": [ 238 | { 239 | "name": "stdout", 240 | "output_type": "stream", 241 | "text": [ 242 | "GroundTruth: cat ship ship plane\n" 243 | ] 244 | }, 245 | { 246 | "data": { 247 | "image/png": "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\n", 248 | "text/plain": [ 249 | "
" 250 | ] 251 | }, 252 | "metadata": {}, 253 | "output_type": "display_data" 254 | } 255 | ], 256 | "source": [ 257 | "dataiter = iter(test_loader)\n", 258 | "images, labels = dataiter.next()\n", 259 | "images = images[:4]\n", 260 | "labels = labels[:4]\n", 261 | "# print images\n", 262 | "imshow(torchvision.utils.make_grid(images))\n", 263 | "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 12, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "name": "stdout", 273 | "output_type": "stream", 274 | "text": [ 275 | "Predicted: cat ship ship plane\n" 276 | ] 277 | } 278 | ], 279 | "source": [ 280 | "outputs = net(images.to(device))\n", 281 | "_, predicted = torch.max(outputs.cpu(), 1)\n", 282 | "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n", 283 | " for j in range(4)))" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 13, 289 | "metadata": {}, 290 | "outputs": [ 291 | { 292 | "name": "stdout", 293 | "output_type": "stream", 294 | "text": [ 295 | "Accuracy of the network on the 10000 test images: 54 %\n" 296 | ] 297 | } 298 | ], 299 | "source": [ 300 | "correct = 0\n", 301 | "total = 0\n", 302 | "with torch.no_grad():\n", 303 | " for data in test_loader:\n", 304 | " images, labels = data\n", 305 | " images, labels = images.to(device), labels.to(device)\n", 306 | " outputs = net(images)\n", 307 | " _, predicted = torch.max(outputs.data, 1)\n", 308 | " total += labels.size(0)\n", 309 | " correct += (predicted == labels).sum().item()\n", 310 | "\n", 311 | "print('Accuracy of the network on the 10000 test images: %d %%' % (\n", 312 | " 100 * correct / total))" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": 14, 318 | "metadata": {}, 319 | "outputs": [ 320 | { 321 | "name": "stdout", 322 | "output_type": "stream", 323 | "text": [ 324 | "Accuracy of plane : 76 %\n", 325 | "Accuracy of car : 46 %\n", 326 | "Accuracy of bird : 40 %\n", 327 | "Accuracy of cat : 26 %\n", 328 | "Accuracy of deer : 38 %\n", 329 | "Accuracy of dog : 50 %\n", 330 | "Accuracy of frog : 65 %\n", 331 | "Accuracy of horse : 60 %\n", 332 | "Accuracy of ship : 71 %\n", 333 | "Accuracy of truck : 68 %\n" 334 | ] 335 | } 336 | ], 337 | "source": [ 338 | "class_correct = list(0. for i in range(10))\n", 339 | "class_total = list(0. for i in range(10))\n", 340 | "with torch.no_grad():\n", 341 | " for data in test_loader:\n", 342 | " images, labels = data\n", 343 | " images, labels = images.to(device), labels.to(device)\n", 344 | " outputs = net(images)\n", 345 | " _, predicted = torch.max(outputs, 1)\n", 346 | " c = (predicted == labels).squeeze()\n", 347 | " for i in range(4):\n", 348 | " label = labels[i]\n", 349 | " class_correct[label] += c[i].item()\n", 350 | " class_total[label] += 1\n", 351 | "\n", 352 | "\n", 353 | "for i in range(10):\n", 354 | " print('Accuracy of %5s : %2d %%' % (\n", 355 | " classes[i], 100 * class_correct[i] / class_total[i]))" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": null, 361 | "metadata": {}, 362 | "outputs": [], 363 | "source": [] 364 | } 365 | ], 366 | "metadata": { 367 | "kernelspec": { 368 | "display_name": "Python 3", 369 | "language": "python", 370 | "name": "python3" 371 | }, 372 | "language_info": { 373 | "codemirror_mode": { 374 | "name": "ipython", 375 | "version": 3 376 | }, 377 | "file_extension": ".py", 378 | "mimetype": "text/x-python", 379 | "name": "python", 380 | "nbconvert_exporter": "python", 381 | "pygments_lexer": "ipython3", 382 | "version": "3.6.3" 383 | } 384 | }, 385 | "nbformat": 4, 386 | "nbformat_minor": 2 387 | } 388 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## PyTorch-Cifar10-Notebook 2 | 3 | Training LeNet, VGG, ResNet, DenseNet on CIFAR10 with PyTorch. 4 | 5 | --------------------------------------------------------------------------------