2_line_word_segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing\n",
    "import os\n",
    "import random\n",
    "import time\n",
    "\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "import mxnet as mx\n",
    "from mxnet import nd, autograd, gluon\n",
    "from mxnet.image import resize_short\n",
    "from mxboard import SummaryWriter\n",
    "from mxnet.gluon.model_zoo.vision import resnet34_v1\n",
    "from mxnet.contrib.ndarray import MultiBoxPrior, MultiBoxTarget, MultiBoxDetection, box_nms\n",
    "import numpy as np\n",
    "from skimage.draw import line_aa\n",
    "from skimage import transform as skimage_tf\n",
    "\n",
    "np.seterr(all='raise')\n",
    "\n",
    "mx.random.seed(42)\n",
    "\n",
    "from ocr.utils.iam_dataset import IAMDataset\n",
    "from ocr.utils.draw_box_on_image import draw_boxes_on_image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Line / Word segmentation\n",
    "This notebook demonstates a deep convolutional network method to provide bounding boxes surrounding handwritten texts.\n",
    "\n",
    "Input: An image containing handwritten text\n",
    "Output: A list of bounding boxes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network definition\n",
    "We utilised an SSD network with horizonal anchor boxes to identify each line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SSD(gluon.Block):\n",
    "    def __init__(self, num_classes, ctx, **kwargs):\n",
    "        super(SSD, self).__init__(**kwargs)\n",
    "\n",
    "        # Seven sets of anchor boxes are defined. For each set, n=2 sizes and m=3 ratios are defined.\n",
    "        # Four anchor boxes (n + m - 1) are generated: 2 square anchor boxes based on the n=2 sizes and 2 rectanges based on\n",
    "        # the sizes and the ratios. See https://discuss.mxnet.io/t/question-regarding-ssd-algorithm/1307 for more information.\n",
    "        \n",
    "        #self.anchor_sizes = [[.1, .2], [.2, .3], [.2, .4], [.4, .6], [.5, .7], [.6, .8], [.7, .9]]\n",
    "        #self.anchor_ratios = [[1, 3, 5], [1, 3, 5], [1, 6, 8], [1, 5, 7], [1, 6, 8], [1, 7, 9], [1, 7, 10]]\n",
    "\n",
    "        self.anchor_sizes = [[.1, .2], [.2, .3], [.2, .4], [.3, .4], [.3, .5], [.4, .6]]\n",
    "        self.anchor_ratios = [[1, 3, 5], [1, 3, 5], [1, 6, 8], [1, 4, 7], [1, 6, 8], [1, 5, 7]]\n",
    "\n",
    "        self.num_anchors = len(self.anchor_sizes)\n",
    "        self.num_classes = num_classes\n",
    "        self.ctx = ctx\n",
    "        with self.name_scope():\n",
    "            self.body, self.downsamples, self.class_preds, self.box_preds = self.get_ssd_model()\n",
    "            self.downsamples.initialize(mx.init.Normal(), ctx=self.ctx)\n",
    "            self.class_preds.initialize(mx.init.Normal(), ctx=self.ctx)\n",
    "            self.box_preds.initialize(mx.init.Normal(), ctx=self.ctx)\n",
    "\n",
    "    def get_body(self):\n",
    "        '''\n",
    "        Create the feature extraction network of the SSD based on resnet34.\n",
    "        The first layer of the res-net is converted into grayscale by averaging the weights of the 3 channels\n",
    "        of the original resnet.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        network: gluon.nn.HybridSequential\n",
    "            The body network for feature extraction based on resnet\n",
    "        \n",
    "        '''\n",
    "        pretrained = resnet34_v1(pretrained=True, ctx=self.ctx)\n",
    "        pretrained_2 = resnet34_v1(pretrained=True, ctx=mx.cpu(0))\n",
    "        first_weights = pretrained_2.features[0].weight.data().mean(axis=1).expand_dims(axis=1)\n",
    "        # First weights could be replaced with individual channels.\n",
    "        \n",
    "        body = gluon.nn.HybridSequential()\n",
    "        with body.name_scope():\n",
    "            first_layer = gluon.nn.Conv2D(channels=64, kernel_size=(7, 7), padding=(3, 3), strides=(2, 2), in_channels=1, use_bias=False)\n",
    "            first_layer.initialize(mx.init.Normal(), ctx=self.ctx)\n",
    "            first_layer.weight.set_data(first_weights)\n",
    "            body.add(first_layer)\n",
    "            body.add(*pretrained.features[1:-3])\n",
    "        return body\n",
    "\n",
    "    def get_class_predictor(self, num_anchors_predicted):\n",
    "        '''\n",
    "        Creates the category prediction network (takes input from each downsampled feature)\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        \n",
    "        num_anchors_predicted: int\n",
    "            Given n sizes and m ratios, the number of boxes predicted is n+m-1.\n",
    "            e.g., sizes=[.1, .2], ratios=[1, 3, 5] the number of anchors predicted is 4.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "\n",
    "        network: gluon.nn.HybridSequential\n",
    "            The class predictor network\n",
    "        '''\n",
    "        return gluon.nn.Conv2D(num_anchors_predicted*(self.num_classes + 1), kernel_size=3, padding=1)\n",
    "\n",
    "    def get_box_predictor(self, num_anchors_predicted):\n",
    "        '''\n",
    "        Creates the bounding box prediction network (takes input from each downsampled feature)\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        \n",
    "        num_anchors_predicted: int\n",
    "            Given n sizes and m ratios, the number of boxes predicted is n+m-1.\n",
    "            e.g., sizes=[.1, .2], ratios=[1, 3, 5] the number of anchors predicted is 4.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "\n",
    "        pred: gluon.nn.HybridSequential\n",
    "            The box predictor network\n",
    "        '''\n",
    "        pred = gluon.nn.HybridSequential()\n",
    "        with pred.name_scope():\n",
    "            pred.add(gluon.nn.Conv2D(channels=num_anchors_predicted*4, kernel_size=3, padding=1))\n",
    "        return pred\n",
    "\n",
    "    def get_down_sampler(self, num_filters):\n",
    "        '''\n",
    "        Creates a two-stacked Conv-BatchNorm-Relu and then a pooling layer to\n",
    "        downsample the image features by half.\n",
    "        '''\n",
    "        out = gluon.nn.HybridSequential()\n",
    "        for _ in range(2):\n",
    "            out.add(gluon.nn.Conv2D(num_filters, 3, strides=1, padding=1))\n",
    "            out.add(gluon.nn.BatchNorm(in_channels=num_filters))\n",
    "            out.add(gluon.nn.Activation('relu'))\n",
    "        out.add(gluon.nn.MaxPool2D(2))\n",
    "        out.hybridize()\n",
    "        return out\n",
    "\n",
    "    def get_ssd_model(self):\n",
    "        '''\n",
    "        Creates the SSD model that includes the image feature, downsample, category\n",
    "        and bounding boxes prediction networks.\n",
    "        '''\n",
    "        body = self.get_body()\n",
    "        downsamples = gluon.nn.HybridSequential()\n",
    "        class_preds = gluon.nn.HybridSequential()\n",
    "        box_preds = gluon.nn.HybridSequential()\n",
    "\n",
    "        downsamples.add(self.get_down_sampler(32))\n",
    "        downsamples.add(self.get_down_sampler(32))\n",
    "        downsamples.add(self.get_down_sampler(32))\n",
    "\n",
    "        for scale in range(self.num_anchors):\n",
    "            num_anchors_predicted = len(self.anchor_sizes[0]) + len(self.anchor_ratios[0]) - 1\n",
    "            class_preds.add(self.get_class_predictor(num_anchors_predicted))\n",
    "            box_preds.add(self.get_box_predictor(num_anchors_predicted))\n",
    "\n",
    "        return body, downsamples, class_preds, box_preds\n",
    "\n",
    "    def ssd_forward(self, x):\n",
    "        '''\n",
    "        Helper function of the forward pass of the sdd\n",
    "        '''\n",
    "        x = self.body(x)\n",
    "\n",
    "        default_anchors = []\n",
    "        predicted_boxes = []\n",
    "        predicted_classes = []\n",
    "\n",
    "        for i in range(self.num_anchors):\n",
    "            default_anchors.append(MultiBoxPrior(x, sizes=self.anchor_sizes[i], ratios=self.anchor_ratios[i]))\n",
    "            predicted_boxes.append(self._flatten_prediction(self.box_preds[i](x)))\n",
    "            predicted_classes.append(self._flatten_prediction(self.class_preds[i](x)))\n",
    "            if i < len(self.downsamples):\n",
    "                x = self.downsamples[i](x)\n",
    "            elif i == 3:\n",
    "                x = nd.Pooling(x, global_pool=True, pool_type='max', kernel=(4, 4))\n",
    "        return default_anchors, predicted_classes, predicted_boxes\n",
    "\n",
    "    def forward(self, x):\n",
    "        default_anchors, predicted_classes, predicted_boxes = self.ssd_forward(x)\n",
    "        # we want to concatenate anchors, class predictions, box predictions from different layers\n",
    "        anchors = nd.concat(*default_anchors, dim=1)\n",
    "        box_preds = nd.concat(*predicted_boxes, dim=1)\n",
    "        class_preds = nd.concat(*predicted_classes, dim=1)\n",
    "        class_preds = nd.reshape(class_preds, shape=(0, -1, self.num_classes + 1))\n",
    "        return anchors, class_preds, box_preds\n",
    "\n",
    "    def _flatten_prediction(self, pred):\n",
    "        '''\n",
    "        Helper function to flatten the predicted bounding boxes and categories\n",
    "        '''\n",
    "        return nd.flatten(nd.transpose(pred, axes=(0, 2, 3, 1)))\n",
    "\n",
    "    def training_targets(self, default_anchors, class_predicts, labels):\n",
    "        '''\n",
    "        Helper function to obtain the bounding boxes from the anchors.\n",
    "        '''\n",
    "        class_predicts = nd.transpose(class_predicts, axes=(0, 2, 1))\n",
    "        box_target, box_mask, cls_target = MultiBoxTarget(default_anchors, labels, class_predicts)\n",
    "        return box_target, box_mask, cls_target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss function\n",
    "The SSD was trained to minimize the classification error (box is text/box is not text) and the smoothed L1 loss between the predicted and actual bounding box. The smooth L1 loss is defined below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SmoothL1Loss(gluon.loss.Loss):\n",
    "    '''\n",
    "    A SmoothL1loss function defined in https://gluon.mxnet.io/chapter08_computer-vision/object-detection.html\n",
    "    '''\n",
    "    def __init__(self, batch_axis=0, **kwargs):\n",
    "        super(SmoothL1Loss, self).__init__(None, batch_axis, **kwargs)\n",
    "\n",
    "    def hybrid_forward(self, F, output, label, mask):\n",
    "        loss = F.smooth_l1((output - label) * mask, scalar=1.0)\n",
    "        return F.mean(loss, self._batch_axis, exclude=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data transform and augmentation\n",
    "\n",
    "The data is transformed so that the images and labels could be fed into the network. The training data is augmented so that the images are randomly translated and lines are randomly removed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def augment_transform(image, label):\n",
    "    '''\n",
    "    1) Function that randomly translates the input image by +-width_range and +-height_range.\n",
    "    The labels (bounding boxes) are also translated by the same amount.\n",
    "    2) Each line can also be randomly removed for augmentation. Labels are also reduced to correspond to this\n",
    "    data and label are converted into tensors by calling the \"transform\" function.\n",
    "    '''\n",
    "    ty = random.uniform(-random_y_translation, random_y_translation)\n",
    "    tx = random.uniform(-random_x_translation, random_x_translation)\n",
    "\n",
    "    st = skimage_tf.SimilarityTransform(translation=(tx*image.shape[1], ty*image.shape[0]))\n",
    "    image = skimage_tf.warp(image, st, cval=1.0)\n",
    "\n",
    "    label[:, 0] = label[:, 0] - tx/2 #NOTE: Check why it has to be halfed (found experimentally)\n",
    "    label[:, 1] = label[:, 1] - ty/2\n",
    "    \n",
    "    index = np.random.uniform(0, 1.0, size=label.shape[0]) > random_remove_box\n",
    "    for i, should_output_bb in enumerate(index):\n",
    "        if should_output_bb == False:\n",
    "            (x, y, w, h) = label[i]\n",
    "            (x1, y1, x2, y2) = (x, y, x + w, y + h)\n",
    "            (x1, y1, x2, y2) = (x1 * image.shape[1], y1 * image.shape[0],\n",
    "                                x2 * image.shape[1], y2 * image.shape[0])\n",
    "            (x1, y1, x2, y2) = (int(x1), int(y1), int(x2), int(y2))\n",
    "            x1 = 0 if x1 < 0 else x1\n",
    "            y1 = 0 if y1 < 0 else y1\n",
    "            x2 = 0 if x2 < 0 else x2\n",
    "            y2 = 0 if y2 < 0 else y2\n",
    "            image_h, image_w = image.shape\n",
    "            x1 = image_w-1 if x1 >= image_w else x1\n",
    "            y1 = image_h-1 if y1 >= image_h else y1\n",
    "            x2 = image_w-1 if x2 >= image_w else x2\n",
    "            y2 = image_h-1 if y2 >= image_h else y2\n",
    "            image[y1:y2, x1:x2] = image[y1, x1]\n",
    "    \n",
    "    augmented_labels = label[index, :]\n",
    "    return transform(image*255., augmented_labels)\n",
    "\n",
    "def transform(image, label):\n",
    "    '''\n",
    "    Function that converts resizes image into the input image tensor for a CNN.\n",
    "    The labels (bounding boxes) are expanded, converted into (x, y, x+w, y+h), and\n",
    "    zero padded to the maximum number of labels. Finally, it is converted into a float\n",
    "    tensor.\n",
    "    '''\n",
    "    max_label_n = 128 if detection_box == \"word\" else 13\n",
    "\n",
    "    # Resize the image\n",
    "    image = np.expand_dims(image, axis=2)\n",
    "    image = mx.nd.array(image)\n",
    "    image = resize_short(image, image_size)\n",
    "    image = image.transpose([2, 0, 1])/255.\n",
    "\n",
    "    # Expand the bounding box by expand_bb_scale\n",
    "    bb = label.copy()\n",
    "    new_w = (1 + expand_bb_scale) * bb[:, 2]\n",
    "    new_h = (1 + expand_bb_scale) * bb[:, 3]\n",
    "    \n",
    "    bb[:, 0] = bb[:, 0] - (new_w - bb[:, 2])/2\n",
    "    bb[:, 1] = bb[:, 1] - (new_h - bb[:, 3])/2\n",
    "    bb[:, 2] = new_w\n",
    "    bb[:, 3] = new_h\n",
    "    label = bb \n",
    "\n",
    "    # Convert the predicted bounding box from (x, y, w, h to (x, y, x + w, y + h)\n",
    "    label = label.astype(np.float32)\n",
    "    label[:, 2] = label[:, 0] + label[:, 2]\n",
    "    label[:, 3] = label[:, 1] + label[:, 3]\n",
    "\n",
    "    # Zero pad the data\n",
    "    label_n = label.shape[0]\n",
    "    label_padded = np.zeros(shape=(max_label_n, 5))\n",
    "    label_padded[:label_n, 1:] = label\n",
    "    label_padded[:label_n, 0] = np.ones(shape=(1, label_n))\n",
    "    label_padded = mx.nd.array(label_padded)\n",
    "    return image, label_padded\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper function to generate output images for MXBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_output_image(box_predictions, default_anchors, cls_probs, box_target, box_mask, cls_target, x, y):\n",
    "    '''\n",
    "    Generate the image with the predicted and actual bounding boxes.\n",
    "    Parameters\n",
    "    ----------\n",
    "    box_predictions: nd.array\n",
    "        Bounding box predictions relative to the anchor boxes, output of the network\n",
    "\n",
    "    default_anchors: nd.array\n",
    "        Anchors used, output of the network\n",
    "    \n",
    "    cls_probs: nd.array\n",
    "        Output of nd.SoftmaxActivation(nd.transpose(class_predictions, (0, 2, 1)), mode='channel')\n",
    "        where class_predictions is the output of the network.\n",
    "\n",
    "    box_target: nd.array\n",
    "        Output classification probabilities from network.training_targets(default_anchors, class_predictions, y)\n",
    "\n",
    "    box_mask: nd.array\n",
    "        Output bounding box predictions from network.training_targets(default_anchors, class_predictions, y) \n",
    "\n",
    "    cls_target: nd.array\n",
    "        Output targets from network.training_targets(default_anchors, class_predictions, y)\n",
    "    \n",
    "    x: nd.array\n",
    "       The input images\n",
    "\n",
    "    y: nd.array\n",
    "        The actual labels\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    output_image: np.array\n",
    "        The images with the predicted and actual bounding boxes drawn on\n",
    "\n",
    "    number_of_bbs: int\n",
    "        The number of predicting bounding boxes\n",
    "    '''\n",
    "    output = MultiBoxDetection(*[cls_probs, box_predictions, default_anchors], force_suppress=True, clip=False)\n",
    "    output = box_nms(output, overlap_thresh=overlap_thres, valid_thresh=min_c, topk=topk)\n",
    "    output = output.asnumpy()\n",
    "\n",
    "    number_of_bbs = 0\n",
    "    predicted_bb = []\n",
    "    for b in range(output.shape[0]):\n",
    "        predicted_bb_ = output[b, output[b, :, 0] != -1]\n",
    "        predicted_bb_ = predicted_bb_[:, 2:]\n",
    "        number_of_bbs += predicted_bb_.shape[0]\n",
    "        predicted_bb_[:, 2] = predicted_bb_[:, 2] - predicted_bb_[:, 0]\n",
    "        predicted_bb_[:, 3] = predicted_bb_[:, 3] - predicted_bb_[:, 1]\n",
    "        predicted_bb.append(predicted_bb_)\n",
    "        \n",
    "    labels = y[:, :, 1:].asnumpy()\n",
    "    labels[:, :, 2] = labels[:, :, 2] - labels[:, :, 0]\n",
    "    labels[:, :, 3] = labels[:, :, 3] - labels[:, :, 1]\n",
    "\n",
    "    output_image = draw_boxes_on_image(predicted_bb, labels, x.asnumpy())\n",
    "    output_image[output_image<0] = 0\n",
    "    output_image[output_image>1] = 1\n",
    "\n",
    "    return output_image, number_of_bbs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_epoch(e, network, dataloader, trainer, log_dir, print_name, is_train, update_metric):\n",
    "    '''\n",
    "    Run one epoch to train or test the SSD network\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "        \n",
    "    e: int\n",
    "        The epoch number\n",
    "\n",
    "    network: nn.Gluon.HybridSequential\n",
    "        The SSD network\n",
    "\n",
    "    dataloader: gluon.data.DataLoader\n",
    "        The train or testing dataloader that is wrapped around the iam_dataset\n",
    "    \n",
    "    log_dir: Str\n",
    "        The directory to store the log files for mxboard\n",
    "\n",
    "    print_name: Str\n",
    "        Name to print for associating with the data. usually this will be \"train\" and \"test\"\n",
    "    \n",
    "    is_train: bool\n",
    "        Boolean to indicate whether or not the CNN should be updated. is_train should only be set to true for the training data\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "\n",
    "    network: gluon.nn.HybridSequential\n",
    "        The class predictor network\n",
    "    '''\n",
    "\n",
    "    total_losses = [0 for ctx_i in ctx]\n",
    "    for i, (X, Y) in enumerate(dataloader):\n",
    "        X = gluon.utils.split_and_load(X, ctx)\n",
    "        Y = gluon.utils.split_and_load(Y, ctx)\n",
    "        \n",
    "        with autograd.record(train_mode=is_train):\n",
    "            losses = []\n",
    "            for x, y in zip(X, Y):\n",
    "                default_anchors, class_predictions, box_predictions = network(x)\n",
    "                box_target, box_mask, cls_target = network.training_targets(default_anchors, class_predictions, y)\n",
    "                # losses\n",
    "                loss_class = cls_loss(class_predictions, cls_target)\n",
    "                loss_box = box_loss(box_predictions, box_target, box_mask)\n",
    "                # sum all losses\n",
    "                loss = loss_class + loss_box\n",
    "                losses.append(loss)\n",
    "            \n",
    "        if is_train:\n",
    "            for loss in losses:\n",
    "                loss.backward()\n",
    "            step_size = 0\n",
    "            for x in X:\n",
    "                step_size += x.shape[0]\n",
    "            trainer.step(step_size)\n",
    "\n",
    "        for index, loss in enumerate(losses):\n",
    "            total_losses[index] += loss.mean().asscalar()\n",
    "            \n",
    "        if update_metric:\n",
    "            cls_metric.update([cls_target], [nd.transpose(class_predictions, (0, 2, 1))])\n",
    "            box_metric.update([box_target], [box_predictions * box_mask])\n",
    "            \n",
    "        if i == 0 and e % send_image_every_n == 0 and e > 0:\n",
    "            cls_probs = nd.SoftmaxActivation(nd.transpose(class_predictions, (0, 2, 1)), mode='channel')\n",
    "            output_image, number_of_bbs = generate_output_image(box_predictions, default_anchors,\n",
    "                                                                cls_probs, box_target, box_mask,\n",
    "                                                                cls_target, x, y)\n",
    "            print(\"Number of predicted {} BBs = {}\".format(print_name, number_of_bbs))\n",
    "            with SummaryWriter(logdir=log_dir, verbose=False, flush_secs=5) as sw:\n",
    "                sw.add_image('bb_{}_image'.format(print_name), output_image, global_step=e)\n",
    "        \n",
    "\n",
    "    total_loss = 0\n",
    "    for loss in total_losses:\n",
    "        total_loss += loss / (len(dataloader)*len(total_losses))\n",
    "\n",
    "    with SummaryWriter(logdir=log_dir, verbose=False, flush_secs=5) as sw:\n",
    "        if update_metric:\n",
    "            name1, val1 = cls_metric.get()\n",
    "            name2, val2 = box_metric.get()\n",
    "            sw.add_scalar(name1, {\"test\": val1}, global_step=e)\n",
    "            sw.add_scalar(name2, {\"test\": val2}, global_step=e)\n",
    "        sw.add_scalar('loss', {print_name: total_loss}, global_step=e)\n",
    "            \n",
    "    return total_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define default parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "detection_box = \"word\" #\"word\" or \"line\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "gpu_count = 4\n",
    "expand_bb_scale = 0.05\n",
    "min_c = 0.01\n",
    "overlap_thres = 0.1 if detection_box == \"line\" else 0.001\n",
    "topk = 150 if detection_box == \"line\" else 200\n",
    "\n",
    "epochs = 20\n",
    "learning_rate = 0.00005\n",
    "batch_size = 32\n",
    "image_size = 350\n",
    "\n",
    "random_x_translation, random_y_translation = (0.03, 0.03) if detection_box == \"line\" else (0.005, 0.005)\n",
    "random_remove_box = 0.1\n",
    "\n",
    "\n",
    "log_dir = \"./logs/line_word_segmentation\"\n",
    "checkpoint_dir, checkpoint_name = \"model_checkpoint\", \"ssd_\"+detection_box+\".params\"\n",
    "\n",
    "print_every_n = 5\n",
    "send_image_every_n = 20\n",
    "save_every_n = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training samples: 967\n",
      "Number of testing samples: 232\n"
     ]
    }
   ],
   "source": [
    "ctx = [mx.gpu(i) for i in range(gpu_count)]\n",
    "\n",
    "train_ds = IAMDataset(\"form_bb\", output_data=\"bb\", output_parse_method=detection_box, train=True)\n",
    "print(\"Number of training samples: {}\".format(len(train_ds)))\n",
    "\n",
    "test_ds = IAMDataset(\"form_bb\", output_data=\"bb\", output_parse_method=detection_box, train=False)\n",
    "print(\"Number of testing samples: {}\".format(len(test_ds)))\n",
    "\n",
    "train_data = gluon.data.DataLoader(train_ds.transform(augment_transform), batch_size, shuffle=True, last_batch=\"rollover\", num_workers=8)\n",
    "test_data = gluon.data.DataLoader(test_ds.transform(transform), batch_size, shuffle=False, last_batch=\"keep\", num_workers=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = SSD(num_classes=2, ctx=ctx)\n",
    "net.hybridize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "cls_loss = gluon.loss.SoftmaxCrossEntropyLoss()\n",
    "box_loss = SmoothL1Loss()\n",
    "cls_loss.hybridize()\n",
    "box_loss.hybridize()\n",
    "\n",
    "best_test_loss = 10e5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters loaded\n"
     ]
    }
   ],
   "source": [
    "if os.path.isfile(os.path.join(checkpoint_dir, checkpoint_name)):\n",
    "    net.load_parameters(os.path.join(checkpoint_dir, checkpoint_name), ctx=ctx)\n",
    "    print(\"Parameters loaded\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0, train_loss 0.023123, test_loss 0.033317, test accuracy=0.990993, mae=0.009293\n",
      "Saving network, previous best test loss 0.033303, current test loss 0.033284\n",
      "Saving network, previous best test loss 0.033284, current test loss 0.033277\n",
      "Epoch 5, train_loss 0.022678, test_loss 0.033480, test accuracy=0.991008, mae=0.009325\n",
      "Epoch 10, train_loss 0.021695, test_loss 0.033569, test accuracy=0.990982, mae=0.009336\n",
      "Epoch 15, train_loss 0.021458, test_loss 0.033605, test accuracy=0.991015, mae=0.009293\n"
     ]
    }
   ],
   "source": [
    "trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': learning_rate})\n",
    "for e in range(epochs):\n",
    "    cls_metric = mx.metric.Accuracy()\n",
    "    box_metric = mx.metric.MAE()\n",
    "    train_loss = run_epoch(e, net, train_data, trainer, log_dir, print_name=\"train\", is_train=True, update_metric=False)\n",
    "    test_loss = run_epoch(e, net, test_data, trainer, log_dir, print_name=\"test\", is_train=False, update_metric=True)    \n",
    "    if test_loss < best_test_loss:\n",
    "        print(\"Saving network, previous best test loss {:.6f}, current test loss {:.6f}\".format(best_test_loss, test_loss))\n",
    "        net.save_parameters(os.path.join(checkpoint_dir, checkpoint_name))\n",
    "        best_test_loss = test_loss\n",
    "        \n",
    "    if e % print_every_n == 0:\n",
    "        name1, val1 = cls_metric.get()\n",
    "        name2, val2 = box_metric.get()\n",
    "        print(\"Epoch {0}, train_loss {1:.6f}, test_loss {2:.6f}, test {3}={4:.6f}, {5}={6:.6f}\".format(e, train_loss, test_loss, name1, val1, name2, val2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.isfile(os.path.join(checkpoint_dir, checkpoint_name)):\n",
    "    net.load_parameters(os.path.join(checkpoint_dir, checkpoint_name), ctx=ctx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Helper function to predict the bounding box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_bounding_boxes(net, image, bb):\n",
    "    '''\n",
    "    Given the outputs of the dataset (image and bounding box) and the network, \n",
    "    the predicted bounding boxes are provided.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    net: SSD\n",
    "    The trained SSD network.\n",
    "    \n",
    "    image: np.array\n",
    "    A grayscale image of the handwriting passages.\n",
    "    \n",
    "    bb: [(x1, y1, x2, y2)]\n",
    "    A tuple that contains the bounding box.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    predicted_bb: [(x, y, w, h)]\n",
    "    The predicted bounding boxes.\n",
    "    \n",
    "    actual_bb: [(x, y, w, h)]\n",
    "    The actual bounding bounding boxes.\n",
    "    '''\n",
    "    image, bb = transform(image, bb)\n",
    "\n",
    "    image = image.as_in_context(ctx[0])\n",
    "    image = image.expand_dims(axis=0)\n",
    "\n",
    "    bb = bb.as_in_context(ctx[0])\n",
    "    bb = bb.expand_dims(axis=0)\n",
    "\n",
    "    default_anchors, class_predictions, box_predictions = net(image)\n",
    "    box_target, box_mask, cls_target = net.training_targets(default_anchors, class_predictions, bb)\n",
    "    cls_probs = nd.SoftmaxActivation(nd.transpose(class_predictions, (0, 2, 1)), mode='channel')\n",
    "\n",
    "    predicted_bb = MultiBoxDetection(*[cls_probs, box_predictions, default_anchors], force_suppress=True, clip=False)\n",
    "    predicted_bb = box_nms(predicted_bb, overlap_thresh=overlap_thres, valid_thresh=min_c, topk=topk)\n",
    "    predicted_bb = predicted_bb.asnumpy()\n",
    "    predicted_bb = predicted_bb[0, predicted_bb[0, :, 0] != -1]\n",
    "    predicted_bb = predicted_bb[:, 2:]\n",
    "    predicted_bb[:, 2] = predicted_bb[:, 2] - predicted_bb[:, 0]\n",
    "    predicted_bb[:, 3] = predicted_bb[:, 3] - predicted_bb[:, 1]\n",
    "\n",
    "    labeled_bb = bb[:, :, 1:].asnumpy()\n",
    "    labeled_bb[:, :, 2] = labeled_bb[:, :, 2] - labeled_bb[:, :, 0]\n",
    "    labeled_bb[:, :, 3] = labeled_bb[:, :, 3] - labeled_bb[:, :, 1]\n",
    "    labeled_bb = labeled_bb[0]\n",
    "    return predicted_bb, labeled_bb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quantitative analysis\n",
    "The mean IOU was calculated for the train and test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_iou(box1, box2):\n",
    "    '''\n",
    "    Calculate the IOU between two bounding boxes (x, y, w, h)\n",
    "    '''\n",
    "    # source: https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/\n",
    "    x1 = max(box1[0], box2[0])\n",
    "    y1 = max(box1[1], box2[1])\n",
    "    x2 = min(box1[2], box2[2])\n",
    "    y2 = min(box1[3], box2[3])\n",
    "\n",
    "    inter_area = max(0, x2 - x1 + 1) * max(0, y2 - y1 + 1)\n",
    "\n",
    "    box1_area = (box1[2] - box1[0] + 1) * (box1[3] - box1[1] + 1)\n",
    "    box2_area = (box2[2] - box2[0] + 1) * (box2[3] - box2[1] + 1)\n",
    "\n",
    "    iou = inter_area / float(box1_area + box2_area - inter_area)\n",
    "    return iou\n",
    "\n",
    "def calculate_iou(dataset):\n",
    "    '''\n",
    "    Iterate through the dataset and calculate the mean IOU between the actual and \n",
    "    predicted bounding boxes.\n",
    "    '''\n",
    "    ious = []\n",
    "    for i in range(len(dataset)):\n",
    "        iou_i = 0.0\n",
    "        count_i = 0\n",
    "        image, bb = dataset[i]\n",
    "        predicted_bb, actual_bb = predict_bounding_boxes(net, image, bb)\n",
    "        # A naive 1-1 bouding box matching algorithm was used. This algorithm\n",
    "        # doesn't account for insertions or deletes and may result in lower IOU values.\n",
    "        for predicted_bb_i, actual_bb_i in zip(predicted_bb, actual_bb):\n",
    "            iou = get_iou(predicted_bb_i, actual_bb_i)\n",
    "            iou_i += iou\n",
    "            count_i += 1\n",
    "        ious.append(iou_i/count_i)\n",
    "    return np.mean(ious)\n",
    "        \n",
    "train_iou = calculate_iou(train_ds)\n",
    "test_iou = calculate_iou(test_ds)\n",
    "print(\"Train iou {} test iou {}\".format(train_iou, test_iou))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Qualitative analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualise the predicted and actual bounding boxes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1440 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figs_to_plot = 2\n",
    "fig, axs = plt.subplots(figs_to_plot, 2, figsize=(15, 10 * figs_to_plot))\n",
    "ds = test_ds\n",
    "for i in range(figs_to_plot):\n",
    "    n = int(random.random()*len(ds))\n",
    "    image, bb = ds[n]\n",
    "    predicted_bb, actual_bb = predict_bounding_boxes(net, image, bb)\n",
    "    \n",
    "    for j in range(actual_bb.shape[0]):\n",
    "        (x, y, w, h) = actual_bb[j]\n",
    "        axs[i][0].imshow(image, cmap='Greys_r')\n",
    "        image_h, image_w = image.shape[-2:]\n",
    "        (x, y, w, h) = (x * image_w, y * image_h, w * image_w, h * image_h)\n",
    "        rect = patches.Rectangle((x, y), w, h, fill=False, color=\"r\")\n",
    "        axs[i][0].add_patch(rect)\n",
    "        axs[i][0].set_title(\"BB actual\")\n",
    "\n",
    "    for j in range(predicted_bb.shape[0]):\n",
    "        axs[i][1].imshow(image, cmap='Greys_r')\n",
    "        (x, y, w, h) = predicted_bb[j]\n",
    "        image_h, image_w = image.shape[-2:]\n",
    "        (x, y, w, h) = (x * image_w, y * image_h, w * image_w, h * image_h)\n",
    "        rect = patches.Rectangle((x, y), w, h, fill=False, color=\"r\")\n",
    "        axs[i][1].add_patch(rect)\n",
    "        axs[i][1].set_title(\"BB predicted\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}