Product.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "%cd sku_dockship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "!which python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import argparse\n",
    "import os\n",
    "import sys\n",
    "os.environ['CUDA_VISIBLE_DEVICES']=''\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "import keras \n",
    "import numpy\n",
    "\n",
    "from object_detector_retinanet.keras_retinanet import models\n",
    "from object_detector_retinanet.keras_retinanet.preprocessing.csv_generator import CSVGenerator\n",
    "from object_detector_retinanet.keras_retinanet.utils.predict_iou import predict\n",
    "from object_detector_retinanet.keras_retinanet.utils.keras_version import check_keras_version\n",
    "from object_detector_retinanet.utils import image_path, annotation_path, root_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def get_session():\n",
    "    \"\"\" Construct a modified tf session.\n",
    "    \"\"\"\n",
    "    config = tf.ConfigProto()\n",
    "    config.gpu_options.allow_growth = True\n",
    "    return tf.Session(config=config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "keras.backend.tensorflow_backend.set_session(get_session())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "CLASSES         = 'object_detector_retinanet/keras_retinanet/bin/class_mappings.csv'\n",
    "MODEL           =  'iou_resnet50_csv_06.h5'\n",
    "MAX_DETECTIONS  = 9999\n",
    "hard_score_rate = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np\n",
    "import random\n",
    "import threading\n",
    "import warnings\n",
    "\n",
    "import keras\n",
    "\n",
    "from utils.anchors import anchor_targets_bbox, bbox_transform\n",
    "from utils.image import (\n",
    "    TransformParameters,\n",
    "    adjust_transform_for_image,\n",
    "    apply_transform,\n",
    "    preprocess_image,\n",
    "    resize_image,\n",
    ")\n",
    "from utils.transform import transform_aabb\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from object_detector_retinanet.keras_retinanet.preprocessing.get_image_size import get_image_size\n",
    "from utils.image import read_image_bgr\n",
    "import cv2\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from six import raise_from\n",
    "from tqdm import tqdm\n",
    "\n",
    "import csv\n",
    "import sys\n",
    "import os.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print('Loading model, this may take a second...')\n",
    "model = models.load_model(MODEL, backbone_name='resnet50', convert=1, nms=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import csv\n",
    "\n",
    "import datetime\n",
    "\n",
    "from object_detector_retinanet.keras_retinanet.utils import EmMerger\n",
    "from object_detector_retinanet.utils import create_folder, root_dir\n",
    "from utils.visualization import draw_detections, draw_annotations\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "csv_data_lst = []\n",
    "csv_data_lst.append(['image_id', 'x1', 'y1', 'x2', 'y2', 'confidence', 'hard_score'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "image_name = os.getcwd()+'/test_0.jpg'\n",
    "raw_image = read_image_bgr(image_name)\n",
    "image = preprocess_image(raw_image.copy())\n",
    "image, scale = resize_image(image)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "boxes, hard_scores, labels, soft_scores = model.predict_on_batch(np.expand_dims(image, axis=0))\n",
    "soft_scores = np.squeeze(soft_scores, axis=-1)\n",
    "soft_scores = hard_score_rate * hard_scores + (1 - hard_score_rate) * soft_scores\n",
    "boxes /= scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# select indices which have a score above the threshold\n",
    "indices = np.where(hard_scores[0, :] > 0.05)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "scores = soft_scores[0][indices]\n",
    "hard_scores = hard_scores[0][indices]\n",
    "# find the order with which to sort the scores\n",
    "scores_sort = np.argsort(-scores)[:MAX_DETECTIONS]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "image_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "image_boxes = boxes[0, indices[scores_sort], :]\n",
    "image_scores = scores[scores_sort]\n",
    "image_hard_scores = hard_scores[scores_sort]\n",
    "image_labels = labels[0, indices[scores_sort]]\n",
    "image_detections = np.concatenate(\n",
    "    [image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_labels, axis=1)], axis=1)\n",
    "results = np.concatenate(\n",
    "    [image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_hard_scores, axis=1),\n",
    "     np.expand_dims(image_labels, axis=1)], axis=1)\n",
    "\n",
    "filtered_data = EmMerger.merge_detections(image_name, results)\n",
    "filtered_boxes = []\n",
    "filtered_scores = []\n",
    "filtered_labels = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for ind, detection in filtered_data.iterrows():\n",
    "    box = np.asarray([detection['x1'], detection['y1'], detection['x2'], detection['y2']])\n",
    "    filtered_boxes.append(box)\n",
    "    filtered_scores.append(detection['confidence'])\n",
    "    filtered_labels.append('{0:.2f}'.format(detection['hard_score']))\n",
    "    row = [image_name, detection['x1'], detection['y1'], detection['x2'], detection['y2'],\n",
    "           detection['confidence'], detection['hard_score']]\n",
    "    csv_data_lst.append(row)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(csv_data_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "draw_detections(raw_image, np.asarray(filtered_boxes), np.asarray(filtered_scores),\n",
    "                        np.asarray(filtered_labels), color=(0, 0, 255))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "cv2.imwrite('output.jpg', raw_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plt.imshow(raw_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/unreal/rahul/Product_Recognition/sku_dockship\n"
     ]
    }
   ],
   "source": [
    "%cd sku_dockship/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import argparse\n",
    "import functools\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "import warnings\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = ''\n",
    "import keras\n",
    "import keras.preprocessing.image\n",
    "import tensorflow as tf\n",
    "from keras.utils import multi_gpu_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from object_detector_retinanet.keras_retinanet import losses\n",
    "from object_detector_retinanet.keras_retinanet import models\n",
    "from object_detector_retinanet.keras_retinanet.callbacks import RedirectModel\n",
    "from object_detector_retinanet.keras_retinanet.models.retinanet import retinanet_bbox\n",
    "from object_detector_retinanet.keras_retinanet.preprocessing.csv_generator import CSVGenerator\n",
    "from object_detector_retinanet.keras_retinanet.utils.anchors import make_shapes_callback, anchor_targets_bbox\n",
    "from object_detector_retinanet.keras_retinanet.utils.keras_version import check_keras_version\n",
    "from object_detector_retinanet.keras_retinanet.utils.model import freeze as freeze_model\n",
    "from object_detector_retinanet.keras_retinanet.utils.transform import random_transform_generator\n",
    "\n",
    "from object_detector_retinanet.utils import create_folder, image_path, annotation_path, root_dir, DEBUG_MODE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def create_models(backbone_retinanet, num_classes, weights, multi_gpu=0, freeze_backbone=False):\n",
    "    \"\"\" Creates three models (model, training_model, prediction_model).\n",
    "\n",
    "    Args\n",
    "        backbone_retinanet : A function to call to create a retinanet model with a given backbone.\n",
    "        num_classes        : The number of classes to train.\n",
    "        weights            : The weights to load into the model.\n",
    "        multi_gpu          : The number of GPUs to use for training.\n",
    "        freeze_backbone    : If True, disables learning for the backbone.\n",
    "\n",
    "    Returns\n",
    "        model            : The base model. This is also the model that is saved in snapshots.\n",
    "        training_model   : The training model. If multi_gpu=0, this is identical to model.\n",
    "        prediction_model : The model wrapped with utility functions to perform object detection (applies regression values and performs NMS).\n",
    "    \"\"\"\n",
    "    modifier = freeze_model if freeze_backbone else None\n",
    "\n",
    "    # Keras recommends initialising a multi-gpu model on the CPU to ease weight sharing, and to prevent OOM errors.\n",
    "    # optionally wrap in a parallel model\n",
    "    if multi_gpu > 1:\n",
    "        with tf.device('/cpu:0'):\n",
    "            model = model_with_weights(backbone_retinanet(num_classes, modifier=modifier), weights=weights,\n",
    "                                       skip_mismatch=True)\n",
    "        training_model = multi_gpu_model(model, gpus=multi_gpu)\n",
    "    else:\n",
    "        model = model_with_weights(backbone_retinanet(num_classes, modifier=modifier), weights=weights,\n",
    "                                   skip_mismatch=True)\n",
    "        training_model = model\n",
    "\n",
    "    # make prediction model\n",
    "    prediction_model = retinanet_bbox(model=model)\n",
    "\n",
    "    # compile model\n",
    "    training_model.compile(\n",
    "        loss={\n",
    "            'regression': losses.smooth_l1(),\n",
    "            'classification': losses.focal()\n",
    "        },\n",
    "        optimizer=keras.optimizers.adam(lr=1e-5, clipnorm=0.001)\n",
    "        # optimizer=keras.optimizers.SGD()\n",
    "    )\n",
    "\n",
    "    return model, training_model, prediction_model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": [
     0,
     9,
     15,
     26,
     84
    ]
   },
   "outputs": [],
   "source": [
    "def makedirs(path):\n",
    "    # Intended behavior: try to create the directory,\n",
    "    # pass if the directory exists already, fails otherwise.\n",
    "    # Meant for Python 2.7/3.n compatibility.\n",
    "    try:\n",
    "        os.makedirs(path)\n",
    "    except OSError:\n",
    "        if not os.path.isdir(path):\n",
    "            raise\n",
    "def get_session():\n",
    "    \"\"\" Construct a modified tf session.\n",
    "    \"\"\"\n",
    "    config = tf.ConfigProto()\n",
    "    config.gpu_options.allow_growth = True\n",
    "    return tf.Session(config=config)\n",
    "def model_with_weights(model, weights, skip_mismatch):\n",
    "    \"\"\" Load weights for model.\n",
    "\n",
    "    Args\n",
    "        model         : The model to load weights for.\n",
    "        weights       : The weights to load.\n",
    "        skip_mismatch : If True, skips layers whose shape of weights doesn't match with the model.\n",
    "    \"\"\"\n",
    "    if weights is not None:\n",
    "        model.load_weights(weights, by_name=True, skip_mismatch=skip_mismatch)\n",
    "    return model\n",
    "def create_callbacks(model, training_model, prediction_model, validation_generator):\n",
    "    \"\"\" Creates the callbacks to use during training.\n",
    "\n",
    "    Args\n",
    "        model: The base model.\n",
    "        training_model: The model that is used for training.\n",
    "        prediction_model: The model that should be used for validation.\n",
    "        validation_generator: The generator for creating validation data.\n",
    "        args: parseargs args object.\n",
    "\n",
    "    Returns:\n",
    "        A list of callbacks used for training.\n",
    "    \"\"\"\n",
    "    callbacks = []\n",
    "\n",
    "    tensorboard_callback = None\n",
    "\n",
    "    if TENSORBOARD_DIR:\n",
    "        tensorboard_callback = keras.callbacks.TensorBoard(\n",
    "            log_dir=TENSORBOARD_DIR,\n",
    "            histogram_freq=0,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            write_graph=True,\n",
    "            write_grads=False,\n",
    "            write_images=False,\n",
    "            embeddings_freq=0,\n",
    "            embeddings_layer_names=None,\n",
    "            embeddings_metadata=None\n",
    "        )\n",
    "        callbacks.append(tensorboard_callback)\n",
    "\n",
    "    # save the model\n",
    "    if SNAPSHOT:\n",
    "        # ensure directory created first; otherwise h5py will error after epoch.\n",
    "        makedirs(SNAPSHOT_PATH)\n",
    "        checkpoint = keras.callbacks.ModelCheckpoint(\n",
    "            os.path.join(\n",
    "                SNAPSHOT_PATH,\n",
    "                '{backbone}_{dataset_type}_{{epoch:02d}}.h5'.format(backbone=BACKBONE,\n",
    "                                                                    dataset_type=DATASET_TYPE)\n",
    "            ),\n",
    "            verbose=1\n",
    "        )\n",
    "        checkpoint = RedirectModel(checkpoint, model)\n",
    "        callbacks.append(checkpoint)\n",
    "\n",
    "    callbacks.append(keras.callbacks.ReduceLROnPlateau(\n",
    "        monitor='loss',\n",
    "        factor=0.1,\n",
    "        patience=2,\n",
    "        verbose=1,\n",
    "        mode='auto',\n",
    "        epsilon=0.0001,\n",
    "        cooldown=0,\n",
    "        min_lr=0\n",
    "    ))\n",
    "\n",
    "    return callbacks\n",
    "def create_generators():\n",
    "    \"\"\" Create generators for training and validation.\n",
    "    \"\"\"\n",
    "    # create random transform generator for augmenting training data\n",
    "    if RANDOM_TRANSFORM:\n",
    "        transform_generator = random_transform_generator(\n",
    "            min_rotation=-0.1,\n",
    "            max_rotation=0.1,\n",
    "            min_translation=(-0.1, -0.1),\n",
    "            max_translation=(0.1, 0.1),\n",
    "            min_shear=-0.1,\n",
    "            max_shear=0.1,\n",
    "            min_scaling=(0.9, 0.9),\n",
    "            max_scaling=(1.1, 1.1),\n",
    "            flip_x_chance=0.5,\n",
    "            flip_y_chance=0.5,\n",
    "        )\n",
    "    else:\n",
    "        transform_generator = random_transform_generator(flip_x_chance=0.5)\n",
    "\n",
    "    if DATASET_TYPE == 'csv':\n",
    "        train_generator = CSVGenerator(\n",
    "            ANNOTATIONS,\n",
    "            CLASSES,\n",
    "            transform_generator=transform_generator,\n",
    "            base_dir=BASE_DIR,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            image_min_side=IMAGE_MIN_SIDE,\n",
    "            image_max_side=IMAGE_MAX_SIDE\n",
    "        )\n",
    "\n",
    "        if VAL_ANNOTATIONS:\n",
    "            validation_generator = CSVGenerator(\n",
    "                VAL_ANNOTATIONS,\n",
    "                CLASSES,\n",
    "                base_dir=BASE_DIR,\n",
    "                batch_size=BATCH_SIZE,\n",
    "                image_min_side=IMAGE_MIN_SIDE,\n",
    "                image_max_side=IMAGE_MAX_SIDE\n",
    "            )\n",
    "        else:\n",
    "            validation_generator = None\n",
    "    else:\n",
    "        raise ValueError('Invalid data type received: {}'.format(args.dataset_type))\n",
    "\n",
    "    return train_generator, validation_generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "BACKBONE           = 'resnet50'\n",
    "SNAPSHOT_PATH      = './snapshots'\n",
    "SNAPSHOT           = None#'iou_resnet50_csv_06.h5'\n",
    "TENSORBOARD_DIR    = './tensorboard'\n",
    "RANDOM_TRANSFORM   = True\n",
    "IMAGE_MIN_SIDE     = 800\n",
    "IMAGE_MAX_SIDE     = 1333\n",
    "FREEZE_BACKBONE    = True\n",
    "NO_SNAPSHOTS       = True\n",
    "EPOCHS             = 150\n",
    "STEPS              = 10000\n",
    "ANNOTATIONS        = '/home/unreal/Documents/SKU110K/annotations/annotations_train.csv'\n",
    "CLASSES            = 'object_detector_retinanet/keras_retinanet/bin/class_mappings.csv'\n",
    "VAL_ANNOTATIONS    = '/home/unreal/Documents/SKU110K/annotations/annotations_val.csv'\n",
    "BASE_DIR           = '/home/unreal/Documents/SKU110K/images'\n",
    "DATASET_TYPE       = 'csv'\n",
    "BATCH_SIZE         = 1\n",
    "WEIGHTS            = None\n",
    "MULTI_GPU          = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "backbone = models.backbone(BACKBONE)\n",
    "# create_folder(SNAPSHOT_PATH)\n",
    "# create_folder(TENSORBOARD_DIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<object_detector_retinanet.keras_retinanet.models.resnet.ResNetBackbone at 0x7f0069697b00>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backbone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_generator, validation_generator = create_generators()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if SNAPSHOT is not None:\n",
    "    print('Loading model, this may take a second...')\n",
    "    model = models.load_model(SNAPSHOT, backbone_name=BACKBONE)\n",
    "    training_model = model\n",
    "    prediction_model = retinanet_bbox(model=model)\n",
    "else:\n",
    "    if WEIGHTS is None:\n",
    "        weights = backbone.download_imagenet()\n",
    "    print('Creating model, this may take a second...')\n",
    "    model, training_model, prediction_model = create_models(\n",
    "            backbone_retinanet=backbone.retinanet,\n",
    "            num_classes=train_generator.num_classes(),\n",
    "            weights=WEIGHTS,\n",
    "            multi_gpu=MULTI_GPU,\n",
    "            freeze_backbone=FREEZE_BACKBONE\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'vgg' in BACKBONE or 'densenet' in BACKBONE:\n",
    "    compute_anchor_targets = functools.partial(anchor_targets_bbox, shapes_callback=make_shapes_callback(model))\n",
    "    train_generator.compute_anchor_targets = compute_anchor_targets\n",
    "    if validation_generator is not None:\n",
    "        validation_generator.compute_anchor_targets = compute_anchor_targets\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = create_callbacks(\n",
    "    model,\n",
    "    training_model,\n",
    "    prediction_model,\n",
    "    validation_generator,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "training_model.fit_generator(\n",
    "        generator=train_generator,\n",
    "        steps_per_epoch=STEPS,\n",
    "        epochs=EPOCHS,\n",
    "        verbose=1,\n",
    "        callbacks=callbacks,\n",
    "        validation_data=validation_generator,\n",
    "        validation_steps=validation_generator.size()\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}