samples/shapes/train_shapes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mask R-CNN - Train on Shapes Dataset\n",
    "\n",
    "\n",
    "This notebook shows how to train Mask R-CNN on your own dataset. To keep things simple we use a synthetic dataset of shapes (squares, triangles, and circles) which enables fast training. You'd still need a GPU, though, because the network backbone is a Resnet101, which would be too slow to train on a CPU. On a GPU, you can start to get okay-ish results in a few minutes, and good results in less than an hour.\n",
    "\n",
    "The code of the *Shapes* dataset is included below. It generates images on the fly, so it doesn't require downloading any data. And it can generate images of any size, so we pick a small image size to train faster. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import random\n",
    "import math\n",
    "import re\n",
    "import time\n",
    "import numpy as np\n",
    "import cv2\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Root directory of the project\n",
    "ROOT_DIR = os.path.abspath(\"../../\")\n",
    "\n",
    "# Import Mask RCNN\n",
    "sys.path.append(ROOT_DIR)  # To find local version of the library\n",
    "from mrcnn.config import Config\n",
    "from mrcnn import utils\n",
    "import mrcnn.model as modellib\n",
    "from mrcnn import visualize\n",
    "from mrcnn.model import log\n",
    "\n",
    "%matplotlib inline \n",
    "\n",
    "# Directory to save logs and trained model\n",
    "MODEL_DIR = os.path.join(ROOT_DIR, \"logs\")\n",
    "\n",
    "# Local path to trained weights file\n",
    "COCO_MODEL_PATH = os.path.join(ROOT_DIR, \"mask_rcnn_coco.h5\")\n",
    "# Download COCO trained weights from Releases if needed\n",
    "if not os.path.exists(COCO_MODEL_PATH):\n",
    "    utils.download_trained_weights(COCO_MODEL_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Configurations:\n",
      "BACKBONE                       resnet101\n",
      "BACKBONE_STRIDES               [4, 8, 16, 32, 64]\n",
      "BATCH_SIZE                     2\n",
      "BBOX_STD_DEV                   [0.1 0.1 0.2 0.2]\n",
      "COMPUTE_BACKBONE_SHAPE         None\n",
      "DETECTION_MAX_INSTANCES        100\n",
      "DETECTION_MIN_CONFIDENCE       0.7\n",
      "DETECTION_NMS_THRESHOLD        0.3\n",
      "FPN_CLASSIF_FC_LAYERS_SIZE     1024\n",
      "GPU_COUNT                      1\n",
      "GRADIENT_CLIP_NORM             5.0\n",
      "IMAGES_PER_GPU                 2\n",
      "IMAGE_CHANNEL_COUNT            3\n",
      "IMAGE_MAX_DIM                  128\n",
      "IMAGE_META_SIZE                16\n",
      "IMAGE_MIN_DIM                  128\n",
      "IMAGE_MIN_SCALE                0\n",
      "IMAGE_RESIZE_MODE              square\n",
      "IMAGE_SHAPE                    [128 128   3]\n",
      "LEARNING_MOMENTUM              0.9\n",
      "LEARNING_RATE                  0.001\n",
      "LOSS_WEIGHTS                   {'rpn_class_loss': 1.0, 'rpn_bbox_loss': 1.0, 'mrcnn_class_loss': 1.0, 'mrcnn_bbox_loss': 1.0, 'mrcnn_mask_loss': 1.0}\n",
      "MASK_POOL_SIZE                 14\n",
      "MASK_SHAPE                     [28, 28]\n",
      "MAX_GT_INSTANCES               100\n",
      "MEAN_PIXEL                     [123.7 116.8 103.9]\n",
      "MINI_MASK_SHAPE                (56, 56)\n",
      "NAME                           shapes\n",
      "NUM_CLASSES                    4\n",
      "POOL_SIZE                      7\n",
      "POST_NMS_ROIS_INFERENCE        1000\n",
      "POST_NMS_ROIS_TRAINING         2000\n",
      "PRE_NMS_LIMIT                  6000\n",
      "ROI_POSITIVE_RATIO             0.33\n",
      "RPN_ANCHOR_RATIOS              [0.5, 1, 2]\n",
      "RPN_ANCHOR_SCALES              (8, 16, 32, 64, 128)\n",
      "RPN_ANCHOR_STRIDE              1\n",
      "RPN_BBOX_STD_DEV               [0.1 0.1 0.2 0.2]\n",
      "RPN_NMS_THRESHOLD              0.7\n",
      "RPN_TRAIN_ANCHORS_PER_IMAGE    256\n",
      "STEPS_PER_EPOCH                100\n",
      "TOP_DOWN_PYRAMID_SIZE          256\n",
      "TRAIN_BN                       False\n",
      "TRAIN_ROIS_PER_IMAGE           32\n",
      "USE_MINI_MASK                  True\n",
      "USE_RPN_ROIS                   True\n",
      "VALIDATION_STEPS               5\n",
      "WEIGHT_DECAY                   0.0001\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class ShapesConfig(Config):\n",
    "    \"\"\"Configuration for training on the toy shapes dataset.\n",
    "    Derives from the base Config class and overrides values specific\n",
    "    to the toy shapes dataset.\n",
    "    \"\"\"\n",
    "    # Give the configuration a recognizable name\n",
    "    NAME = \"shapes\"\n",
    "\n",
    "    # Train on 1 GPU and 8 images per GPU. We can put multiple images on each\n",
    "    # GPU because the images are small. Batch size is 8 (GPUs * images/GPU).\n",
    "    GPU_COUNT = 1\n",
    "    IMAGES_PER_GPU = 2\n",
    "\n",
    "    # Number of classes (including background)\n",
    "    NUM_CLASSES = 1 + 3  # background + 3 shapes\n",
    "\n",
    "    # Use small images for faster training. Set the limits of the small side\n",
    "    # the large side, and that determines the image shape.\n",
    "    IMAGE_MIN_DIM = 128\n",
    "    IMAGE_MAX_DIM = 128\n",
    "\n",
    "    # Use smaller anchors because our image and objects are small\n",
    "    RPN_ANCHOR_SCALES = (8, 16, 32, 64, 128)  # anchor side in pixels\n",
    "\n",
    "    # Reduce training ROIs per image because the images are small and have\n",
    "    # few objects. Aim to allow ROI sampling to pick 33% positive ROIs.\n",
    "    TRAIN_ROIS_PER_IMAGE = 32\n",
    "\n",
    "    # Use a small epoch since the data is simple\n",
    "    STEPS_PER_EPOCH = 100\n",
    "\n",
    "    # use small validation steps since the epoch is small\n",
    "    VALIDATION_STEPS = 5\n",
    "    \n",
    "config = ShapesConfig()\n",
    "config.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook Preferences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ax(rows=1, cols=1, size=8):\n",
    "    \"\"\"Return a Matplotlib Axes array to be used in\n",
    "    all visualizations in the notebook. Provide a\n",
    "    central point to control graph sizes.\n",
    "    \n",
    "    Change the default size attribute to control the size\n",
    "    of rendered images\n",
    "    \"\"\"\n",
    "    _, ax = plt.subplots(rows, cols, figsize=(size*cols, size*rows))\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "\n",
    "Create a synthetic dataset\n",
    "\n",
    "Extend the Dataset class and add a method to load the shapes dataset, `load_shapes()`, and override the following methods:\n",
    "\n",
    "* load_image()\n",
    "* load_mask()\n",
    "* image_reference()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShapesDataset(utils.Dataset):\n",
    "    \"\"\"Generates the shapes synthetic dataset. The dataset consists of simple\n",
    "    shapes (triangles, squares, circles) placed randomly on a blank surface.\n",
    "    The images are generated on the fly. No file access required.\n",
    "    \"\"\"\n",
    "\n",
    "    def load_shapes(self, count, height, width):\n",
    "        \"\"\"Generate the requested number of synthetic images.\n",
    "        count: number of images to generate.\n",
    "        height, width: the size of the generated images.\n",
    "        \"\"\"\n",
    "        # Add classes\n",
    "        self.add_class(\"shapes\", 1, \"square\")\n",
    "        self.add_class(\"shapes\", 2, \"circle\")\n",
    "        self.add_class(\"shapes\", 3, \"triangle\")\n",
    "\n",
    "        # Add images\n",
    "        # Generate random specifications of images (i.e. color and\n",
    "        # list of shapes sizes and locations). This is more compact than\n",
    "        # actual images. Images are generated on the fly in load_image().\n",
    "        for i in range(count):\n",
    "            bg_color, shapes = self.random_image(height, width)\n",
    "            self.add_image(\"shapes\", image_id=i, path=None,\n",
    "                           width=width, height=height,\n",
    "                           bg_color=bg_color, shapes=shapes)\n",
    "\n",
    "    def load_image(self, image_id):\n",
    "        \"\"\"Generate an image from the specs of the given image ID.\n",
    "        Typically this function loads the image from a file, but\n",
    "        in this case it generates the image on the fly from the\n",
    "        specs in image_info.\n",
    "        \"\"\"\n",
    "        info = self.image_info[image_id]\n",
    "        bg_color = np.array(info['bg_color']).reshape([1, 1, 3])\n",
    "        image = np.ones([info['height'], info['width'], 3], dtype=np.uint8)\n",
    "        image = image * bg_color.astype(np.uint8)\n",
    "        for shape, color, dims in info['shapes']:\n",
    "            image = self.draw_shape(image, shape, dims, color)\n",
    "        return image\n",
    "\n",
    "    def image_reference(self, image_id):\n",
    "        \"\"\"Return the shapes data of the image.\"\"\"\n",
    "        info = self.image_info[image_id]\n",
    "        if info[\"source\"] == \"shapes\":\n",
    "            return info[\"shapes\"]\n",
    "        else:\n",
    "            super(self.__class__).image_reference(self, image_id)\n",
    "\n",
    "    def load_mask(self, image_id):\n",
    "        \"\"\"Generate instance masks for shapes of the given image ID.\n",
    "        \"\"\"\n",
    "        info = self.image_info[image_id]\n",
    "        shapes = info['shapes']\n",
    "        count = len(shapes)\n",
    "        mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\n",
    "        for i, (shape, _, dims) in enumerate(info['shapes']):\n",
    "            mask[:, :, i:i+1] = self.draw_shape(mask[:, :, i:i+1].copy(),\n",
    "                                                shape, dims, 1)\n",
    "        # Handle occlusions\n",
    "        occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n",
    "        for i in range(count-2, -1, -1):\n",
    "            mask[:, :, i] = mask[:, :, i] * occlusion\n",
    "            occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\n",
    "        # Map class names to class IDs.\n",
    "        class_ids = np.array([self.class_names.index(s[0]) for s in shapes])\n",
    "        return mask.astype(np.bool), class_ids.astype(np.int32)\n",
    "\n",
    "    def draw_shape(self, image, shape, dims, color):\n",
    "        \"\"\"Draws a shape from the given specs.\"\"\"\n",
    "        # Get the center x, y and the size s\n",
    "        x, y, s = dims\n",
    "        if shape == 'square':\n",
    "            cv2.rectangle(image, (x-s, y-s), (x+s, y+s), color, -1)\n",
    "        elif shape == \"circle\":\n",
    "            cv2.circle(image, (x, y), s, color, -1)\n",
    "        elif shape == \"triangle\":\n",
    "            points = np.array([[(x, y-s),\n",
    "                                (x-s/math.sin(math.radians(60)), y+s),\n",
    "                                (x+s/math.sin(math.radians(60)), y+s),\n",
    "                                ]], dtype=np.int32)\n",
    "            cv2.fillPoly(image, points, color)\n",
    "        return image\n",
    "\n",
    "    def random_shape(self, height, width):\n",
    "        \"\"\"Generates specifications of a random shape that lies within\n",
    "        the given height and width boundaries.\n",
    "        Returns a tuple of three valus:\n",
    "        * The shape name (square, circle, ...)\n",
    "        * Shape color: a tuple of 3 values, RGB.\n",
    "        * Shape dimensions: A tuple of values that define the shape size\n",
    "                            and location. Differs per shape type.\n",
    "        \"\"\"\n",
    "        # Shape\n",
    "        shape = random.choice([\"square\", \"circle\", \"triangle\"])\n",
    "        # Color\n",
    "        color = tuple([random.randint(0, 255) for _ in range(3)])\n",
    "        # Center x, y\n",
    "        buffer = 20\n",
    "        y = random.randint(buffer, height - buffer - 1)\n",
    "        x = random.randint(buffer, width - buffer - 1)\n",
    "        # Size\n",
    "        s = random.randint(buffer, height//4)\n",
    "        return shape, color, (x, y, s)\n",
    "\n",
    "    def random_image(self, height, width):\n",
    "        \"\"\"Creates random specifications of an image with multiple shapes.\n",
    "        Returns the background color of the image and a list of shape\n",
    "        specifications that can be used to draw the image.\n",
    "        \"\"\"\n",
    "        # Pick random background color\n",
    "        bg_color = np.array([random.randint(0, 255) for _ in range(3)])\n",
    "        # Generate a few random shapes and record their\n",
    "        # bounding boxes\n",
    "        shapes = []\n",
    "        boxes = []\n",
    "        N = random.randint(1, 4)\n",
    "        for _ in range(N):\n",
    "            shape, color, dims = self.random_shape(height, width)\n",
    "            shapes.append((shape, color, dims))\n",
    "            x, y, s = dims\n",
    "            boxes.append([y-s, x-s, y+s, x+s])\n",
    "        # Apply non-max suppression wit 0.3 threshold to avoid\n",
    "        # shapes covering each other\n",
    "        keep_ixs = utils.non_max_suppression(np.array(boxes), np.arange(N), 0.3)\n",
    "        shapes = [s for i, s in enumerate(shapes) if i in keep_ixs]\n",
    "        return bg_color, shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training dataset\n",
    "dataset_train = ShapesDataset()\n",
    "dataset_train.load_shapes(500, config.IMAGE_SHAPE[0], config.IMAGE_SHAPE[1])\n",
    "dataset_train.prepare()\n",
    "\n",
    "# Validation dataset\n",
    "dataset_val = ShapesDataset()\n",
    "dataset_val.load_shapes(50, config.IMAGE_SHAPE[0], config.IMAGE_SHAPE[1])\n",
    "dataset_val.prepare()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAACZCAYAAABHTieHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAC+pJREFUeJzt3XuspdVdx+HvD2kIXpIypRaiMQ0VLKBWYrHSVmfatIGUUm2txsZ7McE402gpaawaRFqLEho1GayXItVoYhNTsBUaGuRSwKEQIGpbIuAt0XIpHcSqOFi6/GO/x25OhzkzzF7nffc+z5OccPZ79rx7HbLmnP3Z6117qrUWAACARTti7AEAAACrSWwAAABdiA0AAKALsQEAAHQhNgAAgC7EBgAA0MXKxEZVvbCqrl937IFncZ6PVdVpw+evq6q9VVXD7Uur6scO4hzvrqp/mR9PVZ1WVbdV1Seq6oaqOmE4fsJw7KaqurGqvvEA531RVd1VVf9ZVa+cO/5bVXX78PELc8ffVVV3VtUdVXX+of6/YDlU1XFV9b5DuP9NB5pnAACLsjKxsUC3JnnF8Pkrktyd5NS527ccxDl+J8mr1h17MMlZrbXvTXJZkl8djv9skitaazuS/FGStx3gvA8meW2SP193/PLW2ncneXmS7xui5OuSvDXJ2vGfqaqvOYixs2Raaw+11t6x/nhVfdUY44Fny5wFWD1bLjaq6v1V9eNVdURVXVdVL1t3l1uTrK0avCTJ+5O8sqqOSnJca+2fN3qM1tqDSb607thDrbUvDDefTPLF4fNPJ3nu8Pm2JI9U1VFVdWtVvbiqXjCsTDy3tfbfrbW9+3m8+4f/finJU8PHE0k+m+To4eOJJP+70dhZDlX161W1Z1gNO29tFa2qLqqqD1bVR5L8UFW9alhRu6mqfnM/57mkqm4ezvX6Tf9GWCpVdercvPtYVZ0y/Hy6pqr+uKouGu73wNyf+UBV7Rg+v26Yi3dU1RnDsfVzdvswJ2+qqt9dW1kGYDkdOfYAFuw7q+qmDe7z9iQ3ZLZK8VettU+u+/onk/xhVT0nSUvyiSTvS/KpJHckyfBL8pL9nPvi1toNB3rwYXXh15L81HDo+iTXVdW5SY5K8l2ttX1V9dYkH0zyeJKfb639+wbfV4ZLvP5hLYiq6tokf59ZVL6ntfbkRudg+qrqdUm+KcnLW2utql6U5Afn7rKvtfaG4UnavUm2t9YeXv+qcVWdleSY1tr2qvrqJHuq6prWWtus74Wlc2aSK1trv19VRyS5KsnPtdb2VNUfHMSff1Nr7b+q6uQklyd59XB8fs7enWRHa+3xIZDPTvKXHb4XADbBqsXGXa2116zd2N+ejdba/1TVlUkuTXL8M3z9kSRvSnJPa+1zVXVcZqsdtw732ZNkx6EObgiYDyW5pLX2meHwbyT55dbah6vqLUnem2Rna+2+qvqnJNtaa399EOd+TZKfSHLOcPukJD+Q5ITMYuPmqrq6tfZvhzpuJudbk9w4FwVPrfv62nx5fpLPt9YeTpLW2vr7fVuS7XOBflSS5yV5dOEjZlVcmeSXqupPk/xtkhMzvAiT2Qs1+9sLtLbn7egkv11V35LZnP2Gufuszdljk7wwyV8MCxpfm9kLJnBYqmpXkjcneaC19tNjj4etaavOw614GdXxSc5N8p7Mntjvz61J3pnktuH2ZzN75fiW4RxnDEv86z9e/Qzny/Aq4J8kubq1dvX8l/LlJ3ePZHYpVarqtUmek+TRqnrDBt/Ty5K8O8mbW2tPzJ33C621fcOxfZn94mb5fSrJ9rnb6/8er0XF55Jsq6rnJ/8/B+d9OsnHW2s7hj1D395aExocyL7W2gWttR/JbP/Yw0leOnzt9Ln7PV5Vxw+rad8xHDsryVOtte/JbK/a/OVRa3P20ST/mOT1w7x8aZIrOn0vbCGttd3DnNoyT/CYnq06D1dtZeOAhidbV2Z2WdLtVfVnVXV2a+2adXe9Jcn5SW4fbt+W5Psze5K34crGUK4/nOTk4Vr685KcltnlAC+oqh9N8nettbdlFj2/V1VfzCwuzquqr8/sUqszM9vbcX1V3Z3kP5J8OMkpSU6tqmtba7+SL/8yvnp4NfAdrbW7huuib8/sl/qNrTWvEK6A1tq1VbWjqvZkthfnQ89wv1ZVO5N8pKr2Jbkns8sI589zxrCy0ZL8a5IN322NLe0tVfWTmc2XhzL7+fWBqvp8nr4idmmSj2cWtI8Mx/YkedfwM/G27McwZ8/PbM5WZnvf3p7ZKgoAS6hcng3A4RpeRPnm1tpFY48FgOnYcpdRAQAAm8PKBgAA0IWVDQAAoAuxAQAAdCE2AACALibx1reX/eL9No4smQvee2JtfK/lcvRpu8zDJfPEPbtXah6ag8tn1eZgYh4uI/OQKXimeWhlAwAA6EJsAAAAXYgNAACgC7EBAAB0ITYAAIAuxAYAANCF2AAAALoQGwAAQBdiAwAA6EJsAAAAXYgNAACgC7EBAAB0ITYAAIAuxAYAANCF2AAAALoQGwAAQBdiAwAA6EJsAAAAXYgNAACgC7EBAAB0ITYAAIAuxAYAANCF2AAAALoQGwAAQBdHjj2ARfjM31wz9hC+wikvOXvsIQBbzGN37h57CF/hmNN3jT0EAEZkZQMAAOhCbAAAAF2IDQAAoAuxAQAAdCE2AACALsQGAADQhdgAAAC6EBsAAEAXYgMAAOhCbAAAAF2IDQAAoAuxAQAAdCE2AACALsQGAADQhdgAAAC6EBsAAEAXYgMAAOhCbAAAAF2IDQAAoAux0cl9u24eewiQcy/cOfYQAIAtTGx0dN+um0UHozv3wp2iAwAYhdjYBKKDKRAdAMBmExubSHAwBYIDANgsYmOTWeVgCqxyAACbQWyMRHAwBYIDAOhJbIxIcDAFggMA6EVsAAAAXYiNkVndYAqsbgAAPYiNCbBpnCmwaRwAWDSxAQAAdCE2AACALsQGAADQhdiYEPs2mAL7NgCARREbAABAF0sdG3vPvCp7z7xq7GEslNWN5fPYnbvz2J27xx7GQlndAAAW4cixB/BszUfGce988lmf59ETty1iOGxR85FxOMFxwUfvXcRw2OKOOX3X2EMAgKdZuthY9ErGsffvFRwcskWvZFx2zsmCAwBYOUt1GVWvS6aOvX9vl/OymnpdMnXZOSd3OS8AwFiWJjZ6780QHByM3nszBAcAsEqWJjY2g+BgCgQHALAqJh8bm/2OU8fev3f06PCOVNOz2e84ddk5J48eHd6RCgA4XJOPja3opN3bxx4C5IqLLx97CADAkpt0bKzav6HBclq1f0MDAGCzTDo2AACA5TXZ2Bh7VWPsfRtMw9irGmPv2wAAOByTjQ0AAGC5TTI2xl7VWGN1Y2sbe1VjjdUNAGBZTTI2tjLvRMUUeCcqAGARxAYAANCF2AAAALoQGxPiEiqmwCVUAMCiiA0AAKALsQEAAHQhNibCJVRMgUuoAIBFEhsTIDSYAqEBACya2BiZ0GAKhAYA0IPYAAAAujhy7AHsz7br3pi9Z1419jDy6Inbup3bisb0HXP6rjx25+6xh5ELPnpvt3Nb0QAAeprsysa269446uMLDZJZcIxJaAAAy2yysbGqhAZTIDQAgM0w6dgYe3Vj0YTGchp7dWPRhAYAsFkmuWdj1YgMpkBkAACbbdIrG8k4qxuLesyTdm8XGitijNWNRT3mFRdfLjQAgFEsxcrGZr071XxkbBQJ9+26WUhsMZv17lTzkbFRJJx74U4hAQBM1uRXNtb0XuE41PMLja2p9wrHoZ5faAAAU7Y0sZH0C45V24hOX72CY9U2ogMALFVsJLMwWGQcCA2ejWNO37XQOBAaAMAqWrrYWHO4kbDoaGFrOtxIWHS0AABMyVJsEH8ma7FwKJvHBQaLthYLh7J5XGAAAFvBUsfGGgHBFAgIAICnW9rLqAAAgGkTGwAAQBdiAwAA6EJsAAAAXYgNAACgC7EBAAB0ITYAAIAuxAYAANCF2AAAALoQGwAAQBdiAwAA6EJsAAAAXYgNAACgi2qtjT0GAABgBVnZAAAAuhAbAABAF2IDAADoQmwAAABdiA0AAKALsQEAAHQhNgAAgC7EBgAA0IXYAAAAuhAbAABAF2IDAADoQmwAAABdiA0AAKALsQEAAHQhNgAAgC7EBgAA0IXYAAAAuhAbAABAF2IDAADoQmwAAABdiA0AAKALsQEAAHQhNgAAgC7+D2wr+y2UewoqAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x144 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x144 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x144 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x144 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load and display random samples\n",
    "image_ids = np.random.choice(dataset_train.image_ids, 4)\n",
    "for image_id in image_ids:\n",
    "    image = dataset_train.load_image(image_id)\n",
    "    mask, class_ids = dataset_train.load_mask(image_id)\n",
    "    visualize.display_top_masks(image, mask, class_ids, dataset_train.class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:2139: The name tf.nn.fused_batch_norm is deprecated. Please use tf.compat.v1.nn.fused_batch_norm instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:2239: The name tf.image.resize_nearest_neighbor is deprecated. Please use tf.compat.v1.image.resize_nearest_neighbor instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\tensorflow_core\\python\\ops\\array_ops.py:1475: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\model.py:554: The name tf.random_shuffle is deprecated. Please use tf.random.shuffle instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\utils.py:202: The name tf.log is deprecated. Please use tf.math.log instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\model.py:601: calling crop_and_resize_v1 (from tensorflow.python.ops.image_ops_impl) with box_ind is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "box_ind is deprecated, use box_indices instead\n",
      "Tensor(\"mrcnn_mask/Reshape_1:0\", shape=(?, 32, 28, 28, 4), dtype=float32) -> predicted_mask\n",
      "Tensor(\"mrcnn_mask_bdry_loss/Reshape:0\", shape=(?,), dtype=int32)\n",
      "Tensor(\"mrcnn_mask_bdry_loss/Reshape_6:0\", shape=(?,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Create model in training mode\n",
    "model = modellib.MaskRCNN(mode=\"training\", config=config,\n",
    "                          model_dir=MODEL_DIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dot: graph is too large for cairo-renderer bitmaps. Scaling by 0.814188 to fit\r\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Generate the plot\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.utils import plot_model\n",
    "import matplotlib.image as mpimg\n",
    "\n",
    "# change to keras model rather than maskrcnn model because maskrcnn is a custom class\n",
    "plot_model(model.keras_model, to_file = 'model_shape1.png',\n",
    "           show_shapes = True,\n",
    "           show_layer_names = True)\n",
    "# plot_model(model.keras_model, to_file='model_plot.png',show_shapes=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://github.com/fchollet/deep-learning-models/releases/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
      "94658560/94653016 [==============================] - 12s 0us/step\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:190: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:197: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:203: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:207: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:216: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:223: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Which weights to start with?\n",
    "init_with = \"coco\"  # imagenet, coco, or last\n",
    "\n",
    "if init_with == \"imagenet\":\n",
    "    model.load_weights(model.get_imagenet_weights(), by_name=True)\n",
    "elif init_with == \"coco\":\n",
    "    # Load weights trained on MS COCO, but skip layers that\n",
    "    # are different due to the different number of classes\n",
    "    # See README for instructions to download the COCO weights\n",
    "    model.load_weights(COCO_MODEL_PATH, by_name=True,\n",
    "                       exclude=[\"mrcnn_class_logits\", \"mrcnn_bbox_fc\", \n",
    "                                \"mrcnn_bbox\", \"mrcnn_mask\"])\n",
    "elif init_with == \"last\":\n",
    "    # Load the last model you trained and continue training\n",
    "    model.load_weights(model.find_last(), by_name=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "Train in two stages:\n",
    "1. Only the heads. Here we're freezing all the backbone layers and training only the randomly initialized layers (i.e. the ones that we didn't use pre-trained weights from MS COCO). To train only the head layers, pass `layers='heads'` to the `train()` function.\n",
    "\n",
    "2. Fine-tune all layers. For this simple example it's not necessary, but we're including it to show the process. Simply pass `layers=\"all` to train all layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:\\Users\\ROG\\Desktop\\FYP\\Mask_RCNN-Occulusion\\logs\\shapes20230407T1613\n",
      "\n",
      "Starting at epoch 0. LR=0.001\n",
      "\n",
      "Checkpoint Path: D:\\Users\\ROG\\Desktop\\FYP\\Mask_RCNN-Occulusion\\logs\\shapes20230407T1613\\mask_rcnn_shapes_{epoch:04d}.h5\n",
      "Selecting layers to train\n",
      "fpn_c5p5               (Conv2D)\n",
      "fpn_c4p4               (Conv2D)\n",
      "fpn_c3p3               (Conv2D)\n",
      "fpn_c2p2               (Conv2D)\n",
      "fpn_p5                 (Conv2D)\n",
      "fpn_p2                 (Conv2D)\n",
      "fpn_p3                 (Conv2D)\n",
      "fpn_p4                 (Conv2D)\n",
      "In model:  rpn_model\n",
      "    rpn_conv_shared        (Conv2D)\n",
      "    rpn_class_raw          (Conv2D)\n",
      "    rpn_bbox_pred          (Conv2D)\n",
      "mrcnn_mask_conv1       (TimeDistributed)\n",
      "mrcnn_mask_bn1         (TimeDistributed)\n",
      "mrcnn_mask_conv2       (TimeDistributed)\n",
      "mrcnn_mask_bn2         (TimeDistributed)\n",
      "mrcnn_mask_conv3       (TimeDistributed)\n",
      "mrcnn_mask_bn3         (TimeDistributed)\n",
      "mrcnn_mask_conv4       (TimeDistributed)\n",
      "mrcnn_mask_bn4         (TimeDistributed)\n",
      "mrcnn_mask_deconv      (TimeDistributed)\n",
      "mrcnn_mask             (TimeDistributed)\n",
      "mrcnn_bdry_conv1       (TimeDistributed)\n",
      "mrcnn_bdry_bn1         (TimeDistributed)\n",
      "mrcnn_bdry_conv2       (TimeDistributed)\n",
      "mrcnn_bdry_bn2         (TimeDistributed)\n",
      "mrcnn_bdry_conv3       (TimeDistributed)\n",
      "mrcnn_bdry_bn3         (TimeDistributed)\n",
      "mrcnn_class_conv1      (TimeDistributed)\n",
      "mrcnn_class_bn1        (TimeDistributed)\n",
      "mrcnn_bdry_conv4       (TimeDistributed)\n",
      "mrcnn_class_conv2      (TimeDistributed)\n",
      "mrcnn_bdry_bn4         (TimeDistributed)\n",
      "mrcnn_class_bn2        (TimeDistributed)\n",
      "mrcnn_bdry_conv5       (TimeDistributed)\n",
      "mrcnn_bdry_bn5         (TimeDistributed)\n",
      "mrcnn_bbox_fc          (TimeDistributed)\n",
      "mrcnn_class_logits     (TimeDistributed)\n",
      "WARNING:tensorflow:From D:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\keras\\optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'NCPUS'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-83fb3ae74319>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      6\u001b[0m             \u001b[0mlearning_rate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLEARNING_RATE\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m             \u001b[0mepochs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m             layers='heads')\n\u001b[0m",
      "\u001b[1;32mD:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\model.py\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(self, train_dataset, val_dataset, learning_rate, epochs, layers, augmentation, custom_callbacks, no_augmentation_sources, info)\u001b[0m\n\u001b[0;32m   2538\u001b[0m             \u001b[0mmax_queue_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2539\u001b[0m             \u001b[1;31m# workers=workers,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2540\u001b[1;33m             \u001b[0mworkers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0menviron\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"NCPUS\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;31m# Linux\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2541\u001b[0m             \u001b[1;31m# workers=1,  # Windows\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2542\u001b[0m             \u001b[0muse_multiprocessing\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;31m# True in Linux and False in windows\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Downloads\\anaconda3\\envs\\mrcnn\\lib\\os.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m    667\u001b[0m         \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    668\u001b[0m             \u001b[1;31m# raise KeyError with the original key value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 669\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    670\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdecodevalue\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    671\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'NCPUS'"
     ]
    }
   ],
   "source": [
    "# Train the head branches\n",
    "# Passing layers=\"heads\" freezes all layers except the head\n",
    "# layers. You can also pass a regular expression to select\n",
    "# which layers to train by name pattern.\n",
    "model.train(dataset_train, dataset_val, \n",
    "            learning_rate=config.LEARNING_RATE, \n",
    "            epochs=1, \n",
    "            layers='heads')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "print(device_lib.list_local_devices())\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.test.is_gpu_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Fine tune all layers\n",
    "# Passing layers=\"all\" trains all layers. You can also \n",
    "# pass a regular expression to select which layers to\n",
    "# train by name pattern.\n",
    "model.train(dataset_train, dataset_val, \n",
    "            learning_rate=config.LEARNING_RATE / 10,\n",
    "            epochs=2, \n",
    "            layers=\"all\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save weights\n",
    "# Typically not needed because callbacks save after every epoch\n",
    "# Uncomment to save manually\n",
    "# model_path = os.path.join(MODEL_DIR, \"mask_rcnn_shapes.h5\")\n",
    "# model.keras_model.save_weights(model_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Downloads\\Anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\model.py:721: The name tf.sets.set_intersection is deprecated. Please use tf.sets.intersection instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\Anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\model.py:723: The name tf.sparse_tensor_to_dense is deprecated. Please use tf.sparse.to_dense instead.\n",
      "\n",
      "WARNING:tensorflow:From D:\\Downloads\\Anaconda3\\envs\\mrcnn\\lib\\site-packages\\mask_rcnn-2.1-py3.6.egg\\mrcnn\\model.py:773: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.cast` instead.\n",
      "Loading weights from  D:\\Desktop\\FYP - Robust Surgical Tool Detection and Occlusion Handling using Deep Learning\\Mask_RCNN-Occulusion\\logs\\shapes20230108T1626\\mask_rcnn_shapes_0001.h5\n",
      "Re-starting from epoch 1\n"
     ]
    }
   ],
   "source": [
    "class InferenceConfig(ShapesConfig):\n",
    "    GPU_COUNT = 1\n",
    "    IMAGES_PER_GPU = 1\n",
    "\n",
    "inference_config = InferenceConfig()\n",
    "\n",
    "# Recreate the model in inference mode\n",
    "model = modellib.MaskRCNN(mode=\"inference\", \n",
    "                          config=inference_config,\n",
    "                          model_dir=MODEL_DIR)\n",
    "\n",
    "# Get path to saved weights\n",
    "# Either set a specific path or find last trained weights\n",
    "# model_path = os.path.join(ROOT_DIR, \".h5 file name here\")\n",
    "model_path = model.find_last()\n",
    "\n",
    "# Load trained weights\n",
    "print(\"Loading weights from \", model_path)\n",
    "model.load_weights(model_path, by_name=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original_image           shape: (128, 128, 3)         min:    8.00000  max:  230.00000  uint8\n",
      "image_meta               shape: (16,)                 min:    0.00000  max:  128.00000  int32\n",
      "gt_class_id              shape: (2,)                  min:    1.00000  max:    2.00000  int32\n",
      "gt_bbox                  shape: (2, 4)                min:   18.00000  max:  128.00000  int32\n",
      "gt_mask                  shape: (128, 128, 2)         min:    0.00000  max:    1.00000  bool\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test on a random image\n",
    "image_id = random.choice(dataset_val.image_ids)\n",
    "original_image, image_meta, gt_class_id, gt_bbox, gt_mask =\\\n",
    "    modellib.load_image_gt(dataset_val, inference_config, \n",
    "                           image_id, use_mini_mask=False)\n",
    "\n",
    "log(\"original_image\", original_image)\n",
    "log(\"image_meta\", image_meta)\n",
    "log(\"gt_class_id\", gt_class_id)\n",
    "log(\"gt_bbox\", gt_bbox)\n",
    "log(\"gt_mask\", gt_mask)\n",
    "\n",
    "visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id, \n",
    "                            dataset_train.class_names, figsize=(8, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 1 images\n",
      "image                    shape: (128, 128, 3)         min:    8.00000  max:  230.00000  uint8\n",
      "molded_images            shape: (1, 128, 128, 3)      min:  -95.90000  max:  106.30000  float64\n",
      "image_metas              shape: (1, 16)               min:    0.00000  max:  128.00000  int32\n",
      "anchors                  shape: (1, 4092, 4)          min:   -0.71267  max:    1.20874  float32\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "results = model.detect([original_image], verbose=1)\n",
    "\n",
    "r = results[0]\n",
    "visualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'], \n",
    "                            dataset_val.class_names, r['scores'], ax=get_ax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mAP:  0.7250000059604644\n"
     ]
    }
   ],
   "source": [
    "# Compute VOC-Style mAP @ IoU=0.5\n",
    "# Running on 10 images. Increase for better accuracy.\n",
    "image_ids = np.random.choice(dataset_val.image_ids, 10)\n",
    "APs = []\n",
    "for image_id in image_ids:\n",
    "    # Load image and ground truth data\n",
    "    image, image_meta, gt_class_id, gt_bbox, gt_mask =\\\n",
    "        modellib.load_image_gt(dataset_val, inference_config,\n",
    "                               image_id, use_mini_mask=False)\n",
    "    molded_images = np.expand_dims(modellib.mold_image(image, inference_config), 0)\n",
    "    # Run object detection\n",
    "    results = model.detect([image], verbose=0)\n",
    "    r = results[0]\n",
    "    # Compute AP\n",
    "    AP, precisions, recalls, overlaps =\\\n",
    "        utils.compute_ap(gt_bbox, gt_class_id, gt_mask,\n",
    "                         r[\"rois\"], r[\"class_ids\"], r[\"scores\"], r['masks'])\n",
    "    APs.append(AP)\n",
    "    \n",
    "print(\"mAP: \", np.mean(APs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}