├── .gitignore ├── LICENSE ├── README.md ├── images ├── fish_000004249599_07973.png ├── mask_000004249599_07973.png ├── results.png └── sample_fish.png ├── models └── unet.pt ├── notebooks ├── inference.ipynb └── train.ipynb └── src ├── FishDataset.py └── model.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | env/ 12 | build/ 13 | develop-eggs/ 14 | dist/ 15 | downloads/ 16 | eggs/ 17 | .eggs/ 18 | lib/ 19 | lib64/ 20 | parts/ 21 | sdist/ 22 | var/ 23 | wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | 49 | # Translations 50 | *.mo 51 | *.pot 52 | 53 | # Django stuff: 54 | *.log 55 | local_settings.py 56 | 57 | # Flask stuff: 58 | instance/ 59 | .webassets-cache 60 | 61 | # Scrapy stuff: 62 | .scrapy 63 | 64 | # Sphinx documentation 65 | docs/_build/ 66 | 67 | # PyBuilder 68 | target/ 69 | 70 | # Jupyter Notebook 71 | .ipynb_checkpoints 72 | 73 | # pyenv 74 | .python-version 75 | 76 | # celery beat schedule file 77 | celerybeat-schedule 78 | 79 | # SageMath parsed files 80 | *.sage.py 81 | 82 | # dotenv 83 | .env 84 | 85 | # virtualenv 86 | .venv 87 | venv/ 88 | ENV/ 89 | 90 | # Spyder project settings 91 | .spyderproject 92 | .spyproject 93 | 94 | # Rope project settings 95 | .ropeproject 96 | 97 | # mkdocs documentation 98 | /site 99 | 100 | # mypy 101 | .mypy_cache/ 102 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Pytorch U-Net 2 | 3 | 4 | This repository contains a simple PyTorch implementation of an U-Net for semantic segmentation of fish images, using [this dataset](http://groups.inf.ed.ac.uk/f4k/GROUNDTRUTH/RECOG/) by B. J. Boom, P. X. Huang and J. He, R. B. Fisher [1]. 5 | 6 | Here is a sample fish image and its ground truth mask: 7 | 8 | 9 | 10 | The model is very simple and not super accurate, but the results are kinda cute: 11 | 12 | 13 | 14 | The code for the U-Net is partially based on this [Kaggle kernel](https://www.kaggle.com/mlagunas/naive-unet-with-pytorch-tensorboard-logging). 15 | 16 | [[1] B. J. Boom, P. X. Huang, J. He, R. B. Fisher, "Supporting Ground-Truth annotation of image datasets using clustering", 21st Int. Conf. on Pattern Recognition (ICPR), 2012](https://ieeexplore.ieee.org/document/6460437/) 17 | -------------------------------------------------------------------------------- /images/fish_000004249599_07973.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arturml/pytorch-unet/85d94c5f691fe5f35f1c0ad541d565e63c870947/images/fish_000004249599_07973.png -------------------------------------------------------------------------------- /images/mask_000004249599_07973.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arturml/pytorch-unet/85d94c5f691fe5f35f1c0ad541d565e63c870947/images/mask_000004249599_07973.png -------------------------------------------------------------------------------- /images/results.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arturml/pytorch-unet/85d94c5f691fe5f35f1c0ad541d565e63c870947/images/results.png -------------------------------------------------------------------------------- /images/sample_fish.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arturml/pytorch-unet/85d94c5f691fe5f35f1c0ad541d565e63c870947/images/sample_fish.png -------------------------------------------------------------------------------- /models/unet.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arturml/pytorch-unet/85d94c5f691fe5f35f1c0ad541d565e63c870947/models/unet.pt -------------------------------------------------------------------------------- /notebooks/inference.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import sys\n", 10 | "sys.path.append('../src')" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 9, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "%matplotlib inline\n", 20 | "import numpy as np\n", 21 | "import torch \n", 22 | "import torch.nn as nn\n", 23 | "import matplotlib.pyplot as plt\n", 24 | "import numpy as np\n", 25 | "from torch.autograd import Variable\n", 26 | "from torch.utils.data.dataset import Dataset\n", 27 | "from torchvision import transforms\n", 28 | "from FishDataset import FishDataset\n", 29 | "from PIL import Image\n", 30 | "from sklearn.model_selection import train_test_split" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "fish_dataset = FishDataset('../data')" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 4, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "unet = torch.load('../models/unet.pt')" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 5, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "def extract_fish(image, model):\n", 58 | " original_shape = image.size\n", 59 | " image = image.resize((128, 128))\n", 60 | " inputs = Variable(transforms.ToTensor()(image).unsqueeze(0)).cuda()\n", 61 | " outputs = model(inputs).round().squeeze(0).cpu().data\n", 62 | " mask = transforms.ToPILImage()(outputs)\n", 63 | " background = Image.new('RGB', (128, 128), color='white')\n", 64 | " \n", 65 | " return Image.composite(image, background, mask).resize(original_shape)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 6, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "# use the same random_sate to get the same validation set from traning\n", 75 | "_, test_indices = train_test_split(np.arange(len(fish_dataset)), test_size=0.2, random_state=42)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 7, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "images = [fish_dataset[i][0] for i in test_indices[:10]]" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 8, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "image/png": "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\n", 95 | "text/plain": [ 96 | "
" 97 | ] 98 | }, 99 | "metadata": {}, 100 | "output_type": "display_data" 101 | } 102 | ], 103 | "source": [ 104 | "fig, axis = plt.subplots(10, 2, figsize=(15,15))\n", 105 | "for image, (ax1, ax2) in zip(images, axis):\n", 106 | " fish = extract_fish(image, unet)\n", 107 | " ax1.imshow(image)\n", 108 | " ax2.imshow(fish)\n", 109 | " ax1.set_xticks([])\n", 110 | " ax1.set_yticks([])\n", 111 | " ax2.set_xticks([])\n", 112 | " ax2.set_yticks([])\n", 113 | "plt.show()" 114 | ] 115 | } 116 | ], 117 | "metadata": { 118 | "kernelspec": { 119 | "display_name": "Environment (conda_pytorch_p36)", 120 | "language": "python", 121 | "name": "conda_pytorch_p36" 122 | }, 123 | "language_info": { 124 | "codemirror_mode": { 125 | "name": "ipython", 126 | "version": 3 127 | }, 128 | "file_extension": ".py", 129 | "mimetype": "text/x-python", 130 | "name": "python", 131 | "nbconvert_exporter": "python", 132 | "pygments_lexer": "ipython3", 133 | "version": "3.6.4" 134 | } 135 | }, 136 | "nbformat": 4, 137 | "nbformat_minor": 2 138 | } 139 | -------------------------------------------------------------------------------- /notebooks/train.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import os\n", 12 | "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\"" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 2, 18 | "metadata": { 19 | "collapsed": true 20 | }, 21 | "outputs": [], 22 | "source": [ 23 | "import sys\n", 24 | "sys.path.append('../src')" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 3, 30 | "metadata": { 31 | "collapsed": true 32 | }, 33 | "outputs": [], 34 | "source": [ 35 | "import numpy as np\n", 36 | "import torch \n", 37 | "import torch.nn as nn\n", 38 | "import os\n", 39 | "from torch.autograd import Variable\n", 40 | "from torch.utils.data.dataset import Dataset\n", 41 | "from torch.utils.data import DataLoader\n", 42 | "from torch.utils.data.sampler import SubsetRandomSampler\n", 43 | "from torchvision import transforms\n", 44 | "from sklearn.model_selection import train_test_split\n", 45 | "from FishDataset import FishDataset" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 4, 51 | "metadata": { 52 | "collapsed": true 53 | }, 54 | "outputs": [], 55 | "source": [ 56 | "%load_ext autoreload\n", 57 | "%autoreload 2\n", 58 | "from model import UNet" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 5, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "train_transform = transforms.Compose([\n", 70 | " transforms.Resize(size=(128, 128)),\n", 71 | " transforms.RandomHorizontalFlip(),\n", 72 | " transforms.ToTensor()\n", 73 | "])\n", 74 | "\n", 75 | "test_transform = transforms.Compose([\n", 76 | " transforms.Resize(size=(128, 128)),\n", 77 | " transforms.ToTensor()\n", 78 | "])" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 6, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "train_dataset = FishDataset('../data', download=True, transform=train_transform, target_transform=train_transform)" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 7, 93 | "metadata": { 94 | "collapsed": true 95 | }, 96 | "outputs": [], 97 | "source": [ 98 | "train_indices, test_indices = train_test_split(np.arange(len(train_dataset)), test_size=0.2, random_state=42)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 8, 104 | "metadata": { 105 | "collapsed": true 106 | }, 107 | "outputs": [], 108 | "source": [ 109 | "train_loader = DataLoader(\n", 110 | " train_dataset,\n", 111 | " batch_size=32,\n", 112 | " sampler=SubsetRandomSampler(train_indices),\n", 113 | " num_workers=4\n", 114 | ")\n", 115 | "\n", 116 | "val_loader = DataLoader(\n", 117 | " FishDataset('../data', transform=test_transform, target_transform=test_transform),\n", 118 | " batch_size=32,\n", 119 | " sampler=SubsetRandomSampler(train_indices),\n", 120 | " num_workers=4\n", 121 | ")" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 9, 127 | "metadata": { 128 | "collapsed": true 129 | }, 130 | "outputs": [], 131 | "source": [ 132 | "def jaccard(outputs, targets):\n", 133 | " outputs = outputs.view(outputs.size(0), -1)\n", 134 | " targets = targets.view(targets.size(0), -1)\n", 135 | " intersection = (outputs * targets).sum(1)\n", 136 | " union = (outputs + targets).sum(1) - intersection\n", 137 | " jac = (intersection + 0.001) / (union + 0.001)\n", 138 | " return jac.mean()" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 10, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "data": { 148 | "text/plain": [ 149 | "UNet(\n", 150 | " (down1): Sequential(\n", 151 | " (0): conv_block(\n", 152 | " (conv): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 153 | " (batch_norm): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True)\n", 154 | " (leaky_relu): LeakyReLU(0.01)\n", 155 | " )\n", 156 | " (1): conv_block(\n", 157 | " (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 158 | " (batch_norm): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True)\n", 159 | " (leaky_relu): LeakyReLU(0.01)\n", 160 | " )\n", 161 | " )\n", 162 | " (down2): Sequential(\n", 163 | " (0): conv_block(\n", 164 | " (conv): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 165 | " (batch_norm): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n", 166 | " (leaky_relu): LeakyReLU(0.01)\n", 167 | " )\n", 168 | " (1): conv_block(\n", 169 | " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 170 | " (batch_norm): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n", 171 | " (leaky_relu): LeakyReLU(0.01)\n", 172 | " )\n", 173 | " )\n", 174 | " (down3): Sequential(\n", 175 | " (0): conv_block(\n", 176 | " (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 177 | " (batch_norm): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n", 178 | " (leaky_relu): LeakyReLU(0.01)\n", 179 | " )\n", 180 | " (1): conv_block(\n", 181 | " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 182 | " (batch_norm): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n", 183 | " (leaky_relu): LeakyReLU(0.01)\n", 184 | " )\n", 185 | " )\n", 186 | " (middle): conv_block(\n", 187 | " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 188 | " (batch_norm): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n", 189 | " (leaky_relu): LeakyReLU(0.01)\n", 190 | " )\n", 191 | " (up3): Sequential(\n", 192 | " (0): conv_block(\n", 193 | " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 194 | " (batch_norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n", 195 | " (leaky_relu): LeakyReLU(0.01)\n", 196 | " )\n", 197 | " (1): conv_block(\n", 198 | " (conv): Conv2d(256, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 199 | " (batch_norm): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n", 200 | " (leaky_relu): LeakyReLU(0.01)\n", 201 | " )\n", 202 | " )\n", 203 | " (up2): Sequential(\n", 204 | " (0): conv_block(\n", 205 | " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 206 | " (batch_norm): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n", 207 | " (leaky_relu): LeakyReLU(0.01)\n", 208 | " )\n", 209 | " (1): conv_block(\n", 210 | " (conv): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 211 | " (batch_norm): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True)\n", 212 | " (leaky_relu): LeakyReLU(0.01)\n", 213 | " )\n", 214 | " )\n", 215 | " (up1): Sequential(\n", 216 | " (0): conv_block(\n", 217 | " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 218 | " (batch_norm): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n", 219 | " (leaky_relu): LeakyReLU(0.01)\n", 220 | " )\n", 221 | " (1): conv_block(\n", 222 | " (conv): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 223 | " (batch_norm): BatchNorm2d(1, eps=1e-05, momentum=0.1, affine=True)\n", 224 | " (leaky_relu): LeakyReLU(0.01)\n", 225 | " )\n", 226 | " )\n", 227 | ")" 228 | ] 229 | }, 230 | "execution_count": 10, 231 | "metadata": {}, 232 | "output_type": "execute_result" 233 | } 234 | ], 235 | "source": [ 236 | "model = UNet()\n", 237 | "model.cuda()" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 11, 243 | "metadata": { 244 | "collapsed": true 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "criterion = nn.BCELoss()\n", 249 | "optimizer = torch.optim.Adam(model.parameters())" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 12, 255 | "metadata": { 256 | "collapsed": true 257 | }, 258 | "outputs": [], 259 | "source": [ 260 | "model_folder = os.path.abspath('../models')\n", 261 | "if not os.path.exists(model_folder):\n", 262 | " os.mkdir(model_folder)\n", 263 | "model_path = os.path.join(model_folder, 'unet.pt')" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 13, 269 | "metadata": { 270 | "scrolled": false 271 | }, 272 | "outputs": [ 273 | { 274 | "name": "stdout", 275 | "output_type": "stream", 276 | "text": [ 277 | "Starting epoch 1/5\n", 278 | " batch 1/685 loss: 0.7597, jaccard 0.1310\n", 279 | " batch 51/685 loss: 0.6546, jaccard 0.6962\n", 280 | " batch 101/685 loss: 0.6477, jaccard 0.7860\n", 281 | " batch 151/685 loss: 0.6474, jaccard 0.7801\n", 282 | " batch 201/685 loss: 0.6405, jaccard 0.8275\n", 283 | " batch 251/685 loss: 0.6364, jaccard 0.8467\n", 284 | " batch 301/685 loss: 0.6396, jaccard 0.8081\n", 285 | " batch 351/685 loss: 0.6308, jaccard 0.8697\n", 286 | " batch 401/685 loss: 0.6329, jaccard 0.8403\n", 287 | " batch 451/685 loss: 0.6293, jaccard 0.8602\n", 288 | " batch 501/685 loss: 0.6279, jaccard 0.8722\n", 289 | " batch 551/685 loss: 0.6297, jaccard 0.8639\n", 290 | " batch 601/685 loss: 0.6294, jaccard 0.8621\n", 291 | " batch 651/685 loss: 0.6205, jaccard 0.8920\n", 292 | "Finished epoch 1, starting evaluation\n", 293 | " loss: 0.6381 jaccard: 0.8154 val_loss: 0.6274 val_jaccard: 0.8766\n", 294 | "\n", 295 | "Starting epoch 2/5\n", 296 | " batch 1/685 loss: 0.6228, jaccard 0.8836\n", 297 | " batch 51/685 loss: 0.6248, jaccard 0.8651\n", 298 | " batch 101/685 loss: 0.6259, jaccard 0.8638\n", 299 | " batch 151/685 loss: 0.6236, jaccard 0.8764\n", 300 | " batch 201/685 loss: 0.6231, jaccard 0.8814\n", 301 | " batch 251/685 loss: 0.6231, jaccard 0.8788\n", 302 | " batch 301/685 loss: 0.6223, jaccard 0.8793\n", 303 | " batch 351/685 loss: 0.6178, jaccard 0.9005\n", 304 | " batch 401/685 loss: 0.6190, jaccard 0.8915\n", 305 | " batch 451/685 loss: 0.6218, jaccard 0.8824\n", 306 | " batch 501/685 loss: 0.6208, jaccard 0.8881\n", 307 | " batch 551/685 loss: 0.6185, jaccard 0.8938\n", 308 | " batch 601/685 loss: 0.6250, jaccard 0.8801\n", 309 | " batch 651/685 loss: 0.6249, jaccard 0.8721\n", 310 | "Finished epoch 2, starting evaluation\n", 311 | " loss: 0.6233 jaccard: 0.8786 val_loss: 0.6207 val_jaccard: 0.8883\n", 312 | "\n", 313 | "Starting epoch 3/5\n", 314 | " batch 1/685 loss: 0.6170, jaccard 0.8874\n", 315 | " batch 51/685 loss: 0.6205, jaccard 0.8924\n", 316 | " batch 101/685 loss: 0.6252, jaccard 0.8714\n", 317 | " batch 151/685 loss: 0.6192, jaccard 0.8835\n", 318 | " batch 201/685 loss: 0.6179, jaccard 0.8774\n", 319 | " batch 251/685 loss: 0.6166, jaccard 0.9028\n", 320 | " batch 301/685 loss: 0.6184, jaccard 0.8931\n", 321 | " batch 351/685 loss: 0.6176, jaccard 0.8855\n", 322 | " batch 401/685 loss: 0.6184, jaccard 0.8910\n", 323 | " batch 451/685 loss: 0.6180, jaccard 0.8913\n", 324 | " batch 501/685 loss: 0.6147, jaccard 0.8963\n", 325 | " batch 551/685 loss: 0.6183, jaccard 0.9003\n", 326 | " batch 601/685 loss: 0.6175, jaccard 0.8936\n", 327 | " batch 651/685 loss: 0.6220, jaccard 0.8853\n", 328 | "Finished epoch 3, starting evaluation\n", 329 | " loss: 0.6194 jaccard: 0.8882 val_loss: 0.6186 val_jaccard: 0.8856\n", 330 | "\n", 331 | "Starting epoch 4/5\n", 332 | " batch 1/685 loss: 0.6154, jaccard 0.9014\n", 333 | " batch 51/685 loss: 0.6153, jaccard 0.9080\n", 334 | " batch 101/685 loss: 0.6146, jaccard 0.9078\n", 335 | " batch 151/685 loss: 0.6188, jaccard 0.8717\n", 336 | " batch 201/685 loss: 0.6168, jaccard 0.8856\n", 337 | " batch 251/685 loss: 0.6151, jaccard 0.8938\n", 338 | " batch 301/685 loss: 0.6171, jaccard 0.8906\n", 339 | " batch 351/685 loss: 0.6155, jaccard 0.8950\n", 340 | " batch 401/685 loss: 0.6106, jaccard 0.9106\n", 341 | " batch 451/685 loss: 0.6208, jaccard 0.8844\n", 342 | " batch 501/685 loss: 0.6158, jaccard 0.8982\n", 343 | " batch 551/685 loss: 0.6194, jaccard 0.8981\n", 344 | " batch 601/685 loss: 0.6161, jaccard 0.8912\n", 345 | " batch 651/685 loss: 0.6158, jaccard 0.8964\n", 346 | "Finished epoch 4, starting evaluation\n", 347 | " loss: 0.6164 jaccard: 0.8924 val_loss: 0.6146 val_jaccard: 0.8952\n", 348 | "\n", 349 | "Starting epoch 5/5\n", 350 | " batch 1/685 loss: 0.6130, jaccard 0.8998\n", 351 | " batch 51/685 loss: 0.6131, jaccard 0.8983\n", 352 | " batch 101/685 loss: 0.6143, jaccard 0.8942\n", 353 | " batch 151/685 loss: 0.6146, jaccard 0.9045\n", 354 | " batch 201/685 loss: 0.6188, jaccard 0.8719\n", 355 | " batch 251/685 loss: 0.6146, jaccard 0.8931\n", 356 | " batch 301/685 loss: 0.6120, jaccard 0.8870\n", 357 | " batch 351/685 loss: 0.6087, jaccard 0.9090\n", 358 | " batch 401/685 loss: 0.6129, jaccard 0.8918\n", 359 | " batch 451/685 loss: 0.6132, jaccard 0.8809\n", 360 | " batch 501/685 loss: 0.6136, jaccard 0.8864\n", 361 | " batch 551/685 loss: 0.6093, jaccard 0.8916\n", 362 | " batch 601/685 loss: 0.6102, jaccard 0.9043\n", 363 | " batch 651/685 loss: 0.6140, jaccard 0.8954\n", 364 | "Finished epoch 5, starting evaluation\n", 365 | " loss: 0.6133 jaccard: 0.8948 val_loss: 0.6111 val_jaccard: 0.8984\n", 366 | "\n" 367 | ] 368 | } 369 | ], 370 | "source": [ 371 | "hist = {'loss': [], 'jaccard': [], 'val_loss': [], 'val_jaccard': []}\n", 372 | "num_epochs = 5\n", 373 | "display_steps = 50\n", 374 | "best_jaccard = 0\n", 375 | "for epoch in range(num_epochs):\n", 376 | " print('Starting epoch {}/{}'.format(epoch+1, num_epochs))\n", 377 | " # train\n", 378 | " model.train()\n", 379 | " running_loss = 0.0\n", 380 | " running_jaccard = 0.0\n", 381 | " for batch_idx, (images, masks, _) in enumerate(train_loader):\n", 382 | " images = Variable(images.cuda())\n", 383 | " masks = Variable(masks.cuda())\n", 384 | " \n", 385 | " optimizer.zero_grad()\n", 386 | " outputs = model(images)\n", 387 | " predicted = outputs.round()\n", 388 | " loss = criterion(outputs, masks)\n", 389 | " loss.backward()\n", 390 | " optimizer.step()\n", 391 | " \n", 392 | " jac = jaccard(outputs.round(), masks)\n", 393 | " running_jaccard += jac.data[0]\n", 394 | " running_loss += loss.data[0]\n", 395 | " \n", 396 | " if batch_idx % display_steps == 0:\n", 397 | " print(' ', end='')\n", 398 | " print('batch {:>3}/{:>3} loss: {:.4f}, jaccard {:.4f}\\r'\\\n", 399 | " .format(batch_idx+1, len(train_loader),\n", 400 | " loss.data[0], jac.data[0]))\n", 401 | "\n", 402 | " \n", 403 | " # evalute\n", 404 | " print('Finished epoch {}, starting evaluation'.format(epoch+1))\n", 405 | " model.eval()\n", 406 | " val_running_loss = 0.0\n", 407 | " val_running_jaccard = 0.0\n", 408 | " for images, masks, _ in val_loader:\n", 409 | " images = Variable(images.cuda())\n", 410 | " masks = Variable(masks.cuda())\n", 411 | " \n", 412 | " outputs = model(images)\n", 413 | " loss = criterion(outputs, masks)\n", 414 | " \n", 415 | " val_running_loss += loss.data[0]\n", 416 | " jac = jaccard(outputs.round(), masks)\n", 417 | " val_running_jaccard += jac.data[0]\n", 418 | "\n", 419 | " train_loss = running_loss / len(train_loader)\n", 420 | " train_jaccard = running_jaccard / len(train_loader)\n", 421 | " val_loss = val_running_loss / len(val_loader)\n", 422 | " val_jaccard = val_running_jaccard / len(val_loader)\n", 423 | " \n", 424 | " hist['loss'].append(train_loss)\n", 425 | " hist['jaccard'].append(train_jaccard)\n", 426 | " hist['val_loss'].append(val_loss)\n", 427 | " hist['val_jaccard'].append(val_jaccard)\n", 428 | " \n", 429 | " if val_jaccard > best_jaccard:\n", 430 | " torch.save(model, model_path)\n", 431 | " print(' ', end='')\n", 432 | " print('loss: {:.4f} jaccard: {:.4f} \\\n", 433 | " val_loss: {:.4f} val_jaccard: {:4.4f}\\n'\\\n", 434 | " .format(train_loss, train_jaccard, val_loss, val_jaccard))" 435 | ] 436 | } 437 | ], 438 | "metadata": { 439 | "kernelspec": { 440 | "display_name": "Python 3", 441 | "language": "python", 442 | "name": "python3" 443 | }, 444 | "language_info": { 445 | "codemirror_mode": { 446 | "name": "ipython", 447 | "version": 3 448 | }, 449 | "file_extension": ".py", 450 | "mimetype": "text/x-python", 451 | "name": "python", 452 | "nbconvert_exporter": "python", 453 | "pygments_lexer": "ipython3", 454 | "version": "3.6.1" 455 | } 456 | }, 457 | "nbformat": 4, 458 | "nbformat_minor": 2 459 | } 460 | -------------------------------------------------------------------------------- /src/FishDataset.py: -------------------------------------------------------------------------------- 1 | 2 | import os 3 | import re 4 | import numpy as np 5 | import random 6 | import tarfile 7 | import urllib 8 | from PIL import Image 9 | from glob import glob 10 | import matplotlib.pyplot as plt 11 | from torch.utils.data.dataset import Dataset 12 | 13 | class FishDataset(Dataset): 14 | """Fishes dataset.""" 15 | 16 | def __init__(self, root_dir, transform=None, target_transform=None, download=False): 17 | """ 18 | Args: 19 | root_dir (string): Data directory containing the fish_image and mask_image folders. 20 | transform (callable, optional): Optional transform to be applied on an image. 21 | """ 22 | self.root_dir = os.path.abspath(root_dir) 23 | self.transform = transform 24 | self.target_transform = target_transform 25 | 26 | if download: 27 | self.download() 28 | 29 | if not self._check_exists(): 30 | raise RuntimeError('Dataset not found. You can use download=True to download it.') 31 | 32 | 33 | self.images = glob(os.path.join(root_dir, 'fish_image/*/*.png')) 34 | self.masks = [re.sub('fish', 'mask', image) for image in self.images] 35 | self.labels = [int(re.search('.*fish_image/fish_(\d+)', image).group(1)) for image in self.images] 36 | 37 | def __len__(self): 38 | return len(self.labels) 39 | 40 | def __getitem__(self, index): 41 | label = self.labels[index] 42 | image = Image.open(self.images[index]) 43 | mask = Image.open(self.masks[index]) 44 | 45 | if mask.mode == '1': 46 | mask = mask.convert('L') 47 | 48 | # https://github.com/pytorch/vision/issues/9 49 | seed = np.random.randint(2147483647) 50 | random.seed(seed) 51 | if self.transform is not None: 52 | image = self.transform(image) 53 | 54 | random.seed(seed) 55 | if self.target_transform is not None: 56 | mask = self.target_transform(mask) 57 | mask = mask.round() 58 | 59 | return (image, mask, label) 60 | 61 | 62 | def download(self): 63 | if self._check_exists(): 64 | return 65 | 66 | try: 67 | os.makedirs(self.root_dir) 68 | except FileExistsError: 69 | pass 70 | 71 | url = 'http://groups.inf.ed.ac.uk/f4k/GROUNDTRUTH/RECOG/Archive/fishRecognition_GT.tar' 72 | file_path = os.path.join(self.root_dir, 'fishRecognition_GT.tar') 73 | print('Downloading...', end=' ') 74 | urllib.request.urlretrieve(url, file_path) 75 | print('Done!') 76 | print('Extracting files...', end=' ') 77 | with tarfile.open(file_path) as tar: 78 | tar.extractall(self.root_dir) 79 | os.remove(file_path) 80 | print('Done!') 81 | 82 | def _check_exists(self): 83 | return os.path.exists(os.path.join(self.root_dir, 'fish_image')) and \ 84 | os.path.exists(os.path.join(self.root_dir, 'mask_image')) 85 | -------------------------------------------------------------------------------- /src/model.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | import torch.nn.init as init 5 | import numpy as np 6 | 7 | class conv_block(nn.Module): 8 | def __init__(self, in_channels, out_channels): 9 | super().__init__() 10 | self.conv = nn.Conv2d(in_channels, out_channels, 3, padding=1) 11 | init.xavier_uniform(self.conv.weight, gain=np.sqrt(2)) 12 | self.batch_norm = nn.BatchNorm2d(out_channels) 13 | self.leaky_relu = nn.LeakyReLU(0.01) 14 | 15 | def forward(self, x): 16 | x = self.conv(x) 17 | x = self.batch_norm(x) 18 | x = self.leaky_relu(x) 19 | return x 20 | 21 | class UNet(nn.Module): 22 | def __init__(self): 23 | super().__init__() 24 | self.down1 = nn.Sequential( 25 | conv_block(3, 32), 26 | conv_block(32, 32) 27 | ) 28 | self.down2 = nn.Sequential( 29 | conv_block(32, 64), 30 | conv_block(64, 64) 31 | ) 32 | self.down3 = nn.Sequential( 33 | conv_block(64, 128), 34 | conv_block(128, 128) 35 | ) 36 | 37 | self.middle = conv_block(128, 128) 38 | 39 | self.up3 = nn.Sequential( 40 | conv_block(256, 256), 41 | conv_block(256, 64) 42 | ) 43 | 44 | self.up2 = nn.Sequential( 45 | conv_block(128, 128), 46 | conv_block(128, 32) 47 | ) 48 | 49 | self.up1 = nn.Sequential( 50 | conv_block(64, 64), 51 | conv_block(64, 1) 52 | ) 53 | 54 | def forward(self, x): 55 | down1 = self.down1(x) 56 | out = F.max_pool2d(down1, 2) 57 | 58 | down2 = self.down2(out) 59 | out = F.max_pool2d(down2, 2) 60 | 61 | down3 = self.down3(out) 62 | out = F.max_pool2d(down3, 2) 63 | 64 | out = self.middle(out) 65 | 66 | out = F.upsample(out, scale_factor=2) 67 | out = torch.cat([down3, out], 1) 68 | out = self.up3(out) 69 | 70 | out = F.upsample(out, scale_factor=2) 71 | out = torch.cat([down2, out], 1) 72 | out = self.up2(out) 73 | 74 | out = F.upsample(out, scale_factor=2) 75 | out = torch.cat([down1, out], 1) 76 | out = self.up1(out) 77 | 78 | out = F.sigmoid(out) 79 | 80 | return out 81 | --------------------------------------------------------------------------------