train.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "25655fa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.pyplot._IonContext at 0x1e29e283470>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Download the required libraries\n",
    "from __future__ import print_function, division\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision\n",
    "from torchvision import datasets, models\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.autograd import Variable\n",
    "import torch.onnx\n",
    "import torchvision\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.ion()   # interactive moden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9dfef537",
   "metadata": {},
   "outputs": [],
   "source": [
    "# i suppose what your image folders placed in datasets directory \n",
    "data_dir= \"C:/Users/User/Documents/GitHub/SWTS-0.1\"\n",
    "\n",
    "# Data scaled and normalization for training and testing\n",
    "norm = 1.7\n",
    "data_transforms = {\n",
    "    'train': transforms.Compose([\n",
    "        #transforms.RandomResizedCrop(32),\n",
    "        transforms.Resize((32, 32)),\n",
    "        transforms.ToTensor(),\n",
    "        #transforms.Normalize([norm, norm, norm], [norm, norm, norm])\n",
    "    ]),\n",
    "    'test': transforms.Compose([\n",
    "        #transforms.RandomResizedCrop(32),\n",
    "        transforms.Resize((32, 32)),\n",
    "        transforms.ToTensor(),\n",
    "        #transforms.Normalize([norm, norm, norm], [norm, norm, norm])\n",
    "    ]),\n",
    "}\n",
    "\n",
    "#Create function to get your(my) images dataset and resize it to size for model\n",
    "def get_dataset(data_dir, data_transforms ):\n",
    "\n",
    "\n",
    "    # create train and test datasets\n",
    "    image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),\n",
    "                                              data_transforms[x])\n",
    "                      for x in ['train', 'test']}\n",
    "    dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,\n",
    "                                                 shuffle=True, num_workers=4)\n",
    "                  for x in ['train', 'test']}\n",
    "    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'test']}\n",
    "    #get classes from train dataset folders name\n",
    "    classes = image_datasets['train'].classes\n",
    "\n",
    "    return dataloaders[\"train\"], dataloaders['test'], classes, dataset_sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7b645ff2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classes:  ['trash']\n",
      "The datasest have:  {'train': 10, 'test': 4}  images\n"
     ]
    }
   ],
   "source": [
    "# get train and test data\n",
    "trainloader, testloader, classes, dataset_sizes = get_dataset(data_dir, data_transforms)\n",
    "print('Classes: ',  classes)\n",
    "print('The datasest have: ',  dataset_sizes ,\" images\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "99732790",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trash trash trash trash\n"
     ]
    }
   ],
   "source": [
    "# create function for print unnormalized images\n",
    "def imshow(img):\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = next(dataiter)\n",
    "#images, labels = dataiter.next()\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "516c43ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=2, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 16 * 5 * 5 )\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4b3b197a",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "device = torch.device(\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "12b322bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.04562464952468872\n",
      "0 0.0910547693570455\n",
      "0 0.13643283049265545\n",
      "1 0.04528200626373291\n",
      "1 0.09037168025970459\n",
      "1 0.13543893496195475\n",
      "2 0.044830759366353355\n",
      "2 0.0892907977104187\n",
      "2 0.13352056741714477\n",
      "3 0.04406999746958415\n",
      "3 0.08774925072987874\n",
      "3 0.13114278316497802\n",
      "4 0.04314290682474772\n",
      "4 0.08596332867940266\n",
      "4 0.12840489149093628\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(5):  # loop over the dataset multiple times\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        print(epoch, running_loss / 15)\n",
    "        '''if i % 15 == 14:    # print every 15 mini-batches\n",
    "            print('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 15))\n",
    "            running_loss = 0.0'''\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8933fec0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GroundTruth:  trash trash trash trash\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        \n",
    "        for printdata in list(zip(predicted,labels,outputs)):\n",
    "            printclass =[classes[int(printdata[0])],classes[int(printdata[1])]]\n",
    "            #print('Predict class - {0}, real class - {1}, probability ({2},{3})'.format( printclass[0],printclass[1],\n",
    "                                                                              #classes[0], classes [1]))\n",
    "\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        imshow(torchvision.utils.make_grid(images))\n",
    "        print('GroundTruth: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a92c6d58",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(net.state_dict(), \"models/model1.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cfd36a5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 4 test images: 100 %\n"
     ]
    }
   ],
   "source": [
    "net = Net()\n",
    "net.load_state_dict(torch.load('models/model1.pth'))\n",
    "\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        \n",
    "        for printdata in list(zip(predicted,labels,outputs)):\n",
    "            printclass =[classes[int(printdata[0])],classes[int(printdata[1])]]\n",
    "\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        imshow(torchvision.utils.make_grid(images))\n",
    "        #print('GroundTruth: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))\n",
    "print('Accuracy of the network on the', dataset_sizes['test'], 'test images: %d %%' % (\n",
    "    100 * correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "085e84db",
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = \"models/model.onnx\"\n",
    "dummy_input = Variable(torch.randn(1, 3, 32, 32))\n",
    "torch.onnx.export(net, dummy_input, PATH)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "82d4c6f819cf47785f735f902f00da8643513d08dab4f4c7470bccf934b8d2d6"
  },
  "kernelspec": {
   "display_name": "Python 3.7.0 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}