MaskRCNN_tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MaskRCNN_tutorial.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyN4R1eOMmV5L8ABdUb2pA8u",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Arvinth-s/Dark-Sight/blob/master/MaskRCNN_tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-GQyrT_Gl1eW"
      },
      "source": [
        "#OM NAMO NARAYANA"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ogLRhyNXmDu2"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HLxTGnQLm45w",
        "outputId": "79dc4032-601c-4693-c0b1-6cdbda9c18ad",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#We use '!' for running shell command\n",
        "#Implemented on the base of pytorch tutorial\n",
        "#https://pytorch.org/tutorials/intermediate/torchvision_tutorial.html\n",
        "if ('PennFudanPed.zip' not in os.listdir('/content/')):\n",
        "  !wget https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip\n",
        "else:\n",
        "  print('Already downloaded')\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Already downloaded\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ejkGOKMEnUz_",
        "outputId": "617bf571-09bf-47f7-d1bd-1663e34531c1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "if(\"PennFudanPed\" not in os.listdir('/content/')):\n",
        "  !unzip 'PennFudanPed.zip'\n",
        "else:\n",
        "  print('Already unzipped')"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Already unzipped\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KP_ydo2-o4iT",
        "outputId": "093a5352-2d2a-4311-c9f9-3be035704d99",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "os.chdir('/content/PennFudanPed')\n",
        "os.listdir('./')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Annotation', 'PNGImages', 'readme.txt', 'PedMasks', 'added-object-list.txt']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zNFaKbvp1sob"
      },
      "source": [
        "#__setitem__ and __getitem__\n",
        "#https://stackoverflow.com/questions/43627405/understanding-getitem-method#:~:text=The%20magic%20method%20__getitem,'%20(date%20of%20birth).\n",
        "\n",
        "class PennFudanDataset(object):\n",
        "    def __init__(self, root, transforms):\n",
        "        self.root = root\n",
        "        self.transforms = transforms\n",
        "        # load all image files, sorting them to\n",
        "        # ensure that they are aligned\n",
        "        self.imgs = list(sorted(os.listdir(os.path.join(root, \"PNGImages\"))))\n",
        "        self.masks = list(sorted(os.listdir(os.path.join(root, \"PedMasks\"))))\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        # load images ad masks\n",
        "        img_path = os.path.join(self.root, \"PNGImages\", self.imgs[idx])\n",
        "        mask_path = os.path.join(self.root, \"PedMasks\", self.masks[idx])\n",
        "        img = Image.open(img_path).convert(\"RGB\")\n",
        "        # note that we haven't converted the mask to RGB,\n",
        "        # because each color corresponds to a different instance\n",
        "        # with 0 being background\n",
        "        mask = Image.open(mask_path)\n",
        "        # convert the PIL Image into a numpy array\n",
        "        mask = np.array(mask)\n",
        "        # instances are encoded as different colors\n",
        "        obj_ids = np.unique(mask)\n",
        "        # first id is the background, so remove it\n",
        "        obj_ids = obj_ids[1:]\n",
        "\n",
        "        # split the color-encoded mask into a set\n",
        "        # of binary masks\n",
        "        masks = mask == obj_ids[:, None, None]\n",
        "\n",
        "        # get bounding box coordinates for each mask\n",
        "        num_objs = len(obj_ids)\n",
        "        boxes = []\n",
        "        for i in range(num_objs):\n",
        "            pos = np.where(masks[i])\n",
        "            xmin = np.min(pos[1])\n",
        "            xmax = np.max(pos[1])\n",
        "            ymin = np.min(pos[0])\n",
        "            ymax = np.max(pos[0])\n",
        "            boxes.append([xmin, ymin, xmax, ymax])\n",
        "\n",
        "        # convert everything into a torch.Tensor\n",
        "        boxes = torch.as_tensor(boxes, dtype=torch.float32)\n",
        "        # there is only one class\n",
        "        labels = torch.ones((num_objs,), dtype=torch.int64)\n",
        "        masks = torch.as_tensor(masks, dtype=torch.uint8)\n",
        "\n",
        "        image_id = torch.tensor([idx])\n",
        "        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])\n",
        "        # suppose all instances are not crowd\n",
        "        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)\n",
        "        # img.show()\n",
        "        # plt.imshow(img)\n",
        "        # print(img)\n",
        "        # print('showing image')\n",
        "        target = {}\n",
        "        target[\"boxes\"] = boxes\n",
        "        target[\"labels\"] = labels\n",
        "        target[\"masks\"] = masks\n",
        "        target[\"image_id\"] = image_id\n",
        "        target[\"area\"] = area\n",
        "        target[\"iscrowd\"] = iscrowd\n",
        "\n",
        "        if self.transforms is not None:\n",
        "            img = self.transforms(img)\n",
        "        # print('my target', target)\n",
        "        return (img, target)\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.imgs)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C-tS-JfF6MLM"
      },
      "source": [
        "import torchvision\n",
        "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MCsKHs3Cs1IR"
      },
      "source": [
        "from torchvision.models.detection import FasterRCNN\n",
        "from torchvision.models.detection.rpn import AnchorGenerator\n",
        "\n",
        "\n",
        "backbone = torchvision.models.mobilenet_v2(pretrained=True).features\n",
        "\n",
        "backbone.out_channels = 1280\n",
        "\n",
        "\n",
        "anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),\n",
        "                                   aspect_ratios=((0.5, 1.0, 2.0),))\n",
        "\n",
        "\n",
        "roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],\n",
        "                                                output_size=7,\n",
        "                                                sampling_ratio=2)\n",
        "\n",
        "model = FasterRCNN(backbone,\n",
        "                   num_classes=2,\n",
        "                   rpn_anchor_generator=anchor_generator,\n",
        "                   box_roi_pool=roi_pooler)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ew5AV_y9tNMi"
      },
      "source": [
        "import torchvision\n",
        "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor\n",
        "from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor\n",
        "\n",
        "\n",
        "def get_model_instance_segmentation(num_classes):\n",
        "\n",
        "    model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n",
        "\n",
        "\n",
        "    in_features = model.roi_heads.box_predictor.cls_score.in_features\n",
        "\n",
        "    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n",
        "\n",
        "\n",
        "    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels\n",
        "    hidden_layer = 256\n",
        "\n",
        "    model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,\n",
        "                                                       hidden_layer,\n",
        "                                                       num_classes)\n",
        "\n",
        "    return model"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YRnB8BHItQxs"
      },
      "source": [
        "import torchvision.transforms as T\n",
        "\n",
        "def get_transform(train):\n",
        "    print(type(train))\n",
        "    transforms = []\n",
        "    transforms.append(T.ToTensor())\n",
        "    # if train:\n",
        "    #     transforms.append(T.RandomHorizontalFlip(0.5))\n",
        "    return T.Compose(transforms)"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KkjmBwHdnxbt"
      },
      "source": [
        "def my_collate(batch):\n",
        "  return ([cbatch[0] for cbatch in batch], [cbatch[1] for cbatch in batch])"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MCY_6CNXlKwN",
        "outputId": "be3de364-7310-43a0-8208-700858226864",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 742
        }
      },
      "source": [
        "import utils\n",
        "\n",
        "model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)\n",
        "dataset = PennFudanDataset('/content/PennFudanPed', get_transform(train=True))\n",
        "data_loader = torch.utils.data.DataLoader(\n",
        " dataset, batch_size=1, shuffle=True, num_workers=4,\n",
        " collate_fn=my_collate)\n",
        "# For Training\n",
        "images,targets = next(iter(data_loader))\n",
        "images = list(image for image in images)\n",
        "print('images', images)\n",
        "targets = [{k: v for k, v in t.items()} for t in targets]\n",
        "print('target', targets)\n",
        "\n",
        "output = model(images,targets)   # Returns losses and detections\n",
        "# For inference\n",
        "model.eval()\n",
        "x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]\n",
        "predictions = model(x)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'bool'>\n",
            "images [tensor([[[0.2000, 0.2000, 0.1882,  ..., 0.3255, 0.2941, 0.2588],\n",
            "         [0.1922, 0.1922, 0.1843,  ..., 0.5294, 0.5176, 0.5020],\n",
            "         [0.1922, 0.1961, 0.1922,  ..., 0.3647, 0.3843, 0.4039],\n",
            "         ...,\n",
            "         [0.4627, 0.4667, 0.4706,  ..., 0.6039, 0.5961, 0.5961],\n",
            "         [0.4588, 0.4706, 0.4784,  ..., 0.6078, 0.6000, 0.6000],\n",
            "         [0.4588, 0.4784, 0.4863,  ..., 0.6078, 0.6039, 0.6039]],\n",
            "\n",
            "        [[0.2745, 0.2745, 0.2745,  ..., 0.3333, 0.3020, 0.2667],\n",
            "         [0.2667, 0.2667, 0.2706,  ..., 0.5373, 0.5255, 0.5098],\n",
            "         [0.2706, 0.2745, 0.2784,  ..., 0.3725, 0.3922, 0.4118],\n",
            "         ...,\n",
            "         [0.4863, 0.4902, 0.4941,  ..., 0.6118, 0.6039, 0.6039],\n",
            "         [0.4824, 0.4941, 0.5020,  ..., 0.6157, 0.6078, 0.6078],\n",
            "         [0.4824, 0.5020, 0.5098,  ..., 0.6157, 0.6118, 0.6118]],\n",
            "\n",
            "        [[0.3294, 0.3294, 0.3255,  ..., 0.3137, 0.2824, 0.2471],\n",
            "         [0.3216, 0.3216, 0.3216,  ..., 0.5176, 0.5059, 0.4902],\n",
            "         [0.3137, 0.3176, 0.3294,  ..., 0.3529, 0.3725, 0.3922],\n",
            "         ...,\n",
            "         [0.4706, 0.4745, 0.4863,  ..., 0.6078, 0.6000, 0.6000],\n",
            "         [0.4667, 0.4784, 0.4941,  ..., 0.6118, 0.6039, 0.6039],\n",
            "         [0.4667, 0.4863, 0.5020,  ..., 0.6118, 0.6078, 0.6078]]])]\n",
            "target [{'boxes': tensor([[227., 157., 369., 435.],\n",
            "        [ 38., 178., 114., 362.]]), 'labels': tensor([1, 1]), 'masks': tensor([[[0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         ...,\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0]],\n",
            "\n",
            "        [[0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         ...,\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0],\n",
            "         [0, 0, 0,  ..., 0, 0, 0]]], dtype=torch.uint8), 'image_id': tensor([7]), 'area': tensor([39476., 13984.]), 'iscrowd': tensor([0, 0])}]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3000: UserWarning: The default behavior for interpolate/upsample with float scale_factor changed in 1.6.0 to align with other frameworks/libraries, and uses scale_factor directly, instead of relying on the computed output size. If you wish to keep the old behavior, please set recompute_scale_factor=True. See the documentation of nn.Upsample for details. \n",
            "  warnings.warn(\"The default behavior for interpolate/upsample with float scale_factor changed \"\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IL6f_lkU-uTu"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy\n",
        "from time import sleep\n",
        "\n",
        "class myDplot():\n",
        "  def __init__(self, n_r, n_c):\n",
        "    self.n_r = n_r\n",
        "    self.n_c = n_c\n",
        "    self.figure, self.h = plt.subplots(n_r, n_c)\n",
        "    self.count = 0\n",
        "    self.xdata = []\n",
        "    self.ydata = []\n",
        "    # plt.show()\n",
        "\n",
        "  def update_line(self, new_data):\n",
        "      # print(new_data)\n",
        "      plt.cla()\n",
        "      self.figure, self.h = plt.subplots(self.n_r, self.n_c)\n",
        "      if(type(len(new_data)) != list and len(new_data) == self.n_r * self.n_c):\n",
        "        new_data = list(np.array(new_data).reshape(self.n_r, self.n_c))\n",
        "      if(len(new_data) != self.n_r or len(new_data[0]) != self.n_c):\n",
        "        print('dimension mismatch')\n",
        "        return\n",
        "      print(np.array(h).shape)\n",
        "      self.xdata.append(np.ones((self.n_r, self.n_c))*self.count)\n",
        "      self.ydata.append(new_data)\n",
        "      # self.xdata = [np.ones((self.n_r, self.n_c))*self.count]\n",
        "      # self.ydata = [new_data]\n",
        "      print(self.xdata, self.ydata)\n",
        "      for i in range(self.n_r):\n",
        "        for j in range(self.n_c):\n",
        "          # self.xdata.append(self.count)\n",
        "          # self.ydata.append(new_data[i][j])\n",
        "          self.h[i][j].clear()\n",
        "          print('self', self.xdata[self.count][i][j], self.ydata[self.count][i][j])\n",
        "          self.h[i][j].plot([self.xdata[x][i][j] for x in range(self.count+1)], [self.ydata[y][i][j] for y in range(self.count+1)])\n",
        "          # self.h[i][j].clear()\n",
        "      self.count = self.count+1\n",
        "      # self.figure.canvas.draw()\n",
        "      # self.figure.canvas.flush_events()\n",
        "      # plt.draw()\n",
        "      plt.show()\n",
        "\n",
        "      # plt.draw()"
      ],
      "execution_count": 252,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NXsYtbEZI0dr",
        "outputId": "e41dd1b5-b9eb-41ed-9e01-2ef70e6cf3c8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "templot = myDplot(2, 3)\n",
        "templot.update_line([0.9252862334251404, 0.1233876422047615, 3.6862316131591797, 0.008536873385310173, 0.000774867890868336, 0])\n",
        "sleep(5)\n",
        "templot.update_line([0.9252862334251404, 0.1233876422047615, 3.6862316131591797, 0.008536873385310173, 0.000774867890868336, 0])\n",
        "sleep(5)\n",
        "templot.update_line([0.9252862334251404, 0.1233876422047615, 3.6862316131591797, 0.008536873385310173, 0.000774867890868336, 0])\n",
        "sleep(10)"
      ],
      "execution_count": 253,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(5,)\n",
            "[array([[0., 0., 0.],\n",
            "       [0., 0., 0.]])] [[array([0.92528623, 0.12338764, 3.68623161]), array([0.00853687, 0.00077487, 0.        ])]]\n",
            "self 0.0 0.9252862334251404\n",
            "self 0.0 0.1233876422047615\n",
            "self 0.0 3.6862316131591797\n",
            "self 0.0 0.008536873385310173\n",
            "self 0.0 0.000774867890868336\n",
            "self 0.0 0.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "(5,)\n",
            "[array([[0., 0., 0.],\n",
            "       [0., 0., 0.]]), array([[1., 1., 1.],\n",
            "       [1., 1., 1.]])] [[array([0.92528623, 0.12338764, 3.68623161]), array([0.00853687, 0.00077487, 0.        ])], [array([0.92528623, 0.12338764, 3.68623161]), array([0.00853687, 0.00077487, 0.        ])]]\n",
            "self 1.0 0.9252862334251404\n",
            "self 1.0 0.1233876422047615\n",
            "self 1.0 3.6862316131591797\n",
            "self 1.0 0.008536873385310173\n",
            "self 1.0 0.000774867890868336\n",
            "self 1.0 0.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "(5,)\n",
            "[array([[0., 0., 0.],\n",
            "       [0., 0., 0.]]), array([[1., 1., 1.],\n",
            "       [1., 1., 1.]]), array([[2., 2., 2.],\n",
            "       [2., 2., 2.]])] [[array([0.92528623, 0.12338764, 3.68623161]), array([0.00853687, 0.00077487, 0.        ])], [array([0.92528623, 0.12338764, 3.68623161]), array([0.00853687, 0.00077487, 0.        ])], [array([0.92528623, 0.12338764, 3.68623161]), array([0.00853687, 0.00077487, 0.        ])]]\n",
            "self 2.0 0.9252862334251404\n",
            "self 2.0 0.1233876422047615\n",
            "self 2.0 3.6862316131591797\n",
            "self 2.0 0.008536873385310173\n",
            "self 2.0 0.000774867890868336\n",
            "self 2.0 0.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4U8WRBjC9N_I"
      },
      "source": [
        "def train_model(model, optimizer, scheduler, dataloader, num_epochs):\n",
        "  dplot = myDplot(3, 2);\n",
        "  for epoch in range(num_epochs):\n",
        "    for phase in ['train', 'eval']:\n",
        "      if(phase == 'train'):\n",
        "        model.train()\n",
        "      else:\n",
        "        model.eval()\n",
        "      running_loss = 0.0\n",
        "      runnin_corrects = 0\n",
        "\n",
        "      for inputs, labels in iter(data_loader):\n",
        "        # inputs = inputs.to(device)\n",
        "        # labels = labels.to(device)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        # running_loss = 0\n",
        "\n",
        "        with torch.set_grad_enabled(phase=='train'):\n",
        "          # outputs=model(inputs)\n",
        "          # _, preds = torch.max(outputs, 1)\n",
        "          loss = model(inputs, labels)\n",
        "          running_loss = []\n",
        "          if(phase == 'train'):\n",
        "            for item in loss:\n",
        "              print(loss[item])\n",
        "              # running_loss = loss[item].numpy()\n",
        "              running_loss.append(loss[item].item())\n",
        "              print(running_loss)\n",
        "              loss[item].backward(retain_graph=True)\n",
        "            optimizer.step()\n",
        "            # scheduler.step()\n",
        "          running_loss.append(0)\n",
        "          dplot.update_line(running_loss)\n",
        "          # running_loss += loss.item() * input.size(0)\n",
        "          \n",
        "          # running_corrects += torch.sum(preds==labels.data)\n",
        "      if(phase=='train'):\n",
        "        scheduler.step()\n",
        "      # epoch_loss = running_loss / dataset_sizes[phase]\n",
        "      # epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
        "\n",
        "      # print('{} Loss: {:.4f} Acc: {:.4f}'.format(\n",
        "          # phase, epoch_loss, epoch_acc\n",
        "      # ))\n",
        "      return model"
      ],
      "execution_count": 215,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xmZUeDrcttaY",
        "outputId": "088c274f-9150-4e90-a3eb-38f8acf65062",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "def main():\n",
        "    device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
        "\n",
        "    num_classes = 2\n",
        "    dataset = PennFudanDataset('/content/PennFudanPed', get_transform(train=True))\n",
        "    dataset_test = PennFudanDataset('/content/PennFudanPed', get_transform(train=False))\n",
        "\n",
        "    indices = torch.randperm(len(dataset)).tolist()\n",
        "    dataset = torch.utils.data.Subset(dataset, indices[:-50])\n",
        "    dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])\n",
        "\n",
        "    data_loader = torch.utils.data.DataLoader(\n",
        "        dataset, batch_size=2, shuffle=True, num_workers=4,)\n",
        "        # collate_fn=utils.collate_fn)\n",
        "\n",
        "    data_loader_test = torch.utils.data.DataLoader(\n",
        "        dataset_test, batch_size=1, shuffle=False, num_workers=4,)\n",
        "        # collate_fn=utils.collate_fn)\n",
        "\n",
        "    # get the model using our helper function\n",
        "    model = get_model_instance_segmentation(num_classes)\n",
        "\n",
        "    # move model to the right device\n",
        "    model.to(device)\n",
        "\n",
        "    # construct an optimizer\n",
        "    params = [p for p in model.parameters() if p.requires_grad]\n",
        "    optimizer = torch.optim.SGD(params, lr=0.005,\n",
        "                                momentum=0.9, weight_decay=0.0005)\n",
        "    # and a learning rate scheduler\n",
        "    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n",
        "                                                   step_size=3,\n",
        "                                                   gamma=0.1)\n",
        "\n",
        "    # let's train it for 10 epochs\n",
        "    num_epochs = 10\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        # # train for one epoch, printing every 10 iterations\n",
        "        # train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)\n",
        "        # # model.()\n",
        "        # # update the learning rate\n",
        "        # lr_scheduler.step()\n",
        "        # # evaluate on the test dataset\n",
        "        # evaluate(model, data_loader_test, device=device)\n",
        "        # # model.eval()\n",
        "        train_model(model, optimizer, lr_scheduler, data_loader, 10)\n",
        "        model = model.train()\n",
        "\n",
        "    print(\"That's it!\")\n",
        "main()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'bool'>\n",
            "<class 'bool'>\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3000: UserWarning: The default behavior for interpolate/upsample with float scale_factor changed in 1.6.0 to align with other frameworks/libraries, and uses scale_factor directly, instead of relying on the computed output size. If you wish to keep the old behavior, please set recompute_scale_factor=True. See the documentation of nn.Upsample for details. \n",
            "  warnings.warn(\"The default behavior for interpolate/upsample with float scale_factor changed \"\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(0.6830, grad_fn=<NllLossBackward>)\n",
            "[0.6829817891120911]\n",
            "tensor(0.2404, grad_fn=<DivBackward0>)\n",
            "[0.6829817891120911, 0.24040639400482178]\n",
            "tensor(4.4283, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)\n",
            "[0.6829817891120911, 0.24040639400482178, 4.428308486938477]\n",
            "tensor(0.0250, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)\n",
            "[0.6829817891120911, 0.24040639400482178, 4.428308486938477, 0.0250244103372097]\n",
            "tensor(0.0038, grad_fn=<DivBackward0>)\n",
            "[0.6829817891120911, 0.24040639400482178, 4.428308486938477, 0.0250244103372097, 0.003835335373878479]\n",
            "(5,)\n",
            "[array([[0., 0.],\n",
            "       [0., 0.],\n",
            "       [0., 0.]])] [[array([0.68298179, 0.24040639]), array([4.42830849, 0.02502441]), array([0.00383534, 0.        ])]]\n",
            "self 0.0 0.6829817891120911\n",
            "self 0.0 0.24040639400482178\n",
            "self 0.0 4.428308486938477\n",
            "self 0.0 0.0250244103372097\n",
            "self 0.0 0.003835335373878479\n",
            "self 0.0 0.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAD4CAYAAAAQP7oXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3df5RdZX3v8ffHxAStAiGJiJnAJHcACWhBJkhLvSI/TLD88BaL4YLCLRS8wF2ucnttWFTaC3UZpFauDS1GxWK7JECo3ii/bviR1lohzAACCYb80iYDliH8sBVNSvjeP/YzYedwTmbPzNnn7DN8XmvNmrOf/exnf/ecJ/mevffZz6OIwMzMrIg3tTsAMzPrHE4aZmZWmJOGmZkV5qRhZmaFOWmYmVlhE9sdQDNMmzYturu72x2GjVP9/f3PRcT0Vu/X/drK1N/f/3PghxExfyTbjYuk0d3dTV9fX7vDsHFK0k/bsV/3ayuTpHUjTRjgy1NmZjYCThpmZlaYk4aZmRXmpGFmZoU5aZiNgKT5ktZKWi9pYZ31l0paI+kxSfdKOiC3boekR9PP8tZGbtYc4+LbU2atIGkCcB1wIrAFeEjS8ohYk6v2CNAbES9L+u/AF4CPp3W/jIjDWxq0WZP5TMOsuKOA9RGxMSK2A0uB0/IVIuL+iHg5LT4AdLU4RrNSOWmYFTcD2Jxb3pLKGjkPuDO3vIekPkkPSPpovQ0kXZDq9A0ODo49YrMm8+UpsxJIOhvoBT6YKz4gIgYkzQbuk/R4RGzIbxcRS4AlAL29vZ7sxirHZxpmxQ0AM3PLXalsF5JOAC4HTo2IbUPlETGQfm8EVgJHlBmsWRmcNMyKewg4UNIsSZOABcAu34KSdATwFbKE8WyufIqkyen1NOAYIH8D3awj+PKUWUER8YqkS4C7gQnADRGxWtKVQF9ELAeuAd4G3CoJ4F8i4lTgEOArkl4l+7C2qOZbV2YdwUnDbAQi4g7gjpqyK3KvT2iw3T8D7yk3OrPylXJ5qsADUF/KPeT0lKQXc+vOkbQu/ZxTRnxmZjY6TT/TKPIAVET8Qa7+/yDdEJS0D/AnZN86CaA/bftCs+M0M7ORK+NMY9gHoGqcCdyUXs8DVkTE8ylRrABGPN67mZmVo4ykUfgBqDQuzyzgvlFs64egzMxarN1fuV0ALIuIHSPdMCKWRERvRPROn97ymTjNzN6QykgahR6AShbw2qWpkW5rZmYtVkbSGPYBKABJ7wamAD/MFd8NfDg9CDUF+HAqMzOzCmj6t6cKPgAFWTJZGhGR2/Z5SVeRJR6AKyPi+WbHaGZmo1PKw33DPQCVlv+0wbY3ADeUEZeZmY1Nu2+Em5lZB3HSMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwM7PCnDTMRqDAsP+XSloj6TFJ96bx1fLr95S0RdLi1kVt1jxOGmYF5Yb9PwmYA5wpaU5NtUeA3oh4L7AM+ELN+quAfyw7VrOyOGmYFTfssP8RcX9EvJwWHyAbPw0ASUcC+wL/r0XxmjWdk4ZZcYWH7k/OA+4EkPQm4IvAH+5uBx7y36rOScOsBJLOJpuB8ppUdBFwR0Rs2d12HvLfqq6UsafMxqlCQ/dLOgG4HPhgRGxLxb8BfEDSRcDbgEmS/j0iXncz3azKnDTMits57D9ZslgA/Nd8BUlHAF8B5kfEs0PlEXFWrs65ZDfLnTCs4/jylFlBEfEKMDTs/5PALUPD/ks6NVW7huxM4lZJj0p63VwyZp3MZxpmIzDcsP8RcUKBNv4G+Jtmx2bWCj7TMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDbAQkzZe0VtJ6Sa+beU/SpZLWSHpM0r2SDkjlB0h6OE3MtFrSp1ofvdnYOWmYFSRpAnAdcBIwBzhT0pyaao+QTeX6XmAZ8IVU/gzwGxFxOPB+YKGkd7UmcrPmcdIwK+4oYH1EbIyI7cBS4LR8hYi4PyJeTosPAF2pfHtEbEvlk/G/PetQpXTc4U7hU50z0mn8aknfypXvSKfwnl/ZqmYGsDm3vCWVNXIecOfQgqSZkh5LbVwdEU+XEqVZiZo+R3juFP5Esn9UD0laHhFrcnUOBC4DjomIFyS9I9fEL9MpvFnHknQ20At8cKgsIjYD702Xpb4jaVlE/GvNdhcAFwDsv//+LYzYrJgyzjSGPYUHfh+4LiJeAIiIZ0uIw6zZBoCZueWuVLYLSScAlwOn5i5J7ZTOMJ4APlBn3ZKI6I2I3unTpzctcLNmKSNpFDmFPwg4SNIPJD0gaX5u3R6S+lL5RxvtRNIFqV7f4OBg86I3a+wh4EBJsyRNAhYAu1xClXQE8BWyhPFsrrxL0lvS6ynAbwFrWxa5WZM0/fLUCPZ7IHAs2ae1f5T0noh4ETggIgYkzQbuk/R4RGyobSAilgBLAHp7e6N1odsbVUS8IukS4G5gAnBDRKyWdCXQFxHLgWuAtwG3SgL4l4g4FTgE+KKkAAT8eUQ83pYDMRuDMpJGkVP4LcCDEfEfwCZJT5ElkYciYgAgIjZKWgkcAbwuaZi1Q0TcAdxRU3ZF7vUJDbZbAby33OjMylfG5alhT+GB75CdZSBpGtnlqo2SpkianCs/BliDmZlVgiKaf2VH0keAa3ntFP5z+VN4ZeftXwTmAzuAz0XEUkm/SXY9+FWyhHZtRHy9wP4GgZ82WD0NeG7MBzV2VYkDqhNLVeKA3cdyQES0/K50h/RrqE4sVYkDOiOWA4EfRsT8OusaKiVpVImkvojodRyvqUosVYkDqhVLEVWKtyqxVCUOGN+x+KlUMzMrzEnDzMwKeyMkjSXtDiCpShxQnViqEgdUK5YiqhRvVWKpShwwjmMZ9/c0zMysed4IZxpmZtYkThpmZlZYRyYNSftIWiFpXfo9pUG9c1KddZLOyZWvTEO3Dw3B/o5UPlnSzWlI9wcldZcZi6S3Srpd0o/TEPGLcvXPlTSYi/H8Bu0ON5Ncw2OSdFkqXytpXtE2d/O3GFUskk6U1C/p8fT7uNw2dd+rkuLolvTL3L6uz21zZIpvvaQvp2eNmq4qfbvd/TrVrUTfrkq/HmMszevbEdFxP2SzoS1MrxeSzU1QW2cfYGP6PSW9npLWrSSbXa12m4uA69PrBcDNZcYCvBX4UKozCfg+cFJaPhdYPMy+J5ANsTI7bf8jYE6RYyKbee5HZBMCzUrtTCjSZgmxHAG8K70+DBjIbVP3vSopjm7giQbtrgKOJhs36s6h92m89u129usq9e2q9Osq9e2OPNMgG2r9xvT6RqDeaLjzgBUR8XxkQ7CvIHsCvWi7y4DjC3yiHHUsEfFyRNwP2cxuwMOkmd4KKjIMfaNjOg1YGhHbImITsD61V6TNpsYSEY/EaxMSrQbeojSczCiM5W9Sl6T9gD0j4oHI/pV9k/rvczNUpW+3s19Ddfp2Vfr1mGJp1OBo+nanJo19I+KZ9PpnwL516gw3RPs30mnaZ3N/1J3bRMQrwEvA1BbEgqS9gVOAe3PFp0t6TNIySflBIAu3S+NjarTtSGena0YseacDD8eu81DUe6/KimOWpEck/YOkD+TqbxmmzWapSt9uZ78u1Dat6dtV6dfNiKUpfbtdQ6MPS9I9wDvrrLo8vxARoWy46ZE4K7Lh198O3AZ8gizDtiMWJE0EbgK+HBEbU/F3gZsiYpukC8k+PRzXqI3xQNKhwNXAh3PFI3qvxugZYP+I2CrpSLLZ9Q5t9k4q1Ldvk1QvcbhfN1EF+jU0sW935HMaktYCx0bEM5L2mzp16tPd3d3tDsvGqf7+/ueBwYh4N4CkM8n634XN3le+b0+bNi3cr60s/f39vyAblXy/kfTtyp5pDGM5cA6wCDinu7ubvr6+Nodk45WkTcCrko4GHgQ+CfxlSbvb2bfdr61MktZFxIckrRpJ3+7UexqLgBMlrQPqTnpj1mQXAV8ju6m6gexbJmXI922zMu1Iv0fUtzvyTCMitgLHDy17ulcrW0T0kX1tsuz97Ozb7tfWCiPt2516pmFmZm3gpGFmZoW1PGlImpC+K/y9BuvPkLRG2fAD32p1fGZ33XUXBx98MD09PSxatOh163czVMPuho2YJGmJpKeUDa9xessOyKyJ2nFP49PAk8CetSskHQhcBhwTES+o4HgsZs2yY8cOLr74YlasWEFXVxdz584F2KOm2nnACxHRI2kB2XfwP042D/MpEfG0pMOAu3ntQanLgWcj4iBJbyIbesOs47T0TENSF/DbZHfq6/l94Lo0JAER8WyrYjMDWLVqFT09PcyePZtJkyaxYMECgL1rqo1m2IjfAz4PEBGvRsRz5R6JWTlafXnqWuAzwKsN1h8EHCTpB5IekDTceDpmTTUwMMDMma+NbNHV1QXZ4HB5Ixo2Ig2lAXCVpIcl3Sqp3rAcSLpAUp+kvsHBwbEfkFmTtSxpSDqZ7PS8fzfVJgIHAscCZwJfzf2Dq23P/7isknLDRgw9VTuRbMC+f46I9wE/BP683rYRsSQieiOid/r06S2J12wkWnmmcQxwqqSfkI3OeJykv6upswVYHhH/kUanfIosibyO/3FZGWbMmMHmza+NCbdlyxaA7TXVBoCZsHN8pb2ArWm5C/g28MmI2JDqbwVeBv4+Ld8KvK+cIzArV8uSRkRcFhFdEdFNNs77fRFxdk2175CdZSBpGtnlqo2YtcjcuXNZt24dmzZtYvv27SxduhTgxZpqQ0N9AHyMrC9HOiu+nWweih8MVU5DTn+X1LfJHt5bU+JhmJWm7c9pSLpS0qlp8W5gq6Q1wP3A/0pPyJq1xMSJE1m8eDHz5s3jkEMO4YwzzgD4VU0//TowVdJ64FKySYoALgF6gCv0+hnZ/gj4U0mPkY1o+j9bdlBmTdSRo9zW6u3tDQ/sZmWR1B8Rva3er/u1lWm0/brtZxpmZtY5nDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw2zGnfddRcHH3wwPT09LFq06HXrJU2WdLOk9ZIelNSdyk+U1C/p8fT7uNw2KyWtrTPPhllHmdjuAMyqZMeOHVx88cWsWLGCrq4u5s6dC7BHTbXzgBciokfSArL5wD8OPAecEhFPSzqMbFKxGbntzooIT5BhHc1nGmY5q1atoqenh9mzZzNp0iQWLFgAsHdNtdOAG9PrZcDxkhQRj0TE06l8NfAWSZNbE7lZazhpmOUMDAwwc+bMnctdXV0Ak2qqzQA2A0TEK8BLwNSaOqcDD0fEtlzZN9Klqc9KUrNjN2uFlicNSRMkPSLpe7upc7qkkNTyKTbNxkrSoWSXrC7MFZ8VEe8BPpB+PtFg2wsk9UnqGxwcLD9YsxFqx5nGp4EnG62U9PZU58GWRWSWzJgxg82bN+9c3rJlC8D2mmoDwEwASROBvYCtabkL+DbwyYjYMLRBRAyk3/8GfAs4qt7+I2JJRPRGRO/06dObdFRmzdPSpJH+Qf028LXdVLuK7FPar1oSlFnO3LlzWbduHZs2bWL79u0sXboU4MWaasuBc9LrjwH3RURI2hu4HVgYET8YqixpoqRp6fWbgZOBJ8o+FrMytPpM41rgM8Cr9VZKeh8wMyJuH64hn8ZbGSZOnMjixYuZN28ehxxyCGeccQbAryRdKenUVO3rwFRJ64FLgYWp/BKgB7ii5qu1k4G7JT0GPEp2pvLVVh6XWbMoIlqzI+lk4CMRcZGkY4E/jIiTc+vfBNwHnBsRP5G0MtUZ9iuKvb290dfnbzJaOST1R0TL76+5X1uZRtuvW3mmcQxwqqSfAEuB4yT9XW7924HDgJWpztHAct8MNzOrjpYljYi4LCK6IqIbWEB2Hfjs3PqXImJaRHSnOg8Ap/phKDOz6mj7cxo114rNzKzC2jKMSESsBFam11c0qHNs6yIyM7Mi2n6mYWZmncNJw8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzquOuuuzj44IPp6ekBeGftekmTJd0sab2kByV1p/ITJfVLejz9Pq7OtssleeY+60hOGmY1duzYwcUXX8ydd97JmjVrAPaRNKem2nnACxHRA3yJbIpigOeAUyLiPWRTwv5tfiNJvwP8e6kHYFYiJw2zGqtWraKnp4fZs2czadIkgOeB02qqnQbcmF4vA46XpIh4JCKeTuWrgbdImgwg6W1k08P+WekHYVYSJw2zGgMDA8ycOTNftB2YUVNtBrAZICJeAV4CptbUOR14OCK2peWrgC8CLzfat6QLJPVJ6hscHBz9QZiVxEnDrASSDiW7ZHVhWj4c+E8R8e3dbRcRSyKiNyJ6p0+f3oJIzUbGScOsxowZM9i8eXO+aBIwUFNtAJgJIGkisBewNS13Ad8GPhkRG1L93wB6Jf0E+CfgIEkrSzoEs9K0PGlImiDpEUnfq7PuUklrJD0m6V5JB7Q6PrO5c+eybt06Nm3axPbt2wH2AZbXVFtOdqMb4GNkc96HpL2B24GFEfGDocoR8dcR8a6I6AZ+C3jKs1NaJ2rHmcangScbrHsE6I2I95LdXPxCy6IySyZOnMjixYuZN28ehxxyCMDzEbG6Zj77rwNTJa0nu7m9MJVfAvQAV0h6NP28o+UHYVYSRUTrdpadtt8IfA64NCJO3k3dI4DFEXHMcO329vZGX19f8wI1y5HUHxG9rd6v+7WVabT9utVnGtcCnwFeLVD3PODORiv9LRMzs9ZrWdKQdDLwbET0F6h7NtALXNOojr9lYmbWei27PCXp88AngFeAPYA9gb+PiLNr6p0A/CXwwYh4tmDbg8BPG6yeRvaUbrtVJQ6oTixViQN2H8sBEdHyTyYd0q+hOrFUJQ7ojFgOBH4YEfNH0lhL72ns3Kl0LPCHtfc00n2MZcD8iFjXpH31teN6dFXjgOrEUpU4oFqxFFGleKsSS1XigPEdS9uf06j5Rso1wNuAW9O3Tmq/5mhmZm00sR07jYiVwMr0+opc+QntiMfMzIpp+5lGCyxpdwBJVeKA6sRSlTigWrEUUaV4qxJLVeKAcRxLW+5pmJlZZ3ojnGmYmVmTOGmYmVlhHZk0JO0jaYWkden3lAb1zkl11kk6J1e+UtLa2rGBGk3hWVYskt4q6XZJP5a0WtKiXP1zJQ3mYjy/Qbvz07Gsl7SwzvqGxyTpslS+VtK8om3u5m8xqli0mylSG71XJcXRLemXuX1dn9vmyBTfeklflqSif5eRqErfbne/TnUr0ber0q/HGEvz+nZEdNwP2UCGC9PrhcDVdersA2xMv6ek11PSupVkAyPWbnMRcH16vQC4ucxYgLcCH0p1JgHfB05Ky+eSjb21u31PADYAs9P2PwLmFDkmYE6qPxmYldqZUKTNEmI5AnhXen0YMJDbpu57VVIc3cATDdpdBRwNiGx4m5PGc99uZ7+uUt+uSr+uUt/uyDMNdp1q80bgo3XqzANWRMTzEfECsAIY7snHulN4lhVLRLwcEfcDRMR24GGga5j95R0FrI+IjWn7pRScljSVL42IbRGxCVif2ivSZlNjid1MkToKY/mb1CVpP2DPiHggsn9l36T++9wMVenb7ezXUJ2+XZV+PaZYGjU4mr7dqUlj34h4Jr3+GbBvnTo7p+NMtrDrlJ3fSKdpn839UYtM4VlGLCibh+EU4N5c8enK5hZZJmmX+UeLtkvjY2q0bZE26xlLLHm1U6RC/feqrDhmKZvv5R8kfSBXf8swbTZLVfp2O/t1obZpTd+uSr9uRixN6dttebivCEn3AO+ss+ry/EJEhKSRfm/4rIgYkPR24DayMbG+2aZYhmZ+uwn4ckRsTMXfBW6KiG2SLiT79HBcozbGA702ReqHc8Ujeq/G6Blg/4jYKulI4DsppqaqUN++TVK9xOF+3UQV6NfQxL7dkc9pSFoLHBsRz0jab+rUqU93d3e3Oywbp/r7+58HBiPi3ZLmAzcAvwZ8PiIW5eumyw/fBI4km/714xHxk3RD8klgbar6QER8qnZf+b49bdq0cL+2svT39/8CeAjYLyLeDSDpTLL+d2Gj7Sp7pjGMoak2FwHndHd348lqrCySNgGvSvpN4DrgKeAvgKskLY+INbnq5wEvRESPpAVknzA/ntZtiIjDh9ndzr7tfm1lkrQuIj4kaZWko4EHgU+SjTLeUKfe01gEnChpHeDxqqwVLgL+FtgPeILsMsuYb0TWke/bZmXakX5fBHyN7AsDG9jN5HfQoWcaEbEVOH5oube3t/OusVlHiYg+SX9E9u2gSwAkbQHeX1N1lxuRkl53IxL4OfDHEfH9Ors6HdgLeMkzUlorREQf2VeCCyl0pjHaB0rSuroP2aR1E9Ld/O/lymalNtanNicVPRizChu6EXkEcCnwLUl71lYKz0hpFTds0pA0gew67klkD82cKWlOTbWd13GBL5FdxyXVWwAcSvY98r9K7Q35NNnNwbyrgS+ltl5IbZtVwQCQ/4poVyqrWyd9e2gvYGt6ZmArQGRTHm8ADio9YrMmK3KmUcZDNkjqAn6b7FoaqUxkX79blooaPVRk1g4PAQems+FJZB+IaicKG7qRDfAx4L70ldXpQx+YJM0mm2pzI2YdpkjSKOMhG4Brgc8Ar+bWTwVeTG002hcAki6Q1Cepz9d+rRVSv7wEuJvsDPmWiFitXWef/DowVdJ6sstQQ5dz/zPwmKRHyT4UfSoinm/tEZiNXVtuhEs6GXg2IvqVzRc+YhGxhDS5iG+EW6tExB3AHTVl+dknfwX8bp3tbiN7iMusoxU50xj1ddzdbHsMcKqkn5Bd7jpO0t+lbfZObTTal5mZtUmRpDHq67ipfEH6dtUssuu4qyLisojoioju1N59EXF22ub+1Aapzf87huMzM7MmGjZpjOU6bkSsBm4B1gB3ARdHxI7afdT4I+DS1NbU1LaZmVVAR449Vau3tzc83IKVRVJ/RPS2er/u11am0fbrTh1GxMzM2sBJw8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNsxGQNF/SWknrJS2ss36ypJvT+gcldefWXZbK10qa18q4zZrFScOsIEkTgOuAk4A5wJmS5tRUOw94ISJ6gC8BV6dt5wALgEOB+cBfpfbMOoqThllxRwHrI2JjRGwHlgKn1dQ5DbgxvV4GHC9JqXxpRGyLiE3A+tSeWUdx0jArbgawObe8JZXVrRMRrwAvAVMLboukCyT1SeobHBxsYuhmzeGkYVYhEbEkInojonf69OntDsfsdQoljWbf/JO0h6RVkn4kabWk/52rf7ykhyU9KumfJPWM/TDNmmIAmJlb7kpldetImgjsBWwtuK1Z5Q2bNEq6+bcNOC4ifh04HJgv6ejU1l8DZ0XE4cC3gD8e2yGaNc1DwIGSZkmaRNa3l9fUWQ6ck15/DLgvIiKVL0gfsGYBBwKrWhS3WdMUOdNo+s2/yPx7qv/m9BNpOYA90+u9gKdHcVxmTZfuUVwC3A08CdwSEaslXSnp1FTt68BUSeuBS4GFadvVwC3AGuAu4OKI2NHqYzAbq4kF6tS7gff+RnUi4hVJ+Zt/D9RsOwN2nsH0Az3AdRHxYKpzPnCHpF8CPweOpg5JFwAXAOy///4FDsNs7CLiDuCOmrIrcq9/Bfxug20/B3yu1ADNSta2G+ERsSNdguoCjpJ0WFr1B8BHIqIL+AbwFw229w1DM7MWK5I0Sr35FxEvAveT3deYDvx67qzjZuA3Cx2JmZmVrkjSaPrNP0nTJe0NIOktwInAj4EXgL0kHZTaOpHs2rGZmVXAsPc00j2KoZt/E4Abhm7+AX0RsZzs5t/fppt/z5MlFlK9oZt/r5Bu/knaD7gx3dd4E9kNxe8BSPp94DZJr5Ilkd9r8jGbmdkoKTsh6Gy9vb3R19fX7jBsnJLUHxG9rd6v+7WVabT92k+Em5lZYU4aZmZWmJOGmZkV5qRhZmaFOWmYmVlhThpmZlaYk4aZmRXmpGFmZoU5aZiZWWFOGmZmVpiThpmZFeakYWZmhTlpmJlZYU4aZmZWmJOGmZkV5qRhVoCkfSStkLQu/Z7SoN45qc46SefkyldKWivp0fTzjtZFb9Y8ThpmxSwE7o2IA4F70/IuJO0D/AnwfuAo4E9qkstZEXF4+nm2FUGbNZuThlkxpwE3ptc3Ah+tU2cesCIino+IF4AVwPwWxWfWEk4aZsXsGxHPpNc/A/atU2cGsDm3vCWVDflGujT1WUmqtxNJF0jqk9Q3ODjYlMDNmmliuwMwq4oTTjiBn/3sZ/VW7Z1fiIiQFCNs/qyIGJD0duA24BPAN2srRcQSYAlkc4SPcB9mpXPSMEvuueeeuuWSXgR2SNovIp6RtB9Q757EAHBsbrkLWAkQEQPp979J+hbZPY/XJQ2zqlNE53+YkTQI/LTB6mnAcy0Mp5GqxAHViaUqccDuYzkA+Btga0QskrQQ2CciPpOvlG6E9wPvS0UPA0cCPwf2jojnJL0ZuAm4JyKu311AHdKvoTqxVCUO6IxYDgR+GBEjuu82Ls40ImJ6o3WS+iKit5XxVDkOqE4sVYkDho9F0lTgFknnkf1HfkYq7wU+FRHnR8Tzkq4CHkqbXZnKfg24OyWMCcA9wFeHi6kT+jVUJ5aqxAHjO5ZxkTTMyhYRW4Hj65T3Aefnlm8Abqip8wuyMw6zjudvT5mZWWFvhKSxpN0BJFWJA6oTS1XigGrFUkSV4q1KLFWJA8ZxLOPiRriZmbXGG+FMw8zMmsRJw8zMCuvIpFHWiKOSJku6WdJ6SQ9K6i4zFklvlXS7pB9LWi1pUa7+uZIGczGe36Dd+elY1qfnB2rXNzwmSZel8rWS5hVtczd/i1HFIulESf2SHk+/j8ttM+LRYccQR+TnD6sAAAPeSURBVLekX+b2dX1umyNTfOslfbnRMCBjVZW+3e5+nepWom9XpV+PMZbm9e2I6Lgf4AvAwvR6IXB1nTr7ABvT7ynp9ZS0biXQW2ebi4Dr0+sFwM1lxgK8FfhQqjMJ+D5wUlo+F1g8zL4nABuA2Wn7HwFzihwTMCfVnwzMSu1MKNJmCbEcAbwrvT4MGMhtU/e9KimObuCJBu2uAo4GBNw59D6N177dzn5dpb5dlX5dpb7dkWcalDfiaL7dZcDxBT5RjjqWiHg5Iu4HiIjtZE8Qdw2zv7yjgPURsTFtvzTFU+SYTgOWRsS2iNgErE/tFWmzqbFExCMR8XQqXw28RdLkQn+BJsbRqEFlw4bsGREPRPav7JvUf5+boSp9u539GqrTt6vSr8cUS6MGR9O3OzVplDXi6M5tIuIV4CVgagtiQdLewClkczUMOV3SY5KWSZo5mnZpfEyNti3SZj1jiSXvdODhiNiWKxt2dNgmxjFL0iOS/kHSB3L1twzTZrNUpW+3s18XapvW9O2q9OtmxNKUvl3ZJ8Il3QO8s86qy/MLEeWNONqiWJA0kWw8oi9HxMZU/F3gpojYJulCsk8PxzVqYzyQdChwNfDhXPGI3qsxegbYPyK2SjoS+E6Kqakq1LdvUzY8ShlxuF8nFejX0MS+XdmkEREnNFon6V9VzoijA8BMYEvq8HuRDVJXWizJEmBdRFw7VBDZsBVDvkZ2jbleu/lPal2prF6dXY5pmG2Ha7OescSCpC7g28AnI2LD0Aa7ea+aHkc6Pd+W9tcvaQNwUKqfv7xS9G9SV4X6dk865qbHkYy2Xw+1XYW+XZV+PaZYmtq3d3fDo6o/wDXsepPuC3Xq7ANsIrsxNyW93ocsUU5Ldd5Mdt3vU2n5Yna9iXRLmbGkdX9G9knjTTXb7Jd7/V+AB+q0O5Hs5uMsXrsxdmhNnbrHBBzKrjcLN5LdaBu2zQZ/h7HEsneq/zt12qz7XpUUx3RgQno9m+wfz9D7VHuz8CPjuW+3s19XqW9XpV9XqW+X9h97mT9k1+juBdaRjRg6dPC9wNdy9X6P7CbYeuC/pbJfIxu++jGym1P/J/fH3AO4NdVfBcwuOZYuIIAngUfTz/lp3edTfD8C7gfe3WD/HwGeIvtWxeWp7Erg1OGOiewyxAZgLblvTNRrs+D7MqpYgD8GfpH7GzwKvGN371VJcZye9vMo2c3bU3Jt9gJPpDYXk0ZTGK99e4xxjLlfV6lvj6E/NbVfV6VvexgRMzMrrFO/PWVmZm3gpGFmZoU5aZiZWWFOGmZmVpiThpmZFeakYWZmhTlpmJlZYf8fZfscNVzx1hMAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(0.3201, grad_fn=<NllLossBackward>)\n",
            "[0.32006189227104187]\n",
            "tensor(0.3409, grad_fn=<DivBackward0>)\n",
            "[0.32006189227104187, 0.3409154713153839]\n",
            "tensor(1.7733, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)\n",
            "[0.32006189227104187, 0.3409154713153839, 1.773283839225769]\n",
            "tensor(0.0338, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)\n",
            "[0.32006189227104187, 0.3409154713153839, 1.773283839225769, 0.033820658922195435]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tnHCqPL44qlc"
      },
      "source": [
        "# ! echo $PYTHONPATH\n",
        "\n",
        "# import os\n",
        "# print(os.environ['PYTHONPATH'])\n",
        "# os.environ['PYTHONPATH'] += \":/content/gdrive/My Drive/Colab Notebooks/MaskRCNN_tutorial/src\"\n",
        "# print(os.environ['PYTHONPATH'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TyRDAp8U4r8W"
      },
      "source": [
        "# !pip install utils"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kilctl--7Eyd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s2eH7O1gq33Q",
        "outputId": "db2b57b3-b81c-4bd2-fb12-2cb260b6a518",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]\n",
        "predictions = model(x)\n",
        "print(predictions)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[{'boxes': tensor([], size=(0, 4), grad_fn=<StackBackward>), 'labels': tensor([], dtype=torch.int64), 'scores': tensor([], grad_fn=<IndexBackward>)}, {'boxes': tensor([], size=(0, 4), grad_fn=<StackBackward>), 'labels': tensor([], dtype=torch.int64), 'scores': tensor([], grad_fn=<IndexBackward>)}]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eAoSwZ4C0JEY"
      },
      "source": [
        "print(output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4Tn-KAs1X8q",
        "outputId": "fc366c9e-baf5-4933-a92d-b34584a4a549",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 460
        }
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(0, 10*np.pi, 100)\n",
        "y = np.sin(x)\n",
        "\n",
        "plt.ion()\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "line1, = ax.plot(x, y, 'b-')\n",
        "\n",
        "for phase in np.linspace(0, 10*np.pi, 100):\n",
        "  line1.set_ydata(np.sin(0.5 * x + phase))\n",
        "  sleep(4)\n",
        "  plt.show()"
      ],
      "execution_count": 245,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-245-525887982835>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mphase\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m   \u001b[0mline1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_ydata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.5\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mphase\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m   \u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m   \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6KGmJ0NDYjBD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}