├── LICENSE ├── README.md └── pytorch-resnet50-starter.ipynb /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Pytorch Transfer Learning image Classification 2 | This is my sample kernel for the kaggle competition iMet Collection 2019 - FGVC6 (Recognize artwork attributes from The Metropolitan Museum of Art) 3 | ### Highlights of this project: 4 | * Pytorch 5 | * Pytorch custom data class 6 | * Transfer learning (Resnet50) 7 | * Multi label classification 8 | * 1103 categories of labels 9 | -------------------------------------------------------------------------------- /pytorch-resnet50-starter.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", 8 | "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" 9 | }, 10 | "outputs": [], 11 | "source": [ 12 | "%matplotlib inline\n", 13 | "\n", 14 | "import os\n", 15 | "import time\n", 16 | "import copy\n", 17 | "import pandas as pd\n", 18 | "import numpy as np\n", 19 | "\n", 20 | "from random import seed\n", 21 | "from random import randint\n", 22 | "import random\n", 23 | "\n", 24 | "import torch\n", 25 | "from torch import nn\n", 26 | "from torch import optim\n", 27 | "import torch.nn.functional as F\n", 28 | "from torchvision import datasets, transforms, models\n", 29 | "\n", 30 | "from PIL import Image\n", 31 | "from matplotlib import pyplot as plt\n", 32 | "\n", 33 | "import warnings\n", 34 | "warnings.filterwarnings(\"ignore\")\n", 35 | "\n", 36 | "from tqdm import tqdm_notebook as tqdm\n", 37 | "\n", 38 | "\n", 39 | "input_dir = os.path.join('..','input','imet-2019-fgvc6')\n", 40 | "train_dir = os.path.join(input_dir,'train')\n", 41 | "test_dir = os.path.join(input_dir,'test')\n", 42 | "labels_csv= os.path.join(input_dir,'labels.csv')\n", 43 | "train_csv = os.path.join(input_dir,'train.csv')\n", 44 | "resnet_weights_path = os.path.join('..','input','resnet50','resnet50.pth')" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 2, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "def seed_all(seed=27):\n", 54 | " \"\"\"https://pytorch.org/docs/stable/notes/randomness.html\"\"\"\n", 55 | " random.seed(seed)\n", 56 | " os.environ['PYTHONHASHSEED'] = str(seed)\n", 57 | " np.random.seed(seed)\n", 58 | " torch.manual_seed(seed)\n", 59 | " torch.cuda.manual_seed(seed)\n", 60 | " torch.backends.cudnn.deterministic = True\n", 61 | "seed_all(27)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 3, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "BATCH_SIZE = 128\n", 71 | "NUM_EPOCHS = 20\n", 72 | "PERCENTILE = 99.7\n", 73 | "LEARNING_RATE = 0.0001\n", 74 | "DISABLE_TQDM = True" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 4, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 5, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [ 92 | "df = pd.read_csv(labels_csv)\n", 93 | "attribute_dict = dict(zip(df.attribute_id,df.attribute_name))\n", 94 | "del df,labels_csv" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 6, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "name": "stdout", 104 | "output_type": "stream", 105 | "text": [ 106 | "total_categories: 1103\n", 107 | "tag_categories: 705 \n", 108 | "culture_categories: 398 \n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "tag_count = 0 \n", 114 | "culture_count = 0\n", 115 | "for idx,data in attribute_dict.items():\n", 116 | " if data.split(\"::\")[0] == 'tag':\n", 117 | " tag_count+=1\n", 118 | " if data.split(\"::\")[0] == 'culture':\n", 119 | " culture_count+=1\n", 120 | "print('total_categories: {0}\\ntag_categories: {1} \\nculture_categories: {2} ' \\\n", 121 | " .format(len(attribute_dict),tag_count,culture_count))\n", 122 | "#cross check your results\n", 123 | "assert tag_count+culture_count == len(attribute_dict)\n", 124 | "output_dim = len(attribute_dict) " 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 7, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [ 133 | "df = pd.read_csv(train_csv)\n", 134 | "labels_dict = dict(zip(df.id,df.attribute_ids))" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 8, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "culture::assyrian\n", 147 | "tag::decorative elements\n" 148 | ] 149 | }, 150 | { 151 | "data": { 152 | "image/png": "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\n", 153 | "text/plain": [ 154 | "
" 155 | ] 156 | }, 157 | "metadata": {}, 158 | "output_type": "display_data" 159 | } 160 | ], 161 | "source": [ 162 | "idx = len(os.listdir(train_dir))\n", 163 | "number = randint(0,idx)\n", 164 | "image_name = os.listdir(train_dir)[number]\n", 165 | "def imshow(image):\n", 166 | " plt.figure(figsize=(6, 6))\n", 167 | " plt.imshow(image)\n", 168 | " plt.show()\n", 169 | "# Example image\n", 170 | "x = Image.open(os.path.join(train_dir,image_name))\n", 171 | "for i in labels_dict[os.listdir(train_dir)[number].split('.')[0]].split():\n", 172 | " print(attribute_dict[int(i)])\n", 173 | "np.array(x).shape\n", 174 | "imshow(x)" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 9, 180 | "metadata": {}, 181 | "outputs": [], 182 | "source": [ 183 | "# need to add more transforms here\n", 184 | "data_transforms = transforms.Compose([\n", 185 | " transforms.Resize((224,224)),\n", 186 | " transforms.ToTensor(),\n", 187 | " ])" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "# Custom Dataset class" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": 10, 200 | "metadata": {}, 201 | "outputs": [], 202 | "source": [ 203 | "from torch.utils import data\n", 204 | "class ImageData(data.Dataset):\n", 205 | " def __init__(self,df,dirpath,transform,test = False):\n", 206 | " self.df = df\n", 207 | " self.test = test\n", 208 | " self.dirpath = dirpath\n", 209 | " self.conv_to_tensor = transform\n", 210 | " #image data \n", 211 | " if not self.test:\n", 212 | " self.image_arr = np.asarray(str(self.dirpath)+'/'+self.df.iloc[:, 0]+'.png')\n", 213 | " else:\n", 214 | " self.image_arr = np.asarray(str(self.dirpath)+'/'+self.df.iloc[:, 0])\n", 215 | " \n", 216 | " #labels data\n", 217 | " if not self.test:\n", 218 | " self.label_df = self.df.iloc[:,1]\n", 219 | " \n", 220 | " # Calculate length of df\n", 221 | " self.data_len = len(self.df.index)\n", 222 | "\n", 223 | " def __len__(self):\n", 224 | " return self.data_len\n", 225 | " \n", 226 | " def __getitem__(self, idx):\n", 227 | " image_name = self.image_arr[idx]\n", 228 | " img = Image.open(image_name)\n", 229 | " img_tensor = self.conv_to_tensor(img)\n", 230 | " if not self.test:\n", 231 | " image_labels = self.label_df[idx]\n", 232 | " label_tensor = torch.zeros((1, output_dim))\n", 233 | " for label in image_labels.split():\n", 234 | " label_tensor[0, int(label)] = 1\n", 235 | " image_label = torch.tensor(label_tensor,dtype= torch.float32)\n", 236 | " return (img_tensor,image_label.squeeze())\n", 237 | " return (img_tensor)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 11, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "name": "stdout", 247 | "output_type": "stream", 248 | "text": [ 249 | "Validation_Data Length: 21848\n", 250 | " Train_Data Length: 87389\n" 251 | ] 252 | } 253 | ], 254 | "source": [ 255 | "df = pd.read_csv(train_csv)\n", 256 | "# if you want to run on less data to quickly check\n", 257 | "#df = pd.read_csv(train_csv).head(5000)\n", 258 | "from sklearn.model_selection import train_test_split\n", 259 | "train_df,val_df = train_test_split(df, test_size=0.20)\n", 260 | "train_df = train_df.reset_index(drop=True)\n", 261 | "val_df = val_df.reset_index(drop=True)\n", 262 | "print(f\"Validation_Data Length: {len(val_df)}\\n Train_Data Length: {len(train_df)}\")" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 12, 268 | "metadata": {}, 269 | "outputs": [], 270 | "source": [ 271 | "# Train dataset\n", 272 | "train_dataset = ImageData(train_df,train_dir,data_transforms)\n", 273 | "train_loader = data.DataLoader(dataset=train_dataset,batch_size=BATCH_SIZE,shuffle=False)\n", 274 | "\n", 275 | "# validation dataset\n", 276 | "val_dataset = ImageData(val_df,train_dir,data_transforms)\n", 277 | "val_loader = data.DataLoader(dataset=val_dataset,batch_size=BATCH_SIZE,shuffle=False)\n", 278 | "\n", 279 | "# test dataset\n", 280 | "test_df = pd.DataFrame(os.listdir(test_dir))\n", 281 | "test_dataset = ImageData(test_df,test_dir,data_transforms,test = True)\n", 282 | "test_loader = data.DataLoader(dataset=test_dataset,batch_size=BATCH_SIZE,shuffle=False)\n", 283 | "\n", 284 | "dataloaders_dict = {'train':train_loader, 'val':val_loader}" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 13, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "name": "stdout", 294 | "output_type": "stream", 295 | "text": [ 296 | "Train Features: torch.Size([128, 3, 224, 224])\n", 297 | "Train Labels: torch.Size([128, 1103])\n", 298 | "\n", 299 | "Validation Features: torch.Size([128, 3, 224, 224])\n", 300 | "Validation Labels: torch.Size([128, 1103])\n", 301 | "\n", 302 | "Test Features: torch.Size([128, 3, 224, 224])\n", 303 | "\n" 304 | ] 305 | } 306 | ], 307 | "source": [ 308 | "features, labels = next(iter(train_loader))\n", 309 | "print(f'Train Features: {features.shape}\\nTrain Labels: {labels.shape}')\n", 310 | "print()\n", 311 | "features, labels = next(iter(val_loader))\n", 312 | "print(f'Validation Features: {features.shape}\\nValidation Labels: {labels.shape}')\n", 313 | "print()\n", 314 | "features = next(iter(test_loader))\n", 315 | "print(f'Test Features: {features.shape}\\n')" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "# Model Using Resnet50" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 14, 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [ 331 | "resnet_cls = models.resnet50()\n", 332 | "resnet_cls.load_state_dict(torch.load(resnet_weights_path))\n", 333 | "\n", 334 | "class AvgPool(nn.Module):\n", 335 | " def forward(self, x):\n", 336 | " return F.avg_pool2d(x, x.shape[2:])\n", 337 | " \n", 338 | "class ResNet50(nn.Module):\n", 339 | " def __init__(self,num_outputs):\n", 340 | " super(ResNet50,self).__init__()\n", 341 | " self.resnet = resnet_cls\n", 342 | " layer4 = self.resnet.layer4\n", 343 | " self.resnet.layer4 = nn.Sequential(\n", 344 | " nn.Dropout(0.5),\n", 345 | " layer4\n", 346 | " )\n", 347 | " self.resnet.avgpool = AvgPool()\n", 348 | " self.resnet.fc = nn.Linear(2048, num_outputs)\n", 349 | " for param in self.resnet.parameters():\n", 350 | " param.requires_grad = False\n", 351 | "\n", 352 | " for param in self.resnet.layer4.parameters():\n", 353 | " param.requires_grad = True\n", 354 | "\n", 355 | " for param in self.resnet.fc.parameters():\n", 356 | " param.requires_grad = True\n", 357 | " \n", 358 | " def forward(self,x):\n", 359 | " out = self.resnet(x)\n", 360 | " return out\n", 361 | " \n", 362 | "NeuralNet = ResNet50(num_outputs = output_dim) " 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "execution_count": 15, 368 | "metadata": {}, 369 | "outputs": [ 370 | { 371 | "data": { 372 | "text/plain": [ 373 | "ResNet50(\n", 374 | " (resnet): ResNet(\n", 375 | " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", 376 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 377 | " (relu): ReLU(inplace)\n", 378 | " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", 379 | " (layer1): Sequential(\n", 380 | " (0): Bottleneck(\n", 381 | " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 382 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 383 | " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 384 | " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 385 | " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 386 | " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 387 | " (relu): ReLU(inplace)\n", 388 | " (downsample): Sequential(\n", 389 | " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 390 | " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 391 | " )\n", 392 | " )\n", 393 | " (1): Bottleneck(\n", 394 | " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 395 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 396 | " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 397 | " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 398 | " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 399 | " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 400 | " (relu): ReLU(inplace)\n", 401 | " )\n", 402 | " (2): Bottleneck(\n", 403 | " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 404 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 405 | " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 406 | " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 407 | " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 408 | " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 409 | " (relu): ReLU(inplace)\n", 410 | " )\n", 411 | " )\n", 412 | " (layer2): Sequential(\n", 413 | " (0): Bottleneck(\n", 414 | " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 415 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 416 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", 417 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 418 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 419 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 420 | " (relu): ReLU(inplace)\n", 421 | " (downsample): Sequential(\n", 422 | " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", 423 | " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 424 | " )\n", 425 | " )\n", 426 | " (1): Bottleneck(\n", 427 | " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 428 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 429 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 430 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 431 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 432 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 433 | " (relu): ReLU(inplace)\n", 434 | " )\n", 435 | " (2): Bottleneck(\n", 436 | " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 437 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 438 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 439 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 440 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 441 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 442 | " (relu): ReLU(inplace)\n", 443 | " )\n", 444 | " (3): Bottleneck(\n", 445 | " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 446 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 447 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 448 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 449 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 450 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 451 | " (relu): ReLU(inplace)\n", 452 | " )\n", 453 | " )\n", 454 | " (layer3): Sequential(\n", 455 | " (0): Bottleneck(\n", 456 | " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 457 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 458 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", 459 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 460 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 461 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 462 | " (relu): ReLU(inplace)\n", 463 | " (downsample): Sequential(\n", 464 | " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", 465 | " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 466 | " )\n", 467 | " )\n", 468 | " (1): Bottleneck(\n", 469 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 470 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 471 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 472 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 473 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 474 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 475 | " (relu): ReLU(inplace)\n", 476 | " )\n", 477 | " (2): Bottleneck(\n", 478 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 479 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 480 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 481 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 482 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 483 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 484 | " (relu): ReLU(inplace)\n", 485 | " )\n", 486 | " (3): Bottleneck(\n", 487 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 488 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 489 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 490 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 491 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 492 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 493 | " (relu): ReLU(inplace)\n", 494 | " )\n", 495 | " (4): Bottleneck(\n", 496 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 497 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 498 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 499 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 500 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 501 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 502 | " (relu): ReLU(inplace)\n", 503 | " )\n", 504 | " (5): Bottleneck(\n", 505 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 506 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 507 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 508 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 509 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 510 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 511 | " (relu): ReLU(inplace)\n", 512 | " )\n", 513 | " )\n", 514 | " (layer4): Sequential(\n", 515 | " (0): Dropout(p=0.5)\n", 516 | " (1): Sequential(\n", 517 | " (0): Bottleneck(\n", 518 | " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 519 | " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 520 | " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", 521 | " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 522 | " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 523 | " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 524 | " (relu): ReLU(inplace)\n", 525 | " (downsample): Sequential(\n", 526 | " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", 527 | " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 528 | " )\n", 529 | " )\n", 530 | " (1): Bottleneck(\n", 531 | " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 532 | " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 533 | " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 534 | " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 535 | " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 536 | " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 537 | " (relu): ReLU(inplace)\n", 538 | " )\n", 539 | " (2): Bottleneck(\n", 540 | " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 541 | " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 542 | " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 543 | " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 544 | " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 545 | " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 546 | " (relu): ReLU(inplace)\n", 547 | " )\n", 548 | " )\n", 549 | " )\n", 550 | " (avgpool): AvgPool()\n", 551 | " (fc): Linear(in_features=2048, out_features=1103, bias=True)\n", 552 | " )\n", 553 | ")" 554 | ] 555 | }, 556 | "execution_count": 15, 557 | "metadata": {}, 558 | "output_type": "execute_result" 559 | } 560 | ], 561 | "source": [ 562 | "NeuralNet" 563 | ] 564 | }, 565 | { 566 | "cell_type": "code", 567 | "execution_count": 16, 568 | "metadata": {}, 569 | "outputs": [ 570 | { 571 | "name": "stdout", 572 | "output_type": "stream", 573 | "text": [ 574 | "25,768,079 total parameters.\n", 575 | "17,224,783 training parameters.\n" 576 | ] 577 | } 578 | ], 579 | "source": [ 580 | "total_params = sum(p.numel() for p in NeuralNet.parameters())\n", 581 | "print(f'{total_params:,} total parameters.')\n", 582 | "total_trainable_params = sum(p.numel() for p in NeuralNet.parameters() if p.requires_grad)\n", 583 | "print(f'{total_trainable_params:,} training parameters.')" 584 | ] 585 | }, 586 | { 587 | "cell_type": "code", 588 | "execution_count": 17, 589 | "metadata": {}, 590 | "outputs": [ 591 | { 592 | "name": "stdout", 593 | "output_type": "stream", 594 | "text": [ 595 | "TRAINING\n", 596 | "training examples: 87389\n", 597 | "batch size: 128\n", 598 | "batches available: 683\n", 599 | "\n", 600 | "TESTING\n", 601 | "validation examples: 21848\n", 602 | "batch size: 128\n", 603 | "batches available: 171\n", 604 | "\n", 605 | "VALIDATION\n", 606 | "testing examples: 7443\n", 607 | "batch size: 128\n", 608 | "batches available: 59\n" 609 | ] 610 | } 611 | ], 612 | "source": [ 613 | "print(\"TRAINING\")\n", 614 | "print(\"training examples: \",len(train_dataset))\n", 615 | "print(\"batch size: \",BATCH_SIZE)\n", 616 | "print(\"batches available: \",len(train_loader))\n", 617 | "print()\n", 618 | "print(\"TESTING\")\n", 619 | "print(\"validation examples: \",len(val_dataset))\n", 620 | "print(\"batch size: \",BATCH_SIZE)\n", 621 | "print(\"batches available: \",len(val_loader))\n", 622 | "print()\n", 623 | "print(\"VALIDATION\")\n", 624 | "print(\"testing examples: \",len(test_dataset))\n", 625 | "print(\"batch size: \",BATCH_SIZE)\n", 626 | "print(\"batches available: \",len(test_loader))" 627 | ] 628 | }, 629 | { 630 | "cell_type": "markdown", 631 | "metadata": {}, 632 | "source": [ 633 | "# Train the Model" 634 | ] 635 | }, 636 | { 637 | "cell_type": "code", 638 | "execution_count": 18, 639 | "metadata": {}, 640 | "outputs": [ 641 | { 642 | "name": "stdout", 643 | "output_type": "stream", 644 | "text": [ 645 | "Phase: train | Epoch: 1/20 | train_loss:0.02759083 | Time: 1020.3523s\n", 646 | "model val_loss Improved from inf to 0.01205008\n", 647 | "Phase: val | Epoch: 1/20 | val_loss:0.01205008 | Time: 242.5033s\n", 648 | "Phase: train | Epoch: 2/20 | train_loss:0.01108181 | Time: 1019.1168s\n", 649 | "model val_loss Improved from 0.01205008 to 0.01037972\n", 650 | "Phase: val | Epoch: 2/20 | val_loss:0.01037972 | Time: 235.0539s\n", 651 | "Phase: train | Epoch: 3/20 | train_loss:0.00987623 | Time: 974.0747s\n", 652 | "model val_loss Improved from 0.01037972 to 0.00965139\n", 653 | "Phase: val | Epoch: 3/20 | val_loss:0.00965139 | Time: 229.2483s\n", 654 | "Phase: train | Epoch: 4/20 | train_loss:0.00913306 | Time: 985.1822s\n", 655 | "model val_loss Improved from 0.00965139 to 0.00927821\n", 656 | "Phase: val | Epoch: 4/20 | val_loss:0.00927821 | Time: 230.8872s\n", 657 | "Phase: train | Epoch: 5/20 | train_loss:0.00857142 | Time: 981.3410s\n", 658 | "model val_loss Improved from 0.00927821 to 0.00903705\n", 659 | "Phase: val | Epoch: 5/20 | val_loss:0.00903705 | Time: 228.4492s\n", 660 | "Phase: train | Epoch: 6/20 | train_loss:0.00809647 | Time: 977.3055s\n", 661 | "model val_loss Improved from 0.00903705 to 0.00891332\n", 662 | "Phase: val | Epoch: 6/20 | val_loss:0.00891332 | Time: 232.7572s\n", 663 | "Phase: train | Epoch: 7/20 | train_loss:0.00767191 | Time: 978.3559s\n", 664 | "model val_loss Improved from 0.00891332 to 0.00883641\n", 665 | "Phase: val | Epoch: 7/20 | val_loss:0.00883641 | Time: 230.9421s\n", 666 | "Phase: train | Epoch: 8/20 | train_loss:0.00728203 | Time: 970.8857s\n", 667 | "model val_loss Improved from 0.00883641 to 0.00880080\n", 668 | "Phase: val | Epoch: 8/20 | val_loss:0.00880080 | Time: 228.9912s\n", 669 | "Phase: train | Epoch: 9/20 | train_loss:0.00691778 | Time: 960.9457s\n", 670 | "Phase: val | Epoch: 9/20 | val_loss:0.00885041 | Time: 228.8472s\n", 671 | "Phase: train | Epoch: 10/20 | train_loss:0.00656370 | Time: 961.6056s\n", 672 | "Phase: val | Epoch: 10/20 | val_loss:0.00894096 | Time: 226.4677s\n", 673 | "Phase: train | Epoch: 11/20 | train_loss:0.00623539 | Time: 978.5004s\n", 674 | "Phase: val | Epoch: 11/20 | val_loss:0.00897319 | Time: 225.8588s\n", 675 | "Phase: train | Epoch: 12/20 | train_loss:0.00572551 | Time: 966.0341s\n", 676 | "model val_loss Improved from 0.00880080 to 0.00869350\n", 677 | "Phase: val | Epoch: 12/20 | val_loss:0.00869350 | Time: 224.9203s\n", 678 | "Phase: train | Epoch: 13/20 | train_loss:0.00553604 | Time: 960.7631s\n", 679 | "Phase: val | Epoch: 13/20 | val_loss:0.00869544 | Time: 224.7910s\n", 680 | "Phase: train | Epoch: 14/20 | train_loss:0.00544243 | Time: 966.4869s\n", 681 | "Phase: val | Epoch: 14/20 | val_loss:0.00870903 | Time: 227.0596s\n", 682 | "Phase: train | Epoch: 15/20 | train_loss:0.00536984 | Time: 965.9445s\n", 683 | "Phase: val | Epoch: 15/20 | val_loss:0.00872658 | Time: 228.9651s\n", 684 | "Phase: train | Epoch: 16/20 | train_loss:0.00528060 | Time: 972.3011s\n", 685 | "model val_loss Improved from 0.00869350 to 0.00868408\n", 686 | "Phase: val | Epoch: 16/20 | val_loss:0.00868408 | Time: 226.7299s\n", 687 | "Phase: train | Epoch: 17/20 | train_loss:0.00525970 | Time: 961.6806s\n", 688 | "model val_loss Improved from 0.00868408 to 0.00868126\n", 689 | "Phase: val | Epoch: 17/20 | val_loss:0.00868126 | Time: 223.1173s\n", 690 | "Phase: train | Epoch: 18/20 | train_loss:0.00524516 | Time: 959.7015s\n", 691 | "model val_loss Improved from 0.00868126 to 0.00868042\n", 692 | "Phase: val | Epoch: 18/20 | val_loss:0.00868042 | Time: 224.9494s\n", 693 | "Phase: train | Epoch: 19/20 | train_loss:0.00523335 | Time: 962.3714s\n", 694 | "model val_loss Improved from 0.00868042 to 0.00867484\n", 695 | "Phase: val | Epoch: 19/20 | val_loss:0.00867484 | Time: 227.1843s\n", 696 | "Phase: train | Epoch: 20/20 | train_loss:0.00522770 | Time: 981.1657s\n", 697 | "Phase: val | Epoch: 20/20 | val_loss:0.00868109 | Time: 228.8864s\n" 698 | ] 699 | } 700 | ], 701 | "source": [ 702 | "NeuralNet = NeuralNet.to(device)\n", 703 | "optimizer = optim.Adam(NeuralNet.parameters(),lr = LEARNING_RATE)\n", 704 | "loss_func = torch.nn.BCEWithLogitsLoss()\n", 705 | "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,patience = 2)\n", 706 | "best_loss = np.inf\n", 707 | "for epoch in range(NUM_EPOCHS):\n", 708 | " for phase in ['train', 'val']:\n", 709 | " start_time = time.time()\n", 710 | " if phase == 'train':\n", 711 | " NeuralNet.train()\n", 712 | " else:\n", 713 | " NeuralNet.eval()\n", 714 | " \n", 715 | " running_loss = 0.0\n", 716 | " for images_batch, labels_batch in tqdm(dataloaders_dict[phase],disable = DISABLE_TQDM):\n", 717 | " images_batch = images_batch.to(device)\n", 718 | " labels_batch = labels_batch.to(device)\n", 719 | " \n", 720 | " optimizer.zero_grad()\n", 721 | " \n", 722 | " with torch.set_grad_enabled(phase == 'train'):\n", 723 | " pred_batch = NeuralNet(images_batch)\n", 724 | " loss = loss_func(pred_batch,labels_batch)\n", 725 | " \n", 726 | " if phase == 'train':\n", 727 | " loss.backward()\n", 728 | " optimizer.step()\n", 729 | " \n", 730 | " running_loss += loss.item() * images_batch.size(0) \n", 731 | " epoch_loss = running_loss / len(dataloaders_dict[phase].dataset) \n", 732 | "\n", 733 | " if phase == 'val' and epoch_loss < best_loss: \n", 734 | " print(\"model val_loss Improved from {:.8f} to {:.8f}\".format(best_loss,epoch_loss))\n", 735 | " best_loss = epoch_loss\n", 736 | " best_model_wts = copy.deepcopy(NeuralNet.state_dict())\n", 737 | " \n", 738 | " if phase == 'val':\n", 739 | " scheduler.step(epoch_loss)\n", 740 | " \n", 741 | " elapsed_time = time.time()-start_time\n", 742 | " print(\"Phase: {} | Epoch: {}/{} | {}_loss:{:.8f} | Time: {:.4f}s\".format(phase,\n", 743 | " epoch+1,\n", 744 | " NUM_EPOCHS,\n", 745 | " phase,\n", 746 | " epoch_loss,\n", 747 | " elapsed_time))\n", 748 | "NeuralNet.load_state_dict(best_model_wts)" 749 | ] 750 | }, 751 | { 752 | "cell_type": "markdown", 753 | "metadata": {}, 754 | "source": [ 755 | "# Predictions from the model" 756 | ] 757 | }, 758 | { 759 | "cell_type": "code", 760 | "execution_count": 19, 761 | "metadata": {}, 762 | "outputs": [], 763 | "source": [ 764 | "NeuralNet.eval()\n", 765 | "predictions = np.zeros((len(test_dataset), output_dim))\n", 766 | "i = 0\n", 767 | "for test_batch in tqdm(test_loader,disable = DISABLE_TQDM):\n", 768 | " test_batch = test_batch.to(device)\n", 769 | " batch_prediction = NeuralNet(test_batch).detach().cpu().numpy()\n", 770 | " predictions[i * BATCH_SIZE:(i+1) * BATCH_SIZE, :] = batch_prediction\n", 771 | " i+=1" 772 | ] 773 | }, 774 | { 775 | "cell_type": "markdown", 776 | "metadata": {}, 777 | "source": [ 778 | "# Generating submission " 779 | ] 780 | }, 781 | { 782 | "cell_type": "code", 783 | "execution_count": 20, 784 | "metadata": {}, 785 | "outputs": [], 786 | "source": [ 787 | "predicted_class_idx = []\n", 788 | "for i in range(len(predictions)): \n", 789 | " idx_list = np.where(predictions[i] > np.percentile(predictions[i],PERCENTILE)) \n", 790 | " predicted_class_idx.append(idx_list[0])" 791 | ] 792 | }, 793 | { 794 | "cell_type": "code", 795 | "execution_count": 21, 796 | "metadata": {}, 797 | "outputs": [ 798 | { 799 | "data": { 800 | "text/html": [ 801 | "
\n", 802 | "\n", 815 | "\n", 816 | " \n", 817 | " \n", 818 | " \n", 819 | " \n", 820 | " \n", 821 | " \n", 822 | " \n", 823 | " \n", 824 | " \n", 825 | " \n", 826 | " \n", 827 | " \n", 828 | " \n", 829 | " \n", 830 | " \n", 831 | " \n", 832 | " \n", 833 | " \n", 834 | " \n", 835 | " \n", 836 | " \n", 837 | " \n", 838 | " \n", 839 | " \n", 840 | " \n", 841 | " \n", 842 | " \n", 843 | " \n", 844 | " \n", 845 | " \n", 846 | " \n", 847 | " \n", 848 | " \n", 849 | " \n", 850 | "
idattribute_ids
0b7bb1254bf81c71e79 304 487 1062
1a6689c35fce7a4ea13 79 121 1039
2d0801eed43ebf742121 161 800 1092
38cbcbba676d26bec554 612 671 780
4b899b628ae6db63413 156 813 1092
\n", 851 | "
" 852 | ], 853 | "text/plain": [ 854 | " id attribute_ids\n", 855 | "0 b7bb1254bf81c71e 79 304 487 1062\n", 856 | "1 a6689c35fce7a4ea 13 79 121 1039\n", 857 | "2 d0801eed43ebf742 121 161 800 1092\n", 858 | "3 8cbcbba676d26bec 554 612 671 780\n", 859 | "4 b899b628ae6db634 13 156 813 1092" 860 | ] 861 | }, 862 | "execution_count": 21, 863 | "metadata": {}, 864 | "output_type": "execute_result" 865 | } 866 | ], 867 | "source": [ 868 | "test_df['attribute_ids'] = predicted_class_idx\n", 869 | "test_df['attribute_ids'] = test_df['attribute_ids'].apply(lambda x : ' '.join(map(str,list(x))))\n", 870 | "test_df = test_df.rename(columns={0: 'id'})\n", 871 | "test_df['id'] = test_df['id'].apply(lambda x : x.split('.')[0])\n", 872 | "test_df.head()" 873 | ] 874 | }, 875 | { 876 | "cell_type": "code", 877 | "execution_count": 22, 878 | "metadata": {}, 879 | "outputs": [], 880 | "source": [ 881 | "test_df.to_csv('submission.csv',index = False)" 882 | ] 883 | } 884 | ], 885 | "metadata": { 886 | "kernelspec": { 887 | "display_name": "Python 3", 888 | "language": "python", 889 | "name": "python3" 890 | }, 891 | "language_info": { 892 | "codemirror_mode": { 893 | "name": "ipython", 894 | "version": 3 895 | }, 896 | "file_extension": ".py", 897 | "mimetype": "text/x-python", 898 | "name": "python", 899 | "nbconvert_exporter": "python", 900 | "pygments_lexer": "ipython3", 901 | "version": "3.6.4" 902 | } 903 | }, 904 | "nbformat": 4, 905 | "nbformat_minor": 1 906 | } 907 | --------------------------------------------------------------------------------