T4_PriorBox.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# TODO: SSD model (PriorBox)\n",
    "import keras.backend as K\n",
    "from keras.engine.topology import InputSpec\n",
    "from keras.engine.topology import Layer\n",
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Series of boxes [xmin, ymin, xmax, ymax] and variances\n",
    "This layer is just providing each layers [xmin, ymin, xmax, ymax] which units maps from layer to image.<br/>\n",
    "Because training data is all about with real image size.\n",
    "- Note\n",
    "> `I wonder that in this layer, tensor will be trained like Neuron.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class PriorBox(Layer):\n",
    "    \n",
    "    def __init__(self, img_size, min_size, max_size=None, aspect_ratios=None,\n",
    "                flip=True, variances=[0.1], clip=True, **kwargs):\n",
    "        self.waxis = 2\n",
    "        self.haxis = 1\n",
    "        self.img_size = img_size\n",
    "        self.min_size = min_size\n",
    "        self.max_size = max_size\n",
    "        self.aspect_ratios = [1.0]\n",
    "        if max_size:\n",
    "            self.aspect_ratios.append(1.0)\n",
    "        if aspect_ratios:\n",
    "            for ar in aspect_ratios:\n",
    "                if ar in self.aspect_ratios:\n",
    "                    continue\n",
    "                self.aspect_ratios.append(ar)\n",
    "                if flip:\n",
    "                    self.aspect_ratios.append(1.0 / ar)\n",
    "        self.variances = np.array(variances)\n",
    "        self.clip = True\n",
    "        super(PriorBox, self).__init__(**kwargs)\n",
    "        \n",
    "    def compute_output_shape(self, input_shape):\n",
    "        num_priors_ = len(self.aspect_ratios)\n",
    "        layer_width = input_shape[self.waxis]\n",
    "        layer_height = input_shape[self.haxis]\n",
    "        num_boxes = num_priors_ * layer_width * layer_height\n",
    "        # 8 means shape of (xmin, ymin, xmax, ymax, variances{4})\n",
    "        return (input_shape[0], num_boxes, 8)\n",
    "    \n",
    "    def call(self, x, mask=None):\n",
    "        if hasattr(x, '_keras_shape'):\n",
    "            input_shape = x._keras_shape\n",
    "        elif hasattr(K, 'int_shape'):\n",
    "            input_shape = K.int_shape(x)\n",
    "            \n",
    "        layer_width = input_shape[self.waxis]\n",
    "        layer_height = input_shape[self.haxis]\n",
    "        \n",
    "        img_width, img_height = img_size[:2]\n",
    "        \n",
    "        box_widths = []\n",
    "        box_heights = []\n",
    "        \n",
    "        for ar in self.aspect_ratios:\n",
    "            if ar == 1 and len(box_widths) == 0:\n",
    "                box_widths.append(self.min_size)\n",
    "                box_heights.append(self.min_size)\n",
    "            elif ar == 1 and len(box_widths) > 0:\n",
    "                # sqrt(min*max)\n",
    "                box_widths.append(np.sqrt(self.min_size * self.max_size))\n",
    "                box_heights.append(np.sqrt(self.min_size * self.max_size))\n",
    "            elif ar != 1:\n",
    "                # ratio of width:height\n",
    "                box_widths.append(self.min_size * np.sqrt(ar))\n",
    "                box_heights.append(self.min_size / np.sqrt(ar))\n",
    "        \n",
    "        # half length, for calculate step length (image_size)\n",
    "        box_widths = 0.5 * np.array(box_widths)\n",
    "        box_heights = 0.5 * np.array(box_heights)\n",
    "        \n",
    "        # define centers of prior boxes\n",
    "        # mapping steps from layer to image\n",
    "        step_x = img_width / layer_width\n",
    "        step_y = img_height / layer_height\n",
    "        \n",
    "        # list of box center positions (x, y)\n",
    "        # note here, it's restricted by image_size \n",
    "        linx = np.linspace(0.5 * step_x, img_width - 0.5 * step_x, layer_width)\n",
    "        liny = np.linspace(0.5 * step_y, img_height - 0.5 * step_y, layer_height)\n",
    "        \n",
    "        centers_x, centers_y = np.meshgrid(linx, liny)\n",
    "        centers_x = centers_x.reshape(-1, 1)\n",
    "        centers_y = centers_y.reshape(-1, 1)\n",
    "        \n",
    "        # define xmin, ymin, xmax, ymax of priors boxes\n",
    "        num_priors_ = len(self.aspect_ratios)\n",
    "        # (x, y) of center box\n",
    "        prior_boxes = np.concatenate((centers_x, centers_y), axis=1)\n",
    "        prior_boxes = np.tile(prior_boxes, (1, 2 * num_priors_))\n",
    "        # [xmin, ymin, xmax, ymax]\n",
    "        prior_boxes[:, ::4] -= box_widths\n",
    "        prior_boxes[:, 1::4] -= box_heights\n",
    "        prior_boxes[:, 2::4] += box_widths\n",
    "        prior_boxes[:, 3::3] += box_heights\n",
    "        # regularization\n",
    "        prior_boxes[:, ::2] /= img_width\n",
    "        prior_boxes[:, 1::2] /= img_height\n",
    "        prior_boxes = prior_boxes.reshape(-1, 4)\n",
    "        \n",
    "        if self.clip:\n",
    "            prior_boxes = np.minimum(np.maximum(prior_boxes, 0.0), 1.0)\n",
    "        if len(self.variances) == 1:\n",
    "            variances = np.ones((num_boxes, 4)) * self.variances[0]\n",
    "        elif len(self.variances) == 4:\n",
    "            variances = np.tile(self.variances, (num_boxes, 1))\n",
    "            \n",
    "        prior_boxes = np.concatenate((prior_boxes, variances), axis=1)\n",
    "        prior_boxes_tensor = K.expand_dims(K.variable(prior_boxes), 0)\n",
    "        pattern = [tf.shape(x)[0], 1, 1]\n",
    "        prior_boxes_tensor = tf.tile(prior_boxes_tensor, pattern)\n",
    "        \n",
    "        return prior_boxes_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}