retinaNet

+#see https://github.com/codecov/support/wiki/Codecov-Yaml
+codecov:
+  notify:
+    require_ci_to_pass: yes
+
+coverage:
+  precision: 0  # 2 = xx.xx%, 0 = xx%
+  round: nearest # how coverage is rounded: down/up/nearest
+  range: 40...100 # custom range of coverage colors from red -> yellow -> green
+  status:
+    # https://codecov.readme.io/v1.0/docs/commit-status
+    project:
+      default:
+        against: auto
+        target: 90% # specify the target coverage for each commit status
+        threshold: 20% # allow this little decrease on project
+        # https://github.com/codecov/support/wiki/Filtering-Branches
+        # branches: master
+        if_ci_failed: error
+    # https://github.com/codecov/support/wiki/Patch-Status
+    patch:
+      default:
+        against: auto
+        target: 40% # specify the target "X%" coverage to hit
+        # threshold: 50% # allow this much decrease on patch
+    changes: false
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: true
+      loop: true
+      macro: false
+      method: false
+  javascript:
+    enable_partials: false
+
+comment:
+  layout: header, diff
+  require_changes: false
+  behavior: default  # update if exists else create new
+  # branches: *
\ No newline at end of file

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+/build/
+/dist/
+/eggs/
+/*-eggs/
+.eggs/
+/sdist/
+/wheels/
+/*.egg-info/
+.installed.cfg
+*.egg
+
+# Unit test / coverage reports
+.coverage
+.coverage.*
+coverage.xml
+*.cover
\ No newline at end of file

+[submodule "tests/test-data"]
+	path = tests/test-data
+	url = https://github.com/fizyr/keras-retinanet-test-data.git

+language: python
+
+sudo: required
+
+python:
+    - '3.6'
+    - '3.7'
+
+install:
+    - pip install -r requirements.txt
+    - pip install -r tests/requirements.txt
+
+cache: pip
+
+script:
+    - python setup.py check -m -s
+    - python setup.py build_ext --inplace
+    - coverage run --source keras_retinanet -m py.test keras_retinanet tests --doctest-modules --forked --flake8
+
+after_success:
+    - coverage xml
+    - coverage report
+    - codecov

+# Contributors
+
+This is a list of people who contributed patches to keras-retinanet.
+
+If you feel you should be listed here or if you have any other questions/comments on your listing here,
+please create an issue or pull request at https://github.com/fizyr/keras-retinanet/
+
+* Hans Gaiser <h.gaiser@fizyr.com>
+* Maarten de Vries <maarten@de-vri.es>
+* Valerio Carpani
+* Ashley Williamson
+* Yann Henon
+* Valeriu Lacatusu
+* András Vidosits
+* Cristian Gratie
+* jjiunlin
+* Sorin Panduru
+* Rodrigo Meira de Andrade
+* Enrico Liscio <e.liscio@fizyr.com>
+* Mihai Morariu
+* pedroconceicao
+* jjiun
+* Wudi Fang
+* Mike Clark
+* hannesedvartsen
+* Max Van Sande
+* Pierre Dérian
+* ori
+* mxvs
+* mwilder
+* Muhammed Kocabas
+* Koen Vijverberg
+* iver56
+* hnsywangxin
+* Guillaume Erhard
+* Eduardo Ramos
+* DiegoAgher
+* Alexander Pacha
+* Agastya Kalra
+* Jiri BOROVEC
+* ntsagko
+* charlie / tianqi
+* jsemric
+* Martin Zlocha
+* Raghav Bhardwaj
+* bw4sz
+* Morten Back Nielsen
+* dshahrokhian
+* Alex / adreo00
+* simone.merello
+* Matt Wilder
+* Jinwoo Baek
+* Etienne Meunier
+* Denis Dowling
+* cclauss
+* Andrew Grigorev
+* ZFTurbo
+* UgoLouche
+* Richard Higgins
+* Rajat /  rajat.goel
+* philipp.marquardt
+* peacherwu
+* Paul / pauldesigaud
+* Martin Genet
+* Leo / leonardvandriel
+* Laurens Hagendoorn
+* Julius / juliussimonelli
+* HolyGuacamole
+* Fausto Morales
+* borakrc
+* Ben Weinstein
+* Anil Karaka
+* Andrea Panizza
+* Bruno Santos
\ No newline at end of file

+[anchor_parameters]
+# Sizes should correlate to how the network processes an image, it is not advised to change these!
+sizes   = 64 128 256
+# Strides should correlate to how the network strides over an image, it is not advised to change these!
+strides = 16 32 64
+# The different ratios to use per anchor location.
+ratios  = 0.5 1 2 3
+# The different scaling factors to use per anchor location.
+scales  = 1 1.2 1.6
+
+[pyramid_levels]
+
+levels = 3 4 5
\ No newline at end of file

+[.ShellClassInfo]
+IconResource=C:\WINDOWS\System32\SHELL32.dll,3
+[ViewState]
+Mode=
+Vid=
+FolderType=Generic

+#!/usr/bin/env python
+# coding: utf-8
+
+# Load necessary modules
+
+import sys
+
+sys.path.insert(0, "../")
+
+
+# import keras_retinanet
+from keras_retinanet import models
+from keras_retinanet.utils.image import read_image_bgr, preprocess_image, resize_image
+from keras_retinanet.utils.visualization import draw_box, draw_caption
+from keras_retinanet.utils.colors import label_color
+from keras_retinanet.utils.gpu import setup_gpu
+
+# import miscellaneous modules
+import matplotlib.pyplot as plt
+import cv2
+import os
+import numpy as np
+import time
+
+# set tf backend to allow memory to grow, instead of claiming everything
+import tensorflow as tf
+
+# use this to change which GPU to use
+gpu = 0
+
+# set the modified tf session as backend in keras
+setup_gpu(gpu)
+
+
+# ## Load RetinaNet model
+
+# In[ ]:
+
+
+# adjust this to point to your downloaded/trained model
+# models can be downloaded here: https://github.com/fizyr/keras-retinanet/releases
+model_path = os.path.join("..", "snapshots", "resnet50_coco_best_v2.1.0.h5")
+
+# load retinanet model
+model = models.load_model(model_path, backbone_name="resnet50")
+
+# if the model is not converted to an inference model, use the line below
+# see: https://github.com/fizyr/keras-retinanet#converting-a-training-model-to-inference-model
+# model = models.convert_model(model)
+
+# print(model.summary())
+
+# load label to names mapping for visualization purposes
+labels_to_names = {
+    0: "person",
+    1: "bicycle",
+    2: "car",
+    3: "motorcycle",
+    4: "airplane",
+    5: "bus",
+    6: "train",
+    7: "truck",
+    8: "boat",
+    9: "traffic light",
+    10: "fire hydrant",
+    11: "stop sign",
+    12: "parking meter",
+    13: "bench",
+    14: "bird",
+    15: "cat",
+    16: "dog",
+    17: "horse",
+    18: "sheep",
+    19: "cow",
+    20: "elephant",
+    21: "bear",
+    22: "zebra",
+    23: "giraffe",
+    24: "backpack",
+    25: "umbrella",
+    26: "handbag",
+    27: "tie",
+    28: "suitcase",
+    29: "frisbee",
+    30: "skis",
+    31: "snowboard",
+    32: "sports ball",
+    33: "kite",
+    34: "baseball bat",
+    35: "baseball glove",
+    36: "skateboard",
+    37: "surfboard",
+    38: "tennis racket",
+    39: "bottle",
+    40: "wine glass",
+    41: "cup",
+    42: "fork",
+    43: "knife",
+    44: "spoon",
+    45: "bowl",
+    46: "banana",
+    47: "apple",
+    48: "sandwich",
+    49: "orange",
+    50: "broccoli",
+    51: "carrot",
+    52: "hot dog",
+    53: "pizza",
+    54: "donut",
+    55: "cake",
+    56: "chair",
+    57: "couch",
+    58: "potted plant",
+    59: "bed",
+    60: "dining table",
+    61: "toilet",
+    62: "tv",
+    63: "laptop",
+    64: "mouse",
+    65: "remote",
+    66: "keyboard",
+    67: "cell phone",
+    68: "microwave",
+    69: "oven",
+    70: "toaster",
+    71: "sink",
+    72: "refrigerator",
+    73: "book",
+    74: "clock",
+    75: "vase",
+    76: "scissors",
+    77: "teddy bear",
+    78: "hair drier",
+    79: "toothbrush",
+}
+
+
+# ## Run detection on example
+
+# In[ ]:
+
+
+# load image
+image = read_image_bgr("000000008021.jpg")
+
+# copy to draw on
+draw = image.copy()
+draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
+
+# preprocess image for network
+image = preprocess_image(image)
+image, scale = resize_image(image)
+
+# process image
+start = time.time()
+boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
+print("processing time: ", time.time() - start)
+
+# correct for image scale
+boxes /= scale
+
+# visualize detections
+for box, score, label in zip(boxes[0], scores[0], labels[0]):
+    # scores are sorted so we can break
+    if score < 0.5:
+        break
+
+    color = label_color(label)
+
+    b = box.astype(int)
+    draw_box(draw, b, color=color)
+
+    caption = "{} {:.3f}".format(labels_to_names[label], score)
+    draw_caption(draw, b, caption)
+
+plt.figure(figsize=(15, 15))
+plt.axis("off")
+plt.imshow(draw)
+plt.show()
+
+
+# In[ ]:
+
+
+# In[ ]:

+from .backend import *  # noqa: F401,F403

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import tensorflow
+from tensorflow import keras
+
+
+def bbox_transform_inv(boxes, deltas, mean=None, std=None):
+    """ Applies deltas (usually regression results) to boxes (usually anchors).
+
+    Before applying the deltas to the boxes, the normalization that was previously applied (in the generator) has to be removed.
+    The mean and std are the mean and std as applied in the generator. They are unnormalized in this function and then applied to the boxes.
+
+    Args
+        boxes : np.array of shape (B, N, 4), where B is the batch size, N the number of boxes and 4 values for (x1, y1, x2, y2).
+        deltas: np.array of same shape as boxes. These deltas (d_x1, d_y1, d_x2, d_y2) are a factor of the width/height.
+        mean  : The mean value used when computing deltas (defaults to [0, 0, 0, 0]).
+        std   : The standard deviation used when computing deltas (defaults to [0.2, 0.2, 0.2, 0.2]).
+
+    Returns
+        A np.array of the same shape as boxes, but with deltas applied to each box.
+        The mean and std are used during training to normalize the regression values (networks love normalization).
+    """
+    if mean is None:
+        mean = [0, 0, 0, 0]
+    if std is None:
+        std = [0.2, 0.2, 0.2, 0.2]
+
+    width  = boxes[:, :, 2] - boxes[:, :, 0]
+    height = boxes[:, :, 3] - boxes[:, :, 1]
+
+    x1 = boxes[:, :, 0] + (deltas[:, :, 0] * std[0] + mean[0]) * width
+    y1 = boxes[:, :, 1] + (deltas[:, :, 1] * std[1] + mean[1]) * height
+    x2 = boxes[:, :, 2] + (deltas[:, :, 2] * std[2] + mean[2]) * width
+    y2 = boxes[:, :, 3] + (deltas[:, :, 3] * std[3] + mean[3]) * height
+
+    pred_boxes = keras.backend.stack([x1, y1, x2, y2], axis=2)
+
+    return pred_boxes
+
+
+def shift(shape, stride, anchors):
+    """ Produce shifted anchors based on shape of the map and stride size.
+
+    Args
+        shape  : Shape to shift the anchors over.
+        stride : Stride to shift the anchors with over the shape.
+        anchors: The anchors to apply at each location.
+    """
+    shift_x = (keras.backend.arange(0, shape[1], dtype=keras.backend.floatx()) + keras.backend.constant(0.5, dtype=keras.backend.floatx())) * stride
+    shift_y = (keras.backend.arange(0, shape[0], dtype=keras.backend.floatx()) + keras.backend.constant(0.5, dtype=keras.backend.floatx())) * stride
+
+    shift_x, shift_y = tensorflow.meshgrid(shift_x, shift_y)
+    shift_x = keras.backend.reshape(shift_x, [-1])
+    shift_y = keras.backend.reshape(shift_y, [-1])
+
+    shifts = keras.backend.stack([
+        shift_x,
+        shift_y,
+        shift_x,
+        shift_y
+    ], axis=0)
+
+    shifts            = keras.backend.transpose(shifts)
+    number_of_anchors = keras.backend.shape(anchors)[0]
+
+    k = keras.backend.shape(shifts)[0]  # number of base points = feat_h * feat_w
+
+    shifted_anchors = keras.backend.reshape(anchors, [1, number_of_anchors, 4]) + keras.backend.cast(keras.backend.reshape(shifts, [k, 1, 4]), keras.backend.floatx())
+    shifted_anchors = keras.backend.reshape(shifted_anchors, [k * number_of_anchors, 4])
+
+    return shifted_anchors
+
+
+def map_fn(*args, **kwargs):
+    """ See https://www.tensorflow.org/api_docs/python/tf/map_fn .
+    """
+
+    if "shapes" in kwargs:
+        shapes = kwargs.pop("shapes")
+        dtype = kwargs.pop("dtype")
+        sig = [tensorflow.TensorSpec(shapes[i], dtype=t) for i, t in
+               enumerate(dtype)]
+
+        # Try to use the new feature fn_output_signature in TF 2.3, use fallback if this is not available
+        try:
+            return tensorflow.map_fn(*args, **kwargs, fn_output_signature=sig)
+        except TypeError:
+            kwargs["dtype"] = dtype
+
+    return tensorflow.map_fn(*args, **kwargs)
+
+
+def resize_images(images, size, method='bilinear', align_corners=False):
+    """ See https://www.tensorflow.org/versions/r1.14/api_docs/python/tf/image/resize_images .
+
+    Args
+        method: The method used for interpolation. One of ('bilinear', 'nearest', 'bicubic', 'area').
+    """
+    methods = {
+        'bilinear': tensorflow.image.ResizeMethod.BILINEAR,
+        'nearest' : tensorflow.image.ResizeMethod.NEAREST_NEIGHBOR,
+        'bicubic' : tensorflow.image.ResizeMethod.BICUBIC,
+        'area'    : tensorflow.image.ResizeMethod.AREA,
+    }
+    return tensorflow.compat.v1.image.resize_images(images, size, methods[method], align_corners)

+#!/usr/bin/env python
+
+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import argparse
+import os
+import sys
+
+# Allow relative imports when being executed as script.
+if __name__ == "__main__" and __package__ is None:
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+    import keras_retinanet.bin  # noqa: F401
+    __package__ = "keras_retinanet.bin"
+
+# Change these to absolute imports if you copy this script outside the keras_retinanet package.
+from .. import models
+from ..utils.config import read_config_file, parse_anchor_parameters, parse_pyramid_levels
+from ..utils.gpu import setup_gpu
+from ..utils.tf_version import check_tf_version
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser(description='Script for converting a training model to an inference model.')
+
+    parser.add_argument('model_in', help='The model to convert.')
+    parser.add_argument('model_out', help='Path to save the converted model to.')
+    parser.add_argument('--backbone', help='The backbone of the model to convert.', default='resnet50')
+    parser.add_argument('--no-nms', help='Disables non maximum suppression.', dest='nms', action='store_false')
+    parser.add_argument('--no-class-specific-filter', help='Disables class specific filtering.', dest='class_specific_filter', action='store_false')
+    parser.add_argument('--config', help='Path to a configuration parameters .ini file.')
+    parser.add_argument('--nms-threshold', help='Value for non maximum suppression threshold.', type=float, default=0.5)
+    parser.add_argument('--score-threshold', help='Threshold for prefiltering boxes.', type=float, default=0.05)
+    parser.add_argument('--max-detections', help='Maximum number of detections to keep.', type=int, default=300)
+    parser.add_argument('--parallel-iterations', help='Number of batch items to process in parallel.', type=int, default=32)
+
+    return parser.parse_args(args)
+
+
+def main(args=None):
+    # parse arguments
+    if args is None:
+        args = sys.argv[1:]
+    args = parse_args(args)
+
+    # make sure tensorflow is the minimum required version
+    check_tf_version()
+
+    # set modified tf session to avoid using the GPUs
+    setup_gpu('cpu')
+
+    # optionally load config parameters
+    anchor_parameters = None
+    pyramid_levels = None
+    if args.config:
+        args.config = read_config_file(args.config)
+        if 'anchor_parameters' in args.config:
+            anchor_parameters = parse_anchor_parameters(args.config)
+
+        if 'pyramid_levels' in args.config:
+            pyramid_levels = parse_pyramid_levels(args.config)
+
+    # load the model
+    model = models.load_model(args.model_in, backbone_name=args.backbone)
+
+    # check if this is indeed a training model
+    models.check_training_model(model)
+
+    # convert the model
+    model = models.convert_model(
+        model,
+        nms=args.nms,
+        class_specific_filter=args.class_specific_filter,
+        anchor_params=anchor_parameters,
+        pyramid_levels=pyramid_levels,
+        nms_threshold=args.nms_threshold,
+        score_threshold=args.score_threshold,
+        max_detections=args.max_detections,
+        parallel_iterations=args.parallel_iterations
+    )
+
+    # save model
+    model.save(args.model_out)
+
+
+if __name__ == '__main__':
+    main()

+#!/usr/bin/env python
+
+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import argparse
+import os
+import sys
+
+# Allow relative imports when being executed as script.
+if __name__ == "__main__" and __package__ is None:
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+    import keras_retinanet.bin  # noqa: F401
+    __package__ = "keras_retinanet.bin"
+
+# Change these to absolute imports if you copy this script outside the keras_retinanet package.
+from .. import models
+from ..preprocessing.csv_generator import CSVGenerator
+from ..preprocessing.pascal_voc import PascalVocGenerator
+from ..utils.anchors import make_shapes_callback
+from ..utils.config import read_config_file, parse_anchor_parameters, parse_pyramid_levels
+from ..utils.eval import evaluate
+from ..utils.gpu import setup_gpu
+from ..utils.tf_version import check_tf_version
+
+
+def create_generator(args, preprocess_image):
+    """ Create generators for evaluation.
+    """
+    common_args = {
+        'config'           : args.config,
+        'image_min_side'   : args.image_min_side,
+        'image_max_side'   : args.image_max_side,
+        'no_resize'        : args.no_resize,
+        'preprocess_image' : preprocess_image,
+        'group_method'     : args.group_method
+    }
+
+    if args.dataset_type == 'coco':
+        # import here to prevent unnecessary dependency on cocoapi
+        from ..preprocessing.coco import CocoGenerator
+
+        validation_generator = CocoGenerator(
+            args.coco_path,
+            'val2017',
+            shuffle_groups=False,
+            **common_args
+        )
+    elif args.dataset_type == 'pascal':
+        validation_generator = PascalVocGenerator(
+            args.pascal_path,
+            'test',
+            image_extension=args.image_extension,
+            shuffle_groups=False,
+            **common_args
+        )
+    elif args.dataset_type == 'csv':
+        validation_generator = CSVGenerator(
+            args.annotations,
+            args.classes,
+            shuffle_groups=False,
+            **common_args
+        )
+    else:
+        raise ValueError('Invalid data type received: {}'.format(args.dataset_type))
+
+    return validation_generator
+
+
+def parse_args(args):
+    """ Parse the arguments.
+    """
+    parser     = argparse.ArgumentParser(description='Evaluation script for a RetinaNet network.')
+    subparsers = parser.add_subparsers(help='Arguments for specific dataset types.', dest='dataset_type')
+    subparsers.required = True
+
+    coco_parser = subparsers.add_parser('coco')
+    coco_parser.add_argument('coco_path', help='Path to dataset directory (ie. /tmp/COCO).')
+
+    pascal_parser = subparsers.add_parser('pascal')
+    pascal_parser.add_argument('pascal_path', help='Path to dataset directory (ie. /tmp/VOCdevkit).')
+    pascal_parser.add_argument('--image-extension',   help='Declares the dataset images\' extension.', default='.jpg')
+
+    csv_parser = subparsers.add_parser('csv')
+    csv_parser.add_argument('annotations', help='Path to CSV file containing annotations for evaluation.')
+    csv_parser.add_argument('classes', help='Path to a CSV file containing class label mapping.')
+
+    parser.add_argument('model',              help='Path to RetinaNet model.')
+    parser.add_argument('--convert-model',    help='Convert the model to an inference model (ie. the input is a training model).', action='store_true')
+    parser.add_argument('--backbone',         help='The backbone of the model.', default='resnet50')
+    parser.add_argument('--gpu',              help='Id of the GPU to use (as reported by nvidia-smi).')
+    parser.add_argument('--score-threshold',  help='Threshold on score to filter detections with (defaults to 0.05).', default=0.05, type=float)
+    parser.add_argument('--iou-threshold',    help='IoU Threshold to count for a positive detection (defaults to 0.5).', default=0.5, type=float)
+    parser.add_argument('--max-detections',   help='Max Detections per image (defaults to 100).', default=100, type=int)
+    parser.add_argument('--save-path',        help='Path for saving images with detections (doesn\'t work for COCO).')
+    parser.add_argument('--image-min-side',   help='Rescale the image so the smallest side is min_side.', type=int, default=800)
+    parser.add_argument('--image-max-side',   help='Rescale the image if the largest side is larger than max_side.', type=int, default=1333)
+    parser.add_argument('--no-resize',        help='Don''t rescale the image.', action='store_true')
+    parser.add_argument('--config',           help='Path to a configuration parameters .ini file (only used with --convert-model).')
+    parser.add_argument('--group-method',     help='Determines how images are grouped together', type=str, default='ratio', choices=['none', 'random', 'ratio'])
+
+    return parser.parse_args(args)
+
+
+def main(args=None):
+    # parse arguments
+    if args is None:
+        args = sys.argv[1:]
+    args = parse_args(args)
+
+    # make sure tensorflow is the minimum required version
+    check_tf_version()
+
+    # optionally choose specific GPU
+    if args.gpu:
+        setup_gpu(args.gpu)
+
+    # make save path if it doesn't exist
+    if args.save_path is not None and not os.path.exists(args.save_path):
+        os.makedirs(args.save_path)
+
+    # optionally load config parameters
+    if args.config:
+        args.config = read_config_file(args.config)
+
+    # create the generator
+    backbone = models.backbone(args.backbone)
+    generator = create_generator(args, backbone.preprocess_image)
+
+    # optionally load anchor parameters
+    anchor_params = None
+    pyramid_levels = None
+    if args.config and 'anchor_parameters' in args.config:
+        anchor_params = parse_anchor_parameters(args.config)
+    if args.config and 'pyramid_levels' in args.config:
+        pyramid_levels = parse_pyramid_levels(args.config)
+
+    # load the model
+    print('Loading model, this may take a second...')
+    model = models.load_model(args.model, backbone_name=args.backbone)
+    generator.compute_shapes = make_shapes_callback(model)
+
+    # optionally convert the model
+    if args.convert_model:
+        model = models.convert_model(model, anchor_params=anchor_params, pyramid_levels=pyramid_levels)
+
+    # print model summary
+    # print(model.summary())
+
+    # start evaluation
+    if args.dataset_type == 'coco':
+        from ..utils.coco_eval import evaluate_coco
+        evaluate_coco(generator, model, args.score_threshold)
+    else:
+        average_precisions, inference_time = evaluate(
+            generator,
+            model,
+            iou_threshold=args.iou_threshold,
+            score_threshold=args.score_threshold,
+            max_detections=args.max_detections,
+            save_path=args.save_path
+        )
+
+        # print evaluation
+        total_instances = []
+        precisions = []
+        for label, (average_precision, num_annotations) in average_precisions.items():
+            print('{:.0f} instances of class'.format(num_annotations),
+                  generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision))
+            total_instances.append(num_annotations)
+            precisions.append(average_precision)
+
+        if sum(total_instances) == 0:
+            print('No test instances found.')
+            return
+
+        print('Inference time for {:.0f} images: {:.4f}'.format(generator.size(), inference_time))
+
+        print('mAP using the weighted average of precisions among classes: {:.4f}'.format(sum([a * b for a, b in zip(total_instances, precisions)]) / sum(total_instances)))
+        print('mAP: {:.4f}'.format(sum(precisions) / sum(x > 0 for x in total_instances)))
+
+
+if __name__ == '__main__':
+    main()

+from .common import *  # noqa: F401,F403

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+from ..utils.coco_eval import evaluate_coco
+
+
+class CocoEval(keras.callbacks.Callback):
+    """ Performs COCO evaluation on each epoch.
+    """
+    def __init__(self, generator, tensorboard=None, threshold=0.05):
+        """ CocoEval callback intializer.
+
+        Args
+            generator   : The generator used for creating validation data.
+            tensorboard : If given, the results will be written to tensorboard.
+            threshold   : The score threshold to use.
+        """
+        self.generator = generator
+        self.threshold = threshold
+        self.tensorboard = tensorboard
+
+        super(CocoEval, self).__init__()
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+
+        coco_tag = ['AP @[ IoU=0.50:0.95 | area=   all | maxDets=100 ]',
+                    'AP @[ IoU=0.50      | area=   all | maxDets=100 ]',
+                    'AP @[ IoU=0.75      | area=   all | maxDets=100 ]',
+                    'AP @[ IoU=0.50:0.95 | area= small | maxDets=100 ]',
+                    'AP @[ IoU=0.50:0.95 | area=medium | maxDets=100 ]',
+                    'AP @[ IoU=0.50:0.95 | area= large | maxDets=100 ]',
+                    'AR @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ]',
+                    'AR @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ]',
+                    'AR @[ IoU=0.50:0.95 | area=   all | maxDets=100 ]',
+                    'AR @[ IoU=0.50:0.95 | area= small | maxDets=100 ]',
+                    'AR @[ IoU=0.50:0.95 | area=medium | maxDets=100 ]',
+                    'AR @[ IoU=0.50:0.95 | area= large | maxDets=100 ]']
+        coco_eval_stats = evaluate_coco(self.generator, self.model, self.threshold)
+
+        if coco_eval_stats is not None:
+            for index, result in enumerate(coco_eval_stats):
+                logs[coco_tag[index]] = result
+
+            if self.tensorboard:
+                import tensorflow as tf
+                writer = tf.summary.create_file_writer(self.tensorboard.log_dir)
+                with writer.as_default():
+                    for index, result in enumerate(coco_eval_stats):
+                        tf.summary.scalar('{}. {}'.format(index + 1, coco_tag[index]), result, step=epoch)
+                    writer.flush()

+from tensorflow import keras
+
+
+class RedirectModel(keras.callbacks.Callback):
+    """Callback which wraps another callback, but executed on a different model.
+
+    ```python
+    model = keras.models.load_model('model.h5')
+    model_checkpoint = ModelCheckpoint(filepath='snapshot.h5')
+    parallel_model = multi_gpu_model(model, gpus=2)
+    parallel_model.fit(X_train, Y_train, callbacks=[RedirectModel(model_checkpoint, model)])
+    ```
+
+    Args
+        callback : callback to wrap.
+        model    : model to use when executing callbacks.
+    """
+
+    def __init__(self,
+                 callback,
+                 model):
+        super(RedirectModel, self).__init__()
+
+        self.callback = callback
+        self.redirect_model = model
+
+    def on_epoch_begin(self, epoch, logs=None):
+        self.callback.on_epoch_begin(epoch, logs=logs)
+
+    def on_epoch_end(self, epoch, logs=None):
+        self.callback.on_epoch_end(epoch, logs=logs)
+
+    def on_batch_begin(self, batch, logs=None):
+        self.callback.on_batch_begin(batch, logs=logs)
+
+    def on_batch_end(self, batch, logs=None):
+        self.callback.on_batch_end(batch, logs=logs)
+
+    def on_train_begin(self, logs=None):
+        # overwrite the model with our custom model
+        self.callback.set_model(self.redirect_model)
+
+        self.callback.on_train_begin(logs=logs)
+
+    def on_train_end(self, logs=None):
+        self.callback.on_train_end(logs=logs)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+from ..utils.eval import evaluate
+
+
+class Evaluate(keras.callbacks.Callback):
+    """ Evaluation callback for arbitrary datasets.
+    """
+
+    def __init__(
+        self,
+        generator,
+        iou_threshold=0.5,
+        score_threshold=0.05,
+        max_detections=100,
+        save_path=None,
+        tensorboard=None,
+        weighted_average=False,
+        verbose=1
+    ):
+        """ Evaluate a given dataset using a given model at the end of every epoch during training.
+
+        # Arguments
+            generator        : The generator that represents the dataset to evaluate.
+            iou_threshold    : The threshold used to consider when a detection is positive or negative.
+            score_threshold  : The score confidence threshold to use for detections.
+            max_detections   : The maximum number of detections to use per image.
+            save_path        : The path to save images with visualized detections to.
+            tensorboard      : Instance of keras.callbacks.TensorBoard used to log the mAP value.
+            weighted_average : Compute the mAP using the weighted average of precisions among classes.
+            verbose          : Set the verbosity level, by default this is set to 1.
+        """
+        self.generator       = generator
+        self.iou_threshold   = iou_threshold
+        self.score_threshold = score_threshold
+        self.max_detections  = max_detections
+        self.save_path       = save_path
+        self.tensorboard     = tensorboard
+        self.weighted_average = weighted_average
+        self.verbose         = verbose
+
+        super(Evaluate, self).__init__()
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+
+        # run evaluation
+        average_precisions, _ = evaluate(
+            self.generator,
+            self.model,
+            iou_threshold=self.iou_threshold,
+            score_threshold=self.score_threshold,
+            max_detections=self.max_detections,
+            save_path=self.save_path
+        )
+
+        # compute per class average precision
+        total_instances = []
+        precisions = []
+        for label, (average_precision, num_annotations) in average_precisions.items():
+            if self.verbose == 1:
+                print('{:.0f} instances of class'.format(num_annotations),
+                      self.generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision))
+            total_instances.append(num_annotations)
+            precisions.append(average_precision)
+        if self.weighted_average:
+            self.mean_ap = sum([a * b for a, b in zip(total_instances, precisions)]) / sum(total_instances)
+        else:
+            self.mean_ap = sum(precisions) / sum(x > 0 for x in total_instances)
+
+        if self.tensorboard:
+            import tensorflow as tf
+            writer = tf.summary.create_file_writer(self.tensorboard.log_dir)
+            with writer.as_default():
+                tf.summary.scalar("mAP", self.mean_ap, step=epoch)
+                if self.verbose == 1:
+                    for label, (average_precision, num_annotations) in average_precisions.items():
+                        tf.summary.scalar("AP_" + self.generator.label_to_name(label), average_precision, step=epoch)
+                writer.flush()
+
+        logs['mAP'] = self.mean_ap
+
+        if self.verbose == 1:
+            print('mAP: {:.4f}'.format(self.mean_ap))

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+
+import math
+
+
+class PriorProbability(keras.initializers.Initializer):
+    """ Apply a prior probability to the weights.
+    """
+
+    def __init__(self, probability=0.01):
+        self.probability = probability
+
+    def get_config(self):
+        return {
+            'probability': self.probability
+        }
+
+    def __call__(self, shape, dtype=None):
+        # set bias to -log((1 - p)/p) for foreground
+        result = keras.backend.ones(shape, dtype=dtype) * -math.log((1 - self.probability) / self.probability)
+
+        return result

+from ._misc import RegressBoxes, UpsampleLike, Anchors, ClipBoxes  # noqa: F401
+from .filter_detections import FilterDetections  # noqa: F401

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import tensorflow
+from tensorflow import keras
+from .. import backend
+from ..utils import anchors as utils_anchors
+
+import numpy as np
+
+
+class Anchors(keras.layers.Layer):
+    """ Keras layer for generating achors for a given shape.
+    """
+
+    def __init__(self, size, stride, ratios=None, scales=None, *args, **kwargs):
+        """ Initializer for an Anchors layer.
+
+        Args
+            size: The base size of the anchors to generate.
+            stride: The stride of the anchors to generate.
+            ratios: The ratios of the anchors to generate (defaults to AnchorParameters.default.ratios).
+            scales: The scales of the anchors to generate (defaults to AnchorParameters.default.scales).
+        """
+        self.size   = size
+        self.stride = stride
+        self.ratios = ratios
+        self.scales = scales
+
+        if ratios is None:
+            self.ratios  = utils_anchors.AnchorParameters.default.ratios
+        elif isinstance(ratios, list):
+            self.ratios  = np.array(ratios)
+        if scales is None:
+            self.scales  = utils_anchors.AnchorParameters.default.scales
+        elif isinstance(scales, list):
+            self.scales  = np.array(scales)
+
+        self.num_anchors = len(self.ratios) * len(self.scales)
+        self.anchors = utils_anchors.generate_anchors(
+            base_size=self.size,
+            ratios=self.ratios,
+            scales=self.scales,
+        ).astype(np.float32)
+
+        super(Anchors, self).__init__(*args, **kwargs)
+
+    def call(self, inputs, **kwargs):
+        features = inputs
+        features_shape = keras.backend.shape(features)
+
+        # generate proposals from bbox deltas and shifted anchors
+        if keras.backend.image_data_format() == 'channels_first':
+            anchors = backend.shift(features_shape[2:4], self.stride, self.anchors)
+        else:
+            anchors = backend.shift(features_shape[1:3], self.stride, self.anchors)
+        anchors = keras.backend.tile(keras.backend.expand_dims(anchors, axis=0), (features_shape[0], 1, 1))
+
+        return anchors
+
+    def compute_output_shape(self, input_shape):
+        if None not in input_shape[1:]:
+            if keras.backend.image_data_format() == 'channels_first':
+                total = np.prod(input_shape[2:4]) * self.num_anchors
+            else:
+                total = np.prod(input_shape[1:3]) * self.num_anchors
+
+            return (input_shape[0], total, 4)
+        else:
+            return (input_shape[0], None, 4)
+
+    def get_config(self):
+        config = super(Anchors, self).get_config()
+        config.update({
+            'size'   : self.size,
+            'stride' : self.stride,
+            'ratios' : self.ratios.tolist(),
+            'scales' : self.scales.tolist(),
+        })
+
+        return config
+
+
+class UpsampleLike(keras.layers.Layer):
+    """ Keras layer for upsampling a Tensor to be the same shape as another Tensor.
+    """
+
+    def call(self, inputs, **kwargs):
+        source, target = inputs
+        target_shape = keras.backend.shape(target)
+        if keras.backend.image_data_format() == 'channels_first':
+            source = tensorflow.transpose(source, (0, 2, 3, 1))
+            output = backend.resize_images(source, (target_shape[2], target_shape[3]), method='nearest')
+            output = tensorflow.transpose(output, (0, 3, 1, 2))
+            return output
+        else:
+            return backend.resize_images(source, (target_shape[1], target_shape[2]), method='nearest')
+
+    def compute_output_shape(self, input_shape):
+        if keras.backend.image_data_format() == 'channels_first':
+            return (input_shape[0][0], input_shape[0][1]) + input_shape[1][2:4]
+        else:
+            return (input_shape[0][0],) + input_shape[1][1:3] + (input_shape[0][-1],)
+
+
+class RegressBoxes(keras.layers.Layer):
+    """ Keras layer for applying regression values to boxes.
+    """
+
+    def __init__(self, mean=None, std=None, *args, **kwargs):
+        """ Initializer for the RegressBoxes layer.
+
+        Args
+            mean: The mean value of the regression values which was used for normalization.
+            std: The standard value of the regression values which was used for normalization.
+        """
+        if mean is None:
+            mean = np.array([0, 0, 0, 0])
+        if std is None:
+            std = np.array([0.2, 0.2, 0.2, 0.2])
+
+        if isinstance(mean, (list, tuple)):
+            mean = np.array(mean)
+        elif not isinstance(mean, np.ndarray):
+            raise ValueError('Expected mean to be a np.ndarray, list or tuple. Received: {}'.format(type(mean)))
+
+        if isinstance(std, (list, tuple)):
+            std = np.array(std)
+        elif not isinstance(std, np.ndarray):
+            raise ValueError('Expected std to be a np.ndarray, list or tuple. Received: {}'.format(type(std)))
+
+        self.mean = mean
+        self.std  = std
+        super(RegressBoxes, self).__init__(*args, **kwargs)
+
+    def call(self, inputs, **kwargs):
+        anchors, regression = inputs
+        return backend.bbox_transform_inv(anchors, regression, mean=self.mean, std=self.std)
+
+    def compute_output_shape(self, input_shape):
+        return input_shape[0]
+
+    def get_config(self):
+        config = super(RegressBoxes, self).get_config()
+        config.update({
+            'mean': self.mean.tolist(),
+            'std' : self.std.tolist(),
+        })
+
+        return config
+
+
+class ClipBoxes(keras.layers.Layer):
+    """ Keras layer to clip box values to lie inside a given shape.
+    """
+    def call(self, inputs, **kwargs):
+        image, boxes = inputs
+        shape = keras.backend.cast(keras.backend.shape(image), keras.backend.floatx())
+        if keras.backend.image_data_format() == 'channels_first':
+            _, _, height, width = tensorflow.unstack(shape, axis=0)
+        else:
+            _, height, width, _ = tensorflow.unstack(shape, axis=0)
+
+        x1, y1, x2, y2 = tensorflow.unstack(boxes, axis=-1)
+        x1 = tensorflow.clip_by_value(x1, 0, width  - 1)
+        y1 = tensorflow.clip_by_value(y1, 0, height - 1)
+        x2 = tensorflow.clip_by_value(x2, 0, width  - 1)
+        y2 = tensorflow.clip_by_value(y2, 0, height - 1)
+
+        return keras.backend.stack([x1, y1, x2, y2], axis=2)
+
+    def compute_output_shape(self, input_shape):
+        return input_shape[1]

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import tensorflow
+from tensorflow import keras
+from .. import backend
+
+
+def filter_detections(
+    boxes,
+    classification,
+    other                 = [],
+    class_specific_filter = True,
+    nms                   = True,
+    score_threshold       = 0.05,
+    max_detections        = 300,
+    nms_threshold         = 0.5
+):
+    """ Filter detections using the boxes and classification values.
+
+    Args
+        boxes                 : Tensor of shape (num_boxes, 4) containing the boxes in (x1, y1, x2, y2) format.
+        classification        : Tensor of shape (num_boxes, num_classes) containing the classification scores.
+        other                 : List of tensors of shape (num_boxes, ...) to filter along with the boxes and classification scores.
+        class_specific_filter : Whether to perform filtering per class, or take the best scoring class and filter those.
+        nms                   : Flag to enable/disable non maximum suppression.
+        score_threshold       : Threshold used to prefilter the boxes with.
+        max_detections        : Maximum number of detections to keep.
+        nms_threshold         : Threshold for the IoU value to determine when a box should be suppressed.
+
+    Returns
+        A list of [boxes, scores, labels, other[0], other[1], ...].
+        boxes is shaped (max_detections, 4) and contains the (x1, y1, x2, y2) of the non-suppressed boxes.
+        scores is shaped (max_detections,) and contains the scores of the predicted class.
+        labels is shaped (max_detections,) and contains the predicted label.
+        other[i] is shaped (max_detections, ...) and contains the filtered other[i] data.
+        In case there are less than max_detections detections, the tensors are padded with -1's.
+    """
+    def _filter_detections(scores, labels):
+        # threshold based on score
+        indices = tensorflow.where(keras.backend.greater(scores, score_threshold))
+
+        if nms:
+            filtered_boxes  = tensorflow.gather_nd(boxes, indices)
+            filtered_scores = keras.backend.gather(scores, indices)[:, 0]
+
+            # perform NMS
+            nms_indices = tensorflow.image.non_max_suppression(filtered_boxes, filtered_scores, max_output_size=max_detections, iou_threshold=nms_threshold)
+
+            # filter indices based on NMS
+            indices = keras.backend.gather(indices, nms_indices)
+
+        # add indices to list of all indices
+        labels = tensorflow.gather_nd(labels, indices)
+        indices = keras.backend.stack([indices[:, 0], labels], axis=1)
+
+        return indices
+
+    if class_specific_filter:
+        all_indices = []
+        # perform per class filtering
+        for c in range(int(classification.shape[1])):
+            scores = classification[:, c]
+            labels = c * tensorflow.ones((keras.backend.shape(scores)[0],), dtype='int64')
+            all_indices.append(_filter_detections(scores, labels))
+
+        # concatenate indices to single tensor
+        indices = keras.backend.concatenate(all_indices, axis=0)
+    else:
+        scores  = keras.backend.max(classification, axis    = 1)
+        labels  = keras.backend.argmax(classification, axis = 1)
+        indices = _filter_detections(scores, labels)
+
+    # select top k
+    scores              = tensorflow.gather_nd(classification, indices)
+    labels              = indices[:, 1]
+    scores, top_indices = tensorflow.nn.top_k(scores, k=keras.backend.minimum(max_detections, keras.backend.shape(scores)[0]))
+
+    # filter input using the final set of indices
+    indices             = keras.backend.gather(indices[:, 0], top_indices)
+    boxes               = keras.backend.gather(boxes, indices)
+    labels              = keras.backend.gather(labels, top_indices)
+    other_              = [keras.backend.gather(o, indices) for o in other]
+
+    # zero pad the outputs
+    pad_size = keras.backend.maximum(0, max_detections - keras.backend.shape(scores)[0])
+    boxes    = tensorflow.pad(boxes, [[0, pad_size], [0, 0]], constant_values=-1)
+    scores   = tensorflow.pad(scores, [[0, pad_size]], constant_values=-1)
+    labels   = tensorflow.pad(labels, [[0, pad_size]], constant_values=-1)
+    labels   = keras.backend.cast(labels, 'int32')
+    other_   = [tensorflow.pad(o, [[0, pad_size]] + [[0, 0] for _ in range(1, len(o.shape))], constant_values=-1) for o in other_]
+
+    # set shapes, since we know what they are
+    boxes.set_shape([max_detections, 4])
+    scores.set_shape([max_detections])
+    labels.set_shape([max_detections])
+    for o, s in zip(other_, [list(keras.backend.int_shape(o)) for o in other]):
+        o.set_shape([max_detections] + s[1:])
+
+    return [boxes, scores, labels] + other_
+
+
+class FilterDetections(keras.layers.Layer):
+    """ Keras layer for filtering detections using score threshold and NMS.
+    """
+
+    def __init__(
+        self,
+        nms                   = True,
+        class_specific_filter = True,
+        nms_threshold         = 0.5,
+        score_threshold       = 0.05,
+        max_detections        = 300,
+        parallel_iterations   = 32,
+        **kwargs
+    ):
+        """ Filters detections using score threshold, NMS and selecting the top-k detections.
+
+        Args
+            nms                   : Flag to enable/disable NMS.
+            class_specific_filter : Whether to perform filtering per class, or take the best scoring class and filter those.
+            nms_threshold         : Threshold for the IoU value to determine when a box should be suppressed.
+            score_threshold       : Threshold used to prefilter the boxes with.
+            max_detections        : Maximum number of detections to keep.
+            parallel_iterations   : Number of batch items to process in parallel.
+        """
+        self.nms                   = nms
+        self.class_specific_filter = class_specific_filter
+        self.nms_threshold         = nms_threshold
+        self.score_threshold       = score_threshold
+        self.max_detections        = max_detections
+        self.parallel_iterations   = parallel_iterations
+        super(FilterDetections, self).__init__(**kwargs)
+
+    def call(self, inputs, **kwargs):
+        """ Constructs the NMS graph.
+
+        Args
+            inputs : List of [boxes, classification, other[0], other[1], ...] tensors.
+        """
+        boxes          = inputs[0]
+        classification = inputs[1]
+        other          = inputs[2:]
+
+        # wrap nms with our parameters
+        def _filter_detections(args):
+            boxes          = args[0]
+            classification = args[1]
+            other          = args[2]
+
+            return filter_detections(
+                boxes,
+                classification,
+                other,
+                nms                   = self.nms,
+                class_specific_filter = self.class_specific_filter,
+                score_threshold       = self.score_threshold,
+                max_detections        = self.max_detections,
+                nms_threshold         = self.nms_threshold,
+            )
+
+        # call filter_detections on each batch
+        dtypes = [keras.backend.floatx(), keras.backend.floatx(), 'int32'] + [o.dtype for o in other]
+        shapes = [(self.max_detections, 4), (self.max_detections,), (self.max_detections,)]
+        shapes.extend([(self.max_detections,) + o.shape[2:] for o in other])
+        outputs = backend.map_fn(
+            _filter_detections,
+            elems=[boxes, classification, other],
+            dtype=dtypes,
+            shapes=shapes,
+            parallel_iterations=self.parallel_iterations,
+        )
+
+        return outputs
+
+    def compute_output_shape(self, input_shape):
+        """ Computes the output shapes given the input shapes.
+
+        Args
+            input_shape : List of input shapes [boxes, classification, other[0], other[1], ...].
+
+        Returns
+            List of tuples representing the output shapes:
+            [filtered_boxes.shape, filtered_scores.shape, filtered_labels.shape, filtered_other[0].shape, filtered_other[1].shape, ...]
+        """
+        return [
+            (input_shape[0][0], self.max_detections, 4),
+            (input_shape[1][0], self.max_detections),
+            (input_shape[1][0], self.max_detections),
+        ] + [
+            tuple([input_shape[i][0], self.max_detections] + list(input_shape[i][2:])) for i in range(2, len(input_shape))
+        ]
+
+    def compute_mask(self, inputs, mask=None):
+        """ This is required in Keras when there is more than 1 output.
+        """
+        return (len(inputs) + 1) * [None]
+
+    def get_config(self):
+        """ Gets the configuration of this layer.
+
+        Returns
+            Dictionary containing the parameters of this layer.
+        """
+        config = super(FilterDetections, self).get_config()
+        config.update({
+            'nms'                   : self.nms,
+            'class_specific_filter' : self.class_specific_filter,
+            'nms_threshold'         : self.nms_threshold,
+            'score_threshold'       : self.score_threshold,
+            'max_detections'        : self.max_detections,
+            'parallel_iterations'   : self.parallel_iterations,
+        })
+
+        return config

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import tensorflow
+from tensorflow import keras
+
+
+def focal(alpha=0.25, gamma=2.0, cutoff=0.5):
+    """ Create a functor for computing the focal loss.
+
+    Args
+        alpha: Scale the focal weight with alpha.
+        gamma: Take the power of the focal weight with gamma.
+        cutoff: Positive prediction cutoff for soft targets
+
+    Returns
+        A functor that computes the focal loss using the alpha and gamma.
+    """
+    def _focal(y_true, y_pred):
+        """ Compute the focal loss given the target tensor and the predicted tensor.
+
+        As defined in https://arxiv.org/abs/1708.02002
+
+        Args
+            y_true: Tensor of target data from the generator with shape (B, N, num_classes).
+            y_pred: Tensor of predicted data from the network with shape (B, N, num_classes).
+
+        Returns
+            The focal loss of y_pred w.r.t. y_true.
+        """
+        labels         = y_true[:, :, :-1]
+        anchor_state   = y_true[:, :, -1]  # -1 for ignore, 0 for background, 1 for object
+        classification = y_pred
+
+        # filter out "ignore" anchors
+        indices        = tensorflow.where(keras.backend.not_equal(anchor_state, -1))
+        labels         = tensorflow.gather_nd(labels, indices)
+        classification = tensorflow.gather_nd(classification, indices)
+
+        # compute the focal loss
+        alpha_factor = keras.backend.ones_like(labels) * alpha
+        alpha_factor = tensorflow.where(keras.backend.greater(labels, cutoff), alpha_factor, 1 - alpha_factor)
+        focal_weight = tensorflow.where(keras.backend.greater(labels, cutoff), 1 - classification, classification)
+        focal_weight = alpha_factor * focal_weight ** gamma
+
+        cls_loss = focal_weight * keras.backend.binary_crossentropy(labels, classification)
+
+        # compute the normalizer: the number of positive anchors
+        normalizer = tensorflow.where(keras.backend.equal(anchor_state, 1))
+        normalizer = keras.backend.cast(keras.backend.shape(normalizer)[0], keras.backend.floatx())
+        normalizer = keras.backend.maximum(keras.backend.cast_to_floatx(1.0), normalizer)
+
+        return keras.backend.sum(cls_loss) / normalizer
+
+    return _focal
+
+
+def smooth_l1(sigma=3.0):
+    """ Create a smooth L1 loss functor.
+
+    Args
+        sigma: This argument defines the point where the loss changes from L2 to L1.
+
+    Returns
+        A functor for computing the smooth L1 loss given target data and predicted data.
+    """
+    sigma_squared = sigma ** 2
+
+    def _smooth_l1(y_true, y_pred):
+        """ Compute the smooth L1 loss of y_pred w.r.t. y_true.
+
+        Args
+            y_true: Tensor from the generator of shape (B, N, 5). The last value for each box is the state of the anchor (ignore, negative, positive).
+            y_pred: Tensor from the network of shape (B, N, 4).
+
+        Returns
+            The smooth L1 loss of y_pred w.r.t. y_true.
+        """
+        # separate target and state
+        regression        = y_pred
+        regression_target = y_true[:, :, :-1]
+        anchor_state      = y_true[:, :, -1]
+
+        # filter out "ignore" anchors
+        indices           = tensorflow.where(keras.backend.equal(anchor_state, 1))
+        regression        = tensorflow.gather_nd(regression, indices)
+        regression_target = tensorflow.gather_nd(regression_target, indices)
+
+        # compute smooth L1 loss
+        # f(x) = 0.5 * (sigma * x)^2          if |x| < 1 / sigma / sigma
+        #        |x| - 0.5 / sigma / sigma    otherwise
+        regression_diff = regression - regression_target
+        regression_diff = keras.backend.abs(regression_diff)
+        regression_loss = tensorflow.where(
+            keras.backend.less(regression_diff, 1.0 / sigma_squared),
+            0.5 * sigma_squared * keras.backend.pow(regression_diff, 2),
+            regression_diff - 0.5 / sigma_squared
+        )
+
+        # compute the normalizer: the number of positive anchors
+        normalizer = keras.backend.maximum(1, keras.backend.shape(indices)[0])
+        normalizer = keras.backend.cast(normalizer, dtype=keras.backend.floatx())
+        return keras.backend.sum(regression_loss) / normalizer
+
+    return _smooth_l1

+from __future__ import print_function
+import sys
+
+
+class Backbone(object):
+    """ This class stores additional information on backbones.
+    """
+    def __init__(self, backbone):
+        # a dictionary mapping custom layer names to the correct classes
+        from .. import layers
+        from .. import losses
+        from .. import initializers
+        self.custom_objects = {
+            'UpsampleLike'     : layers.UpsampleLike,
+            'PriorProbability' : initializers.PriorProbability,
+            'RegressBoxes'     : layers.RegressBoxes,
+            'FilterDetections' : layers.FilterDetections,
+            'Anchors'          : layers.Anchors,
+            'ClipBoxes'        : layers.ClipBoxes,
+            '_smooth_l1'       : losses.smooth_l1(),
+            '_focal'           : losses.focal(),
+        }
+
+        self.backbone = backbone
+        self.validate()
+
+    def retinanet(self, *args, **kwargs):
+        """ Returns a retinanet model using the correct backbone.
+        """
+        raise NotImplementedError('retinanet method not implemented.')
+
+    def download_imagenet(self):
+        """ Downloads ImageNet weights and returns path to weights file.
+        """
+        raise NotImplementedError('download_imagenet method not implemented.')
+
+    def validate(self):
+        """ Checks whether the backbone string is correct.
+        """
+        raise NotImplementedError('validate method not implemented.')
+
+    def preprocess_image(self, inputs):
+        """ Takes as input an image and prepares it for being passed through the network.
+        Having this function in Backbone allows other backbones to define a specific preprocessing step.
+        """
+        raise NotImplementedError('preprocess_image method not implemented.')
+
+
+def backbone(backbone_name):
+    """ Returns a backbone object for the given backbone.
+    """
+    if 'densenet' in backbone_name:
+        from .densenet import DenseNetBackbone as b
+    elif 'seresnext' in backbone_name or 'seresnet' in backbone_name or 'senet' in backbone_name:
+        from .senet import SeBackbone as b
+    elif 'resnet' in backbone_name:
+        from .resnet import ResNetBackbone as b
+    elif 'mobilenet' in backbone_name:
+        from .mobilenet import MobileNetBackbone as b
+    elif 'vgg' in backbone_name:
+        from .vgg import VGGBackbone as b
+    elif 'EfficientNet' in backbone_name:
+        from .effnet import EfficientNetBackbone as b
+    else:
+        raise NotImplementedError('Backbone class for  \'{}\' not implemented.'.format(backbone))
+
+    return b(backbone_name)
+
+
+def load_model(filepath, backbone_name='resnet50'):
+    """ Loads a retinanet model using the correct custom objects.
+
+    Args
+        filepath: one of the following:
+            - string, path to the saved model, or
+            - h5py.File object from which to load the model
+        backbone_name         : Backbone with which the model was trained.
+
+    Returns
+        A keras.models.Model object.
+
+    Raises
+        ImportError: if h5py is not available.
+        ValueError: In case of an invalid savefile.
+    """
+    from tensorflow import keras
+    return keras.models.load_model(filepath, custom_objects=backbone(backbone_name).custom_objects)
+
+
+def convert_model(model, nms=True, class_specific_filter=True, anchor_params=None, **kwargs):
+    """ Converts a training model to an inference model.
+
+    Args
+        model                 : A retinanet training model.
+        nms                   : Boolean, whether to add NMS filtering to the converted model.
+        class_specific_filter : Whether to use class specific filtering or filter for the best scoring class only.
+        anchor_params         : Anchor parameters object. If omitted, default values are used.
+        **kwargs              : Inference and minimal retinanet model settings.
+
+    Returns
+        A keras.models.Model object.
+
+    Raises
+        ImportError: if h5py is not available.
+        ValueError: In case of an invalid savefile.
+    """
+    from .retinanet import retinanet_bbox
+    return retinanet_bbox(model=model, nms=nms, class_specific_filter=class_specific_filter, anchor_params=anchor_params, **kwargs)
+
+
+def assert_training_model(model):
+    """ Assert that the model is a training model.
+    """
+    assert(all(output in model.output_names for output in ['regression', 'classification'])), \
+        "Input is not a training model (no 'regression' and 'classification' outputs were found, outputs are: {}).".format(model.output_names)
+
+
+def check_training_model(model):
+    """ Check that model is a training model and exit otherwise.
+    """
+    try:
+        assert_training_model(model)
+    except AssertionError as e:
+        print(e, file=sys.stderr)
+        sys.exit(1)

+"""
+Copyright 2018 vidosits (https://github.com/vidosits/)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+
+from . import retinanet
+from . import Backbone
+from ..utils.image import preprocess_image
+
+
+allowed_backbones = {
+    'densenet121': ([6, 12, 24, 16], keras.applications.densenet.DenseNet121),
+    'densenet169': ([6, 12, 32, 32], keras.applications.densenet.DenseNet169),
+    'densenet201': ([6, 12, 48, 32], keras.applications.densenet.DenseNet201),
+}
+
+
+class DenseNetBackbone(Backbone):
+    """ Describes backbone information and provides utility functions.
+    """
+
+    def retinanet(self, *args, **kwargs):
+        """ Returns a retinanet model using the correct backbone.
+        """
+        return densenet_retinanet(*args, backbone=self.backbone, **kwargs)
+
+    def download_imagenet(self):
+        """ Download pre-trained weights for the specified backbone name.
+        This name is in the format {backbone}_weights_tf_dim_ordering_tf_kernels_notop
+        where backbone is the densenet + number of layers (e.g. densenet121).
+        For more info check the explanation from the keras densenet script itself:
+            https://github.com/keras-team/keras/blob/master/keras/applications/densenet.py
+        """
+        origin    = 'https://github.com/fchollet/deep-learning-models/releases/download/v0.8/'
+        file_name = '{}_weights_tf_dim_ordering_tf_kernels_notop.h5'
+
+        # load weights
+        if keras.backend.image_data_format() == 'channels_first':
+            raise ValueError('Weights for "channels_first" format are not available.')
+
+        weights_url = origin + file_name.format(self.backbone)
+        return keras.utils.get_file(file_name.format(self.backbone), weights_url, cache_subdir='models')
+
+    def validate(self):
+        """ Checks whether the backbone string is correct.
+        """
+        backbone = self.backbone.split('_')[0]
+
+        if backbone not in allowed_backbones:
+            raise ValueError('Backbone (\'{}\') not in allowed backbones ({}).'.format(backbone, allowed_backbones.keys()))
+
+    def preprocess_image(self, inputs):
+        """ Takes as input an image and prepares it for being passed through the network.
+        """
+        return preprocess_image(inputs, mode='tf')
+
+
+def densenet_retinanet(num_classes, backbone='densenet121', inputs=None, modifier=None, **kwargs):
+    """ Constructs a retinanet model using a densenet backbone.
+
+    Args
+        num_classes: Number of classes to predict.
+        backbone: Which backbone to use (one of ('densenet121', 'densenet169', 'densenet201')).
+        inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
+        modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
+
+    Returns
+        RetinaNet model with a DenseNet backbone.
+    """
+    # choose default input
+    if inputs is None:
+        inputs = keras.layers.Input((None, None, 3))
+
+    blocks, creator = allowed_backbones[backbone]
+    model = creator(input_tensor=inputs, include_top=False, pooling=None, weights=None)
+
+    # get last conv layer from the end of each dense block
+    layer_outputs = [model.get_layer(name='conv{}_block{}_concat'.format(idx + 2, block_num)).output for idx, block_num in enumerate(blocks)]
+
+    # create the densenet backbone
+    # layer_outputs contains 4 layers
+    model = keras.models.Model(inputs=inputs, outputs=layer_outputs, name=model.name)
+
+    # invoke modifier if given
+    if modifier:
+        model = modifier(model)
+
+    # create the full model
+    backbone_layers = {
+        'C2': model.outputs[0],
+        'C3': model.outputs[1],
+        'C4': model.outputs[2],
+        'C5': model.outputs[3]
+    }
+
+    model = retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=backbone_layers, **kwargs)
+
+    return model

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+
+from . import retinanet
+from . import Backbone
+import efficientnet.keras as efn
+
+
+class EfficientNetBackbone(Backbone):
+    """ Describes backbone information and provides utility functions.
+    """
+
+    def __init__(self, backbone):
+        super(EfficientNetBackbone, self).__init__(backbone)
+        self.preprocess_image_func = None
+
+    def retinanet(self, *args, **kwargs):
+        """ Returns a retinanet model using the correct backbone.
+        """
+        return effnet_retinanet(*args, backbone=self.backbone, **kwargs)
+
+    def download_imagenet(self):
+        """ Downloads ImageNet weights and returns path to weights file.
+        """
+        from efficientnet.weights import IMAGENET_WEIGHTS_PATH
+        from efficientnet.weights import IMAGENET_WEIGHTS_HASHES
+
+        model_name = 'efficientnet-b' + self.backbone[-1]
+        file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5'
+        file_hash = IMAGENET_WEIGHTS_HASHES[model_name][1]
+        weights_path = keras.utils.get_file(file_name, IMAGENET_WEIGHTS_PATH + file_name, cache_subdir='models', file_hash=file_hash)
+        return weights_path
+
+    def validate(self):
+        """ Checks whether the backbone string is correct.
+        """
+        allowed_backbones = ['EfficientNetB0', 'EfficientNetB1', 'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4',
+                             'EfficientNetB5', 'EfficientNetB6', 'EfficientNetB7']
+        backbone = self.backbone.split('_')[0]
+
+        if backbone not in allowed_backbones:
+            raise ValueError('Backbone (\'{}\') not in allowed backbones ({}).'.format(backbone, allowed_backbones))
+
+    def preprocess_image(self, inputs):
+        """ Takes as input an image and prepares it for being passed through the network.
+        """
+        return efn.preprocess_input(inputs)
+
+
+def effnet_retinanet(num_classes, backbone='EfficientNetB0', inputs=None, modifier=None, **kwargs):
+    """ Constructs a retinanet model using a resnet backbone.
+
+    Args
+        num_classes: Number of classes to predict.
+        backbone: Which backbone to use (one of ('resnet50', 'resnet101', 'resnet152')).
+        inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
+        modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
+
+    Returns
+        RetinaNet model with a ResNet backbone.
+    """
+    # choose default input
+    if inputs is None:
+        if keras.backend.image_data_format() == 'channels_first':
+            inputs = keras.layers.Input(shape=(3, None, None))
+        else:
+            # inputs = keras.layers.Input(shape=(224, 224, 3))
+            inputs = keras.layers.Input(shape=(None, None, 3))
+
+    # get last conv layer from the end of each block [28x28, 14x14, 7x7]
+    if backbone == 'EfficientNetB0':
+        model = efn.EfficientNetB0(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB1':
+        model = efn.EfficientNetB1(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB2':
+        model = efn.EfficientNetB2(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB3':
+        model = efn.EfficientNetB3(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB4':
+        model = efn.EfficientNetB4(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB5':
+        model = efn.EfficientNetB5(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB6':
+        model = efn.EfficientNetB6(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'EfficientNetB7':
+        model = efn.EfficientNetB7(input_tensor=inputs, include_top=False, weights=None)
+    else:
+        raise ValueError('Backbone (\'{}\') is invalid.'.format(backbone))
+
+    layer_outputs = ['block4a_expand_activation', 'block6a_expand_activation', 'top_activation']
+
+    layer_outputs = [
+        model.get_layer(name=layer_outputs[0]).output,  # 28x28
+        model.get_layer(name=layer_outputs[1]).output,  # 14x14
+        model.get_layer(name=layer_outputs[2]).output,  # 7x7
+    ]
+    # create the densenet backbone
+    model = keras.models.Model(inputs=inputs, outputs=layer_outputs, name=model.name)
+
+    # invoke modifier if given
+    if modifier:
+        model = modifier(model)
+
+    # C2 not provided
+    backbone_layers = {
+        'C3': model.outputs[0],
+        'C4': model.outputs[1],
+        'C5': model.outputs[2]
+    }
+
+    # create the full model
+    return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=backbone_layers, **kwargs)
+
+
+def EfficientNetB0_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB0', inputs=inputs, **kwargs)
+
+
+def EfficientNetB1_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB1', inputs=inputs, **kwargs)
+
+
+def EfficientNetB2_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB2', inputs=inputs, **kwargs)
+
+
+def EfficientNetB3_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB3', inputs=inputs, **kwargs)
+
+
+def EfficientNetB4_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB4', inputs=inputs, **kwargs)
+
+
+def EfficientNetB5_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB5', inputs=inputs, **kwargs)
+
+
+def EfficientNetB6_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB6', inputs=inputs, **kwargs)
+
+
+def EfficientNetB7_retinanet(num_classes, inputs=None, **kwargs):
+    return effnet_retinanet(num_classes=num_classes, backbone='EfficientNetB7', inputs=inputs, **kwargs)

+"""
+Copyright 2017-2018 lvaleriu (https://github.com/lvaleriu/)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+from ..utils.image import preprocess_image
+
+from . import retinanet
+from . import Backbone
+
+
+class MobileNetBackbone(Backbone):
+    """ Describes backbone information and provides utility functions.
+    """
+
+    allowed_backbones = ['mobilenet128', 'mobilenet160', 'mobilenet192', 'mobilenet224']
+
+    def retinanet(self, *args, **kwargs):
+        """ Returns a retinanet model using the correct backbone.
+        """
+        return mobilenet_retinanet(*args, backbone=self.backbone, **kwargs)
+
+    def download_imagenet(self):
+        """ Download pre-trained weights for the specified backbone name.
+        This name is in the format mobilenet{rows}_{alpha} where rows is the
+        imagenet shape dimension and 'alpha' controls the width of the network.
+        For more info check the explanation from the keras mobilenet script itself.
+        """
+
+        alpha = float(self.backbone.split('_')[1])
+        rows = int(self.backbone.split('_')[0].replace('mobilenet', ''))
+
+        # load weights
+        if keras.backend.image_data_format() == 'channels_first':
+            raise ValueError('Weights for "channels_last" format '
+                             'are not available.')
+        if alpha == 1.0:
+            alpha_text = '1_0'
+        elif alpha == 0.75:
+            alpha_text = '7_5'
+        elif alpha == 0.50:
+            alpha_text = '5_0'
+        else:
+            alpha_text = '2_5'
+
+        model_name = 'mobilenet_{}_{}_tf_no_top.h5'.format(alpha_text, rows)
+        weights_url = 'https://github.com/fchollet/deep-learning-models/releases/download/v0.6/' + model_name
+        weights_path = keras.utils.get_file(model_name, weights_url, cache_subdir='models')
+
+        return weights_path
+
+    def validate(self):
+        """ Checks whether the backbone string is correct.
+        """
+        backbone = self.backbone.split('_')[0]
+
+        if backbone not in MobileNetBackbone.allowed_backbones:
+            raise ValueError('Backbone (\'{}\') not in allowed backbones ({}).'.format(backbone, MobileNetBackbone.allowed_backbones))
+
+    def preprocess_image(self, inputs):
+        """ Takes as input an image and prepares it for being passed through the network.
+        """
+        return preprocess_image(inputs, mode='tf')
+
+
+def mobilenet_retinanet(num_classes, backbone='mobilenet224_1.0', inputs=None, modifier=None, **kwargs):
+    """ Constructs a retinanet model using a mobilenet backbone.
+
+    Args
+        num_classes: Number of classes to predict.
+        backbone: Which backbone to use (one of ('mobilenet128', 'mobilenet160', 'mobilenet192', 'mobilenet224')).
+        inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
+        modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
+
+    Returns
+        RetinaNet model with a MobileNet backbone.
+    """
+    alpha = float(backbone.split('_')[1])
+
+    # choose default input
+    if inputs is None:
+        inputs = keras.layers.Input((None, None, 3))
+
+    backbone = keras.applications.mobilenet.MobileNet(input_tensor=inputs, alpha=alpha, include_top=False, pooling=None, weights=None)
+
+    # create the full model
+    layer_names = ['conv_pw_5_relu', 'conv_pw_11_relu', 'conv_pw_13_relu']
+    layer_outputs = [backbone.get_layer(name).output for name in layer_names]
+    backbone = keras.models.Model(inputs=inputs, outputs=layer_outputs, name=backbone.name)
+
+    # invoke modifier if given
+    if modifier:
+        backbone = modifier(backbone)
+
+    # C2 not provided
+    backbone_layers = {
+        'C3': backbone.outputs[0],
+        'C4': backbone.outputs[1],
+        'C5': backbone.outputs[2]
+    }
+
+    return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=backbone_layers, **kwargs)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+import keras_resnet
+import keras_resnet.models
+
+from . import retinanet
+from . import Backbone
+from ..utils.image import preprocess_image
+
+
+class ResNetBackbone(Backbone):
+    """Describes backbone information and provides utility functions."""
+
+    def __init__(self, backbone):
+        super(ResNetBackbone, self).__init__(backbone)
+        self.custom_objects.update(keras_resnet.custom_objects)
+
+    def retinanet(self, *args, **kwargs):
+        """Returns a retinanet model using the correct backbone."""
+        return resnet_retinanet(*args, backbone=self.backbone, **kwargs)
+
+    def download_imagenet(self):
+        """Downloads ImageNet weights and returns path to weights file."""
+        resnet_filename = "ResNet-{}-model.keras.h5"
+        resnet_resource = (
+            "https://github.com/fizyr/keras-models/releases/download/v0.0.1/{}".format(
+                resnet_filename
+            )
+        )
+        depth = int(self.backbone.replace("resnet", ""))
+
+        filename = resnet_filename.format(depth)
+        resource = resnet_resource.format(depth)
+        if depth == 50:
+            checksum = "3e9f4e4f77bbe2c9bec13b53ee1c2319"
+        elif depth == 101:
+            checksum = "05dc86924389e5b401a9ea0348a3213c"
+        elif depth == 152:
+            checksum = "6ee11ef2b135592f8031058820bb9e71"
+
+        return keras.utils.get_file(
+            filename, resource, cache_subdir="models", md5_hash=checksum
+        )
+
+    def validate(self):
+        """Checks whether the backbone string is correct."""
+        allowed_backbones = ["resnet50", "resnet101", "resnet152"]
+        backbone = self.backbone.split("_")[0]
+
+        if backbone not in allowed_backbones:
+            raise ValueError(
+                "Backbone ('{}') not in allowed backbones ({}).".format(
+                    backbone, allowed_backbones
+                )
+            )
+
+    def preprocess_image(self, inputs):
+        """Takes as input an image and prepares it for being passed through the network."""
+        return preprocess_image(inputs, mode="caffe")
+
+
+def resnet_retinanet(
+    num_classes, backbone="resnet50", inputs=None, modifier=None, **kwargs
+):
+    """Constructs a retinanet model using a resnet backbone.
+
+    Args
+        num_classes: Number of classes to predict.
+        backbone: Which backbone to use (one of ('resnet50', 'resnet101', 'resnet152')).
+        inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
+        modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
+
+    Returns
+        RetinaNet model with a ResNet backbone.
+    """
+    # choose default input
+    if inputs is None:
+        if keras.backend.image_data_format() == "channels_first":
+            inputs = keras.layers.Input(shape=(3, None, None))
+        else:
+            inputs = keras.layers.Input(shape=(None, None, 3))
+
+    # create the resnet backbone
+    if backbone == "resnet50":
+        resnet = keras_resnet.models.ResNet50(inputs, include_top=False, freeze_bn=True)
+    elif backbone == "resnet101":
+        resnet = keras_resnet.models.ResNet101(
+            inputs, include_top=False, freeze_bn=True
+        )
+    elif backbone == "resnet152":
+        resnet = keras_resnet.models.ResNet152(
+            inputs, include_top=False, freeze_bn=True
+        )
+    else:
+        raise ValueError("Backbone ('{}') is invalid.".format(backbone))
+
+    # invoke modifier if given
+    if modifier:
+        resnet = modifier(resnet)
+
+    # create the full model
+    # resnet.outputs contains 4 layers
+    backbone_layers = {
+        "C2": resnet.outputs[0],
+        "C3": resnet.outputs[1],
+        "C4": resnet.outputs[2],
+        "C5": resnet.outputs[3],
+    }
+
+    return retinanet.retinanet(
+        inputs=inputs,
+        num_classes=num_classes,
+        backbone_layers=backbone_layers,
+        **kwargs
+    )
+
+
+def resnet50_retinanet(num_classes, inputs=None, **kwargs):
+    return resnet_retinanet(
+        num_classes=num_classes, backbone="resnet50", inputs=inputs, **kwargs
+    )
+
+
+def resnet101_retinanet(num_classes, inputs=None, **kwargs):
+    return resnet_retinanet(
+        num_classes=num_classes, backbone="resnet101", inputs=inputs, **kwargs
+    )
+
+
+def resnet152_retinanet(num_classes, inputs=None, **kwargs):
+    return resnet_retinanet(
+        num_classes=num_classes, backbone="resnet152", inputs=inputs, **kwargs
+    )

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+
+from . import retinanet
+from . import Backbone
+from classification_models.keras import Classifiers
+
+
+class SeBackbone(Backbone):
+    """ Describes backbone information and provides utility functions.
+    """
+
+    def __init__(self, backbone):
+        super(SeBackbone, self).__init__(backbone)
+        _, self.preprocess_image_func = Classifiers.get(self.backbone)
+
+    def retinanet(self, *args, **kwargs):
+        """ Returns a retinanet model using the correct backbone.
+        """
+        return senet_retinanet(*args, backbone=self.backbone, **kwargs)
+
+    def download_imagenet(self):
+        """ Downloads ImageNet weights and returns path to weights file.
+        """
+        from classification_models.weights import WEIGHTS_COLLECTION
+
+        weights_path = None
+        for el in WEIGHTS_COLLECTION:
+            if el['model'] == self.backbone and not el['include_top']:
+                weights_path = keras.utils.get_file(el['name'], el['url'], cache_subdir='models', file_hash=el['md5'])
+
+        if weights_path is None:
+            raise ValueError('Unable to find imagenet weights for backbone {}!'.format(self.backbone))
+
+        return weights_path
+
+    def validate(self):
+        """ Checks whether the backbone string is correct.
+        """
+        allowed_backbones = ['seresnet18', 'seresnet34', 'seresnet50', 'seresnet101', 'seresnet152',
+                             'seresnext50', 'seresnext101', 'senet154']
+        backbone = self.backbone.split('_')[0]
+
+        if backbone not in allowed_backbones:
+            raise ValueError('Backbone (\'{}\') not in allowed backbones ({}).'.format(backbone, allowed_backbones))
+
+    def preprocess_image(self, inputs):
+        """ Takes as input an image and prepares it for being passed through the network.
+        """
+        return self.preprocess_image_func(inputs)
+
+
+def senet_retinanet(num_classes, backbone='seresnext50', inputs=None, modifier=None, **kwargs):
+    """ Constructs a retinanet model using a resnet backbone.
+
+    Args
+        num_classes: Number of classes to predict.
+        backbone: Which backbone to use (one of ('resnet50', 'resnet101', 'resnet152')).
+        inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
+        modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
+
+    Returns
+        RetinaNet model with a ResNet backbone.
+    """
+    # choose default input
+    if inputs is None:
+        if keras.backend.image_data_format() == 'channels_first':
+            inputs = keras.layers.Input(shape=(3, None, None))
+        else:
+            # inputs = keras.layers.Input(shape=(224, 224, 3))
+            inputs = keras.layers.Input(shape=(None, None, 3))
+
+    classifier, _ = Classifiers.get(backbone)
+    model = classifier(input_tensor=inputs, include_top=False, weights=None)
+
+    # get last conv layer from the end of each block [28x28, 14x14, 7x7]
+    if backbone == 'seresnet18' or backbone == 'seresnet34':
+        layer_outputs = ['stage3_unit1_relu1', 'stage4_unit1_relu1', 'relu1']
+    elif backbone == 'seresnet50':
+        layer_outputs = ['activation_36', 'activation_66', 'activation_81']
+    elif backbone == 'seresnet101':
+        layer_outputs = ['activation_36', 'activation_151', 'activation_166']
+    elif backbone == 'seresnet152':
+        layer_outputs = ['activation_56', 'activation_236', 'activation_251']
+    elif backbone == 'seresnext50':
+        layer_outputs = ['activation_37', 'activation_67', 'activation_81']
+    elif backbone == 'seresnext101':
+        layer_outputs = ['activation_37', 'activation_152', 'activation_166']
+    elif backbone == 'senet154':
+        layer_outputs = ['activation_59', 'activation_239', 'activation_253']
+    else:
+        raise ValueError('Backbone (\'{}\') is invalid.'.format(backbone))
+
+    layer_outputs = [
+        model.get_layer(name=layer_outputs[0]).output,  # 28x28
+        model.get_layer(name=layer_outputs[1]).output,  # 14x14
+        model.get_layer(name=layer_outputs[2]).output,  # 7x7
+    ]
+    # create the densenet backbone
+    model = keras.models.Model(inputs=inputs, outputs=layer_outputs, name=model.name)
+
+    # invoke modifier if given
+    if modifier:
+        model = modifier(model)
+
+    # C2 not provided
+    backbone_layers = {
+        'C3': model.outputs[0],
+        'C4': model.outputs[1],
+        'C5': model.outputs[2]
+    }
+
+    # create the full model
+    return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=backbone_layers, **kwargs)
+
+
+def seresnet18_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnet18', inputs=inputs, **kwargs)
+
+
+def seresnet34_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnet34', inputs=inputs, **kwargs)
+
+
+def seresnet50_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnet50', inputs=inputs, **kwargs)
+
+
+def seresnet101_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnet101', inputs=inputs, **kwargs)
+
+
+def seresnet152_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnet152', inputs=inputs, **kwargs)
+
+
+def seresnext50_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnext50', inputs=inputs, **kwargs)
+
+
+def seresnext101_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='seresnext101', inputs=inputs, **kwargs)
+
+
+def senet154_retinanet(num_classes, inputs=None, **kwargs):
+    return senet_retinanet(num_classes=num_classes, backbone='senet154', inputs=inputs, **kwargs)

+from tensorflow import keras
+from .. import initializers
+from .. import layers
+from ..utils.anchors import AnchorParameters
+from . import assert_training_model
+from . import retinanet
+
+def custom_classification_model(
+    num_classes,
+    num_anchors,
+    pyramid_feature_size=256,
+    prior_probability=0.01,
+    classification_feature_size=256,
+    name='classification_submodel'
+):
+     # set input
+    if keras.backend.image_data_format() == "channels_first":
+        inputs = keras.layers.Input(shape=(pyramid_feature_size, None, None))
+    else:
+        inputs = keras.layers.Input(shape=(None, None, pyramid_feature_size))
+
+    outputs = inputs
+
+    # 3 layer
+    for i in range(3):
+
+        # 각 층의 output
+        outputs = keras.layers.Conv2D(
+            filters=classification_feature_size,
+            activation="relu",
+            name="pyramid_classification_{}".format(i),
+            kernel_initializer=keras.initializers.RandomNormal(
+                mean=0.0, stddev=0.01, seed=None
+            ),  # 정규분포에 따라 텐서를 생성하는 초기값 설정
+            bias_initializer="zeros",
+            **options
+        )(outputs)
+
+    # 마지막 layer는 다른 필터로 다른 conv layer를 생성
+    outputs = keras.layers.Conv2D(
+        filters=num_classes * num_anchors,
+        kernel_initializer=keras.initializers.RandomNormal(
+            mean=0.0, stddev=0.01, seed=None
+        ),
+        bias_initializer=initializers.PriorProbability(probability=prior_probability),
+        name="pyramid_classification",
+        **options
+    )(outputs)
+
+    # reshape output and apply sigmoid
+    if keras.backend.image_data_format() == "channels_first":
+        outputs = keras.layers.Permute(
+            (2, 3, 1), name="pyramid_classification_permute"
+        )(outputs)
+
+    # reshape : 2차원 > 1차원
+    outputs = keras.layers.Reshape(
+        (-1, num_classes), name="pyramid_classification_reshape"
+    )(outputs)
+
+    # output layer activation : sigmoid
+    outputs = keras.layers.Activation("sigmoid", name="pyramid_classification_sigmoid")(
+        outputs
+    )
+
+    return keras.models.Model(inputs=inputs, outputs=outputs, name=name)
+
+def custom_regression_model(num_values, num_anchors, pyramid_feature_size=256, regression_feature_size=256, name='regression_submodel'):
+    if num_anchors is None:
+        num_anchors = AnchorParameters.default.num_anchors()
+    model = retinanet.default_regression_model(num_values, num_anchors, pyramid_feature_size, regression_feature_size, name)
+    return model
+
+
+def custom_submodels(num_classes, num_anchors):
+    if num_anchors is None:
+        num_anchors = AnchorParameters.default.num_anchors()
+    return [
+        ("regression", custom_regression_model(4, num_anchors)),
+        ("classification", custom_classification_model(num_classes, num_anchors)),
+    ]
+
+
+

+"""
+Copyright 2017-2018 cgratie (https://github.com/cgratie/)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+
+from tensorflow import keras
+
+from . import retinanet
+from . import Backbone
+from ..utils.image import preprocess_image
+
+
+class VGGBackbone(Backbone):
+    """ Describes backbone information and provides utility functions.
+    """
+
+    def retinanet(self, *args, **kwargs):
+        """ Returns a retinanet model using the correct backbone.
+        """
+        return vgg_retinanet(*args, backbone=self.backbone, **kwargs)
+
+    def download_imagenet(self):
+        """ Downloads ImageNet weights and returns path to weights file.
+        Weights can be downloaded at https://github.com/fizyr/keras-models/releases .
+        """
+        if self.backbone == 'vgg16':
+            resource = keras.applications.vgg16.vgg16.WEIGHTS_PATH_NO_TOP
+            checksum = '6d6bbae143d832006294945121d1f1fc'
+        elif self.backbone == 'vgg19':
+            resource = keras.applications.vgg19.vgg19.WEIGHTS_PATH_NO_TOP
+            checksum = '253f8cb515780f3b799900260a226db6'
+        else:
+            raise ValueError("Backbone '{}' not recognized.".format(self.backbone))
+
+        return keras.utils.get_file(
+            '{}_weights_tf_dim_ordering_tf_kernels_notop.h5'.format(self.backbone),
+            resource,
+            cache_subdir='models',
+            file_hash=checksum
+        )
+
+    def validate(self):
+        """ Checks whether the backbone string is correct.
+        """
+        allowed_backbones = ['vgg16', 'vgg19']
+
+        if self.backbone not in allowed_backbones:
+            raise ValueError('Backbone (\'{}\') not in allowed backbones ({}).'.format(self.backbone, allowed_backbones))
+
+    def preprocess_image(self, inputs):
+        """ Takes as input an image and prepares it for being passed through the network.
+        """
+        return preprocess_image(inputs, mode='caffe')
+
+
+def vgg_retinanet(num_classes, backbone='vgg16', inputs=None, modifier=None, **kwargs):
+    """ Constructs a retinanet model using a vgg backbone.
+
+    Args
+        num_classes: Number of classes to predict.
+        backbone: Which backbone to use (one of ('vgg16', 'vgg19')).
+        inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
+        modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
+
+    Returns
+        RetinaNet model with a VGG backbone.
+    """
+    # choose default input
+    if inputs is None:
+        inputs = keras.layers.Input(shape=(None, None, 3))
+
+    # create the vgg backbone
+    if backbone == 'vgg16':
+        vgg = keras.applications.VGG16(input_tensor=inputs, include_top=False, weights=None)
+    elif backbone == 'vgg19':
+        vgg = keras.applications.VGG19(input_tensor=inputs, include_top=False, weights=None)
+    else:
+        raise ValueError("Backbone '{}' not recognized.".format(backbone))
+
+    if modifier:
+        vgg = modifier(vgg)
+
+    # create the full model
+    layer_names = ["block3_pool", "block4_pool", "block5_pool"]
+    layer_outputs = [vgg.get_layer(name).output for name in layer_names]
+
+    # C2 not provided
+    backbone_layers = {
+        'C3': layer_outputs[0],
+        'C4': layer_outputs[1],
+        'C5': layer_outputs[2]
+    }
+
+    return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=backbone_layers, **kwargs)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from ..preprocessing.generator import Generator
+from ..utils.image import read_image_bgr
+
+import os
+import numpy as np
+
+from pycocotools.coco import COCO
+
+
+class CocoGenerator(Generator):
+    """ Generate data from the COCO dataset.
+
+    See https://github.com/cocodataset/cocoapi/tree/master/PythonAPI for more information.
+    """
+
+    def __init__(self, data_dir, set_name, **kwargs):
+        """ Initialize a COCO data generator.
+
+        Args
+            data_dir: Path to where the COCO dataset is stored.
+            set_name: Name of the set to parse.
+        """
+        self.data_dir  = data_dir
+        self.set_name  = set_name
+        self.coco      = COCO(os.path.join(data_dir, 'annotations', 'instances_' + set_name + '.json'))
+        self.image_ids = self.coco.getImgIds()
+
+        self.load_classes()
+
+        super(CocoGenerator, self).__init__(**kwargs)
+
+    def load_classes(self):
+        """ Loads the class to label mapping (and inverse) for COCO.
+        """
+        # load class names (name -> label)
+        categories = self.coco.loadCats(self.coco.getCatIds())
+        categories.sort(key=lambda x: x['id'])
+
+        self.classes             = {}
+        self.coco_labels         = {}
+        self.coco_labels_inverse = {}
+        for c in categories:
+            self.coco_labels[len(self.classes)] = c['id']
+            self.coco_labels_inverse[c['id']] = len(self.classes)
+            self.classes[c['name']] = len(self.classes)
+
+        # also load the reverse (label -> name)
+        self.labels = {}
+        for key, value in self.classes.items():
+            self.labels[value] = key
+
+    def size(self):
+        """ Size of the COCO dataset.
+        """
+        return len(self.image_ids)
+
+    def num_classes(self):
+        """ Number of classes in the dataset. For COCO this is 80.
+        """
+        return len(self.classes)
+
+    def has_label(self, label):
+        """ Return True if label is a known label.
+        """
+        return label in self.labels
+
+    def has_name(self, name):
+        """ Returns True if name is a known class.
+        """
+        return name in self.classes
+
+    def name_to_label(self, name):
+        """ Map name to label.
+        """
+        return self.classes[name]
+
+    def label_to_name(self, label):
+        """ Map label to name.
+        """
+        return self.labels[label]
+
+    def coco_label_to_label(self, coco_label):
+        """ Map COCO label to the label as used in the network.
+        COCO has some gaps in the order of labels. The highest label is 90, but there are 80 classes.
+        """
+        return self.coco_labels_inverse[coco_label]
+
+    def coco_label_to_name(self, coco_label):
+        """ Map COCO label to name.
+        """
+        return self.label_to_name(self.coco_label_to_label(coco_label))
+
+    def label_to_coco_label(self, label):
+        """ Map label as used by the network to labels as used by COCO.
+        """
+        return self.coco_labels[label]
+
+    def image_path(self, image_index):
+        """ Returns the image path for image_index.
+        """
+        image_info = self.coco.loadImgs(self.image_ids[image_index])[0]
+        path       = os.path.join(self.data_dir, 'images', self.set_name, image_info['file_name'])
+        return path
+
+    def image_aspect_ratio(self, image_index):
+        """ Compute the aspect ratio for an image with image_index.
+        """
+        image = self.coco.loadImgs(self.image_ids[image_index])[0]
+        return float(image['width']) / float(image['height'])
+
+    def load_image(self, image_index):
+        """ Load an image at the image_index.
+        """
+        path  = self.image_path(image_index)
+        return read_image_bgr(path)
+
+    def load_annotations(self, image_index):
+        """ Load annotations for an image_index.
+        """
+        # get ground truth annotations
+        annotations_ids = self.coco.getAnnIds(imgIds=self.image_ids[image_index], iscrowd=False)
+        annotations     = {'labels': np.empty((0,)), 'bboxes': np.empty((0, 4))}
+
+        # some images appear to miss annotations (like image with id 257034)
+        if len(annotations_ids) == 0:
+            return annotations
+
+        # parse annotations
+        coco_annotations = self.coco.loadAnns(annotations_ids)
+        for idx, a in enumerate(coco_annotations):
+            # some annotations have basically no width / height, skip them
+            if a['bbox'][2] < 1 or a['bbox'][3] < 1:
+                continue
+
+            annotations['labels'] = np.concatenate([annotations['labels'], [self.coco_label_to_label(a['category_id'])]], axis=0)
+            annotations['bboxes'] = np.concatenate([annotations['bboxes'], [[
+                a['bbox'][0],
+                a['bbox'][1],
+                a['bbox'][0] + a['bbox'][2],
+                a['bbox'][1] + a['bbox'][3],
+            ]]], axis=0)
+
+        return annotations

+"""
+Copyright 2017-2018 yhenon (https://github.com/yhenon/)
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from .generator import Generator
+from ..utils.image import read_image_bgr
+
+import numpy as np
+from PIL import Image
+from six import raise_from
+
+import csv
+import sys
+import os.path
+from collections import OrderedDict
+
+
+def _parse(value, function, fmt):
+    """
+    Parse a string into a value, and format a nice ValueError if it fails.
+
+    Returns `function(value)`.
+    Any `ValueError` raised is catched and a new `ValueError` is raised
+    with message `fmt.format(e)`, where `e` is the caught `ValueError`.
+    """
+    try:
+        return function(value)
+    except ValueError as e:
+        raise_from(ValueError(fmt.format(e)), None)
+
+
+def _read_classes(csv_reader):
+    """ Parse the classes file given by csv_reader.
+    """
+    result = OrderedDict()
+    for line, row in enumerate(csv_reader):
+        line += 1
+
+        try:
+            class_name, class_id = row
+        except ValueError:
+            raise_from(ValueError('line {}: format should be \'class_name,class_id\''.format(line)), None)
+        class_id = _parse(class_id, int, 'line {}: malformed class ID: {{}}'.format(line))
+
+        if class_name in result:
+            raise ValueError('line {}: duplicate class name: \'{}\''.format(line, class_name))
+        result[class_name] = class_id
+    return result
+
+
+def _read_annotations(csv_reader, classes):
+    """ Read annotations from the csv_reader.
+    """
+    result = OrderedDict()
+    for line, row in enumerate(csv_reader):
+        line += 1
+
+        try:
+            img_file, x1, y1, x2, y2, class_name = row[:6]
+        except ValueError:
+            raise_from(ValueError('line {}: format should be \'img_file,x1,y1,x2,y2,class_name\' or \'img_file,,,,,\''.format(line)), None)
+
+        if img_file not in result:
+            result[img_file] = []
+
+        # If a row contains only an image path, it's an image without annotations.
+        if (x1, y1, x2, y2, class_name) == ('', '', '', '', ''):
+            continue
+
+        x1 = _parse(x1, int, 'line {}: malformed x1: {{}}'.format(line))
+        y1 = _parse(y1, int, 'line {}: malformed y1: {{}}'.format(line))
+        x2 = _parse(x2, int, 'line {}: malformed x2: {{}}'.format(line))
+        y2 = _parse(y2, int, 'line {}: malformed y2: {{}}'.format(line))
+
+        # Check that the bounding box is valid.
+        if x2 <= x1:
+            raise ValueError('line {}: x2 ({}) must be higher than x1 ({})'.format(line, x2, x1))
+        if y2 <= y1:
+            raise ValueError('line {}: y2 ({}) must be higher than y1 ({})'.format(line, y2, y1))
+
+        # check if the current class name is correctly present
+        if class_name not in classes:
+            raise ValueError('line {}: unknown class name: \'{}\' (classes: {})'.format(line, class_name, classes))
+
+        result[img_file].append({'x1': x1, 'x2': x2, 'y1': y1, 'y2': y2, 'class': class_name})
+    return result
+
+
+def _open_for_csv(path):
+    """ Open a file with flags suitable for csv.reader.
+
+    This is different for python2 it means with mode 'rb',
+    for python3 this means 'r' with "universal newlines".
+    """
+    if sys.version_info[0] < 3:
+        return open(path, 'rb')
+    else:
+        return open(path, 'r', newline='')
+
+
+class CSVGenerator(Generator):
+    """ Generate data for a custom CSV dataset.
+
+    See https://github.com/fizyr/keras-retinanet#csv-datasets for more information.
+    """
+
+    def __init__(
+        self,
+        csv_data_file,
+        csv_class_file,
+        base_dir=None,
+        **kwargs
+    ):
+        """ Initialize a CSV data generator.
+
+        Args
+            csv_data_file: Path to the CSV annotations file.
+            csv_class_file: Path to the CSV classes file.
+            base_dir: Directory w.r.t. where the files are to be searched (defaults to the directory containing the csv_data_file).
+        """
+        self.image_names = []
+        self.image_data  = {}
+        self.base_dir    = base_dir
+
+        # Take base_dir from annotations file if not explicitly specified.
+        if self.base_dir is None:
+            self.base_dir = os.path.dirname(csv_data_file)
+
+        # parse the provided class file
+        try:
+            with _open_for_csv(csv_class_file) as file:
+                self.classes = _read_classes(csv.reader(file, delimiter=','))
+        except ValueError as e:
+            raise_from(ValueError('invalid CSV class file: {}: {}'.format(csv_class_file, e)), None)
+
+        self.labels = {}
+        for key, value in self.classes.items():
+            self.labels[value] = key
+
+        # csv with img_path, x1, y1, x2, y2, class_name
+        try:
+            with _open_for_csv(csv_data_file) as file:
+                self.image_data = _read_annotations(csv.reader(file, delimiter=','), self.classes)
+        except ValueError as e:
+            raise_from(ValueError('invalid CSV annotations file: {}: {}'.format(csv_data_file, e)), None)
+        self.image_names = list(self.image_data.keys())
+
+        super(CSVGenerator, self).__init__(**kwargs)
+
+    def size(self):
+        """ Size of the dataset.
+        """
+        return len(self.image_names)
+
+    def num_classes(self):
+        """ Number of classes in the dataset.
+        """
+        return max(self.classes.values()) + 1
+
+    def has_label(self, label):
+        """ Return True if label is a known label.
+        """
+        return label in self.labels
+
+    def has_name(self, name):
+        """ Returns True if name is a known class.
+        """
+        return name in self.classes
+
+    def name_to_label(self, name):
+        """ Map name to label.
+        """
+        return self.classes[name]
+
+    def label_to_name(self, label):
+        """ Map label to name.
+        """
+        return self.labels[label]
+
+    def image_path(self, image_index):
+        """ Returns the image path for image_index.
+        """
+        return os.path.join(self.base_dir, self.image_names[image_index])
+
+    def image_aspect_ratio(self, image_index):
+        """ Compute the aspect ratio for an image with image_index.
+        """
+        # PIL is fast for metadata
+        image = Image.open(self.image_path(image_index))
+        return float(image.width) / float(image.height)
+
+    def load_image(self, image_index):
+        """ Load an image at the image_index.
+        """
+        return read_image_bgr(self.image_path(image_index))
+
+    def load_annotations(self, image_index):
+        """ Load annotations for an image_index.
+        """
+        path        = self.image_names[image_index]
+        annotations = {'labels': np.empty((0,)), 'bboxes': np.empty((0, 4))}
+
+        for idx, annot in enumerate(self.image_data[path]):
+            annotations['labels'] = np.concatenate((annotations['labels'], [self.name_to_label(annot['class'])]))
+            annotations['bboxes'] = np.concatenate((annotations['bboxes'], [[
+                float(annot['x1']),
+                float(annot['y1']),
+                float(annot['x2']),
+                float(annot['y2']),
+            ]]))
+
+        return annotations

+"""
+Copyright 2017-2018 lvaleriu (https://github.com/lvaleriu/)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import csv
+import os.path
+
+import numpy as np
+from PIL import Image
+
+from .generator import Generator
+from ..utils.image import read_image_bgr
+
+kitti_classes = {
+    'Car': 0,
+    'Van': 1,
+    'Truck': 2,
+    'Pedestrian': 3,
+    'Person_sitting': 4,
+    'Cyclist': 5,
+    'Tram': 6,
+    'Misc': 7,
+    'DontCare': 7
+}
+
+
+class KittiGenerator(Generator):
+    """ Generate data for a KITTI dataset.
+
+    See http://www.cvlibs.net/datasets/kitti/ for more information.
+    """
+
+    def __init__(
+        self,
+        base_dir,
+        subset='train',
+        **kwargs
+    ):
+        """ Initialize a KITTI data generator.
+
+        Args
+            base_dir: Directory w.r.t. where the files are to be searched (defaults to the directory containing the csv_data_file).
+            subset: The subset to generate data for (defaults to 'train').
+        """
+        self.base_dir = base_dir
+
+        label_dir = os.path.join(self.base_dir, subset, 'labels')
+        image_dir = os.path.join(self.base_dir, subset, 'images')
+
+        """
+        1    type         Describes the type of object: 'Car', 'Van', 'Truck',
+                             'Pedestrian', 'Person_sitting', 'Cyclist', 'Tram',
+                             'Misc' or 'DontCare'
+        1    truncated    Float from 0 (non-truncated) to 1 (truncated), where
+                         truncated refers to the object leaving image boundaries
+        1    occluded     Integer (0,1,2,3) indicating occlusion state:
+                         0 = fully visible, 1 = partly occluded
+                         2 = largely occluded, 3 = unknown
+        1    alpha        Observation angle of object, ranging [-pi..pi]
+        4    bbox         2D bounding box of object in the image (0-based index):
+                         contains left, top, right, bottom pixel coordinates
+        3    dimensions   3D object dimensions: height, width, length (in meters)
+        3    location     3D object location x,y,z in camera coordinates (in meters)
+        1    rotation_y   Rotation ry around Y-axis in camera coordinates [-pi..pi]
+        """
+
+        self.labels = {}
+        self.classes = kitti_classes
+        for name, label in self.classes.items():
+            self.labels[label] = name
+
+        self.image_data = dict()
+        self.images = []
+        for i, fn in enumerate(os.listdir(label_dir)):
+            label_fp = os.path.join(label_dir, fn)
+            image_fp = os.path.join(image_dir, fn.replace('.txt', '.png'))
+
+            self.images.append(image_fp)
+
+            fieldnames = ['type', 'truncated', 'occluded', 'alpha', 'left', 'top', 'right', 'bottom', 'dh', 'dw', 'dl',
+                          'lx', 'ly', 'lz', 'ry']
+            with open(label_fp, 'r') as csv_file:
+                reader = csv.DictReader(csv_file, delimiter=' ', fieldnames=fieldnames)
+                boxes = []
+                for line, row in enumerate(reader):
+                    label = row['type']
+                    cls_id = kitti_classes[label]
+
+                    annotation = {'cls_id': cls_id, 'x1': row['left'], 'x2': row['right'], 'y2': row['bottom'], 'y1': row['top']}
+                    boxes.append(annotation)
+
+                self.image_data[i] = boxes
+
+        super(KittiGenerator, self).__init__(**kwargs)
+
+    def size(self):
+        """ Size of the dataset.
+        """
+        return len(self.images)
+
+    def num_classes(self):
+        """ Number of classes in the dataset.
+        """
+        return max(self.classes.values()) + 1
+
+    def has_label(self, label):
+        """ Return True if label is a known label.
+        """
+        return label in self.labels
+
+    def has_name(self, name):
+        """ Returns True if name is a known class.
+        """
+        return name in self.classes
+
+    def name_to_label(self, name):
+        """ Map name to label.
+        """
+        raise NotImplementedError()
+
+    def label_to_name(self, label):
+        """ Map label to name.
+        """
+        return self.labels[label]
+
+    def image_aspect_ratio(self, image_index):
+        """ Compute the aspect ratio for an image with image_index.
+        """
+        # PIL is fast for metadata
+        image = Image.open(self.images[image_index])
+        return float(image.width) / float(image.height)
+
+    def image_path(self, image_index):
+        """ Get the path to an image.
+        """
+        return self.images[image_index]
+
+    def load_image(self, image_index):
+        """ Load an image at the image_index.
+        """
+        return read_image_bgr(self.image_path(image_index))
+
+    def load_annotations(self, image_index):
+        """ Load annotations for an image_index.
+        """
+        image_data = self.image_data[image_index]
+        annotations = {'labels': np.empty((len(image_data),)), 'bboxes': np.empty((len(image_data), 4))}
+
+        for idx, ann in enumerate(image_data):
+            annotations['bboxes'][idx, 0] = float(ann['x1'])
+            annotations['bboxes'][idx, 1] = float(ann['y1'])
+            annotations['bboxes'][idx, 2] = float(ann['x2'])
+            annotations['bboxes'][idx, 3] = float(ann['y2'])
+            annotations['labels'][idx] = int(ann['cls_id'])
+
+        return annotations

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from ..preprocessing.generator import Generator
+from ..utils.image import read_image_bgr
+
+import os
+import numpy as np
+from six import raise_from
+from PIL import Image
+
+try:
+    import xml.etree.cElementTree as ET
+except ImportError:
+    import xml.etree.ElementTree as ET
+
+voc_classes = {
+    'aeroplane'   : 0,
+    'bicycle'     : 1,
+    'bird'        : 2,
+    'boat'        : 3,
+    'bottle'      : 4,
+    'bus'         : 5,
+    'car'         : 6,
+    'cat'         : 7,
+    'chair'       : 8,
+    'cow'         : 9,
+    'diningtable' : 10,
+    'dog'         : 11,
+    'horse'       : 12,
+    'motorbike'   : 13,
+    'person'      : 14,
+    'pottedplant' : 15,
+    'sheep'       : 16,
+    'sofa'        : 17,
+    'train'       : 18,
+    'tvmonitor'   : 19
+}
+
+
+def _findNode(parent, name, debug_name=None, parse=None):
+    if debug_name is None:
+        debug_name = name
+
+    result = parent.find(name)
+    if result is None:
+        raise ValueError('missing element \'{}\''.format(debug_name))
+    if parse is not None:
+        try:
+            return parse(result.text)
+        except ValueError as e:
+            raise_from(ValueError('illegal value for \'{}\': {}'.format(debug_name, e)), None)
+    return result
+
+
+class PascalVocGenerator(Generator):
+    """ Generate data for a Pascal VOC dataset.
+
+    See http://host.robots.ox.ac.uk/pascal/VOC/ for more information.
+    """
+
+    def __init__(
+        self,
+        data_dir,
+        set_name,
+        classes=voc_classes,
+        image_extension='.jpg',
+        skip_truncated=False,
+        skip_difficult=False,
+        **kwargs
+    ):
+        """ Initialize a Pascal VOC data generator.
+
+        Args
+            base_dir: Directory w.r.t. where the files are to be searched (defaults to the directory containing the csv_data_file).
+            csv_class_file: Path to the CSV classes file.
+        """
+        self.data_dir             = data_dir
+        self.set_name             = set_name
+        self.classes              = classes
+        self.image_names          = [line.strip().split(None, 1)[0] for line in open(os.path.join(data_dir, 'ImageSets', 'Main', set_name + '.txt')).readlines()]
+        self.image_extension      = image_extension
+        self.skip_truncated       = skip_truncated
+        self.skip_difficult       = skip_difficult
+
+        self.labels = {}
+        for key, value in self.classes.items():
+            self.labels[value] = key
+
+        super(PascalVocGenerator, self).__init__(**kwargs)
+
+    def size(self):
+        """ Size of the dataset.
+        """
+        return len(self.image_names)
+
+    def num_classes(self):
+        """ Number of classes in the dataset.
+        """
+        return len(self.classes)
+
+    def has_label(self, label):
+        """ Return True if label is a known label.
+        """
+        return label in self.labels
+
+    def has_name(self, name):
+        """ Returns True if name is a known class.
+        """
+        return name in self.classes
+
+    def name_to_label(self, name):
+        """ Map name to label.
+        """
+        return self.classes[name]
+
+    def label_to_name(self, label):
+        """ Map label to name.
+        """
+        return self.labels[label]
+
+    def image_aspect_ratio(self, image_index):
+        """ Compute the aspect ratio for an image with image_index.
+        """
+        path  = os.path.join(self.data_dir, 'JPEGImages', self.image_names[image_index] + self.image_extension)
+        image = Image.open(path)
+        return float(image.width) / float(image.height)
+
+    def image_path(self, image_index):
+        """ Get the path to an image.
+        """
+        return os.path.join(self.data_dir, 'JPEGImages', self.image_names[image_index] + self.image_extension)
+
+    def load_image(self, image_index):
+        """ Load an image at the image_index.
+        """
+        return read_image_bgr(self.image_path(image_index))
+
+    def __parse_annotation(self, element):
+        """ Parse an annotation given an XML element.
+        """
+        truncated = _findNode(element, 'truncated', parse=int)
+        difficult = _findNode(element, 'difficult', parse=int)
+
+        class_name = _findNode(element, 'name').text
+        if class_name not in self.classes:
+            raise ValueError('class name \'{}\' not found in classes: {}'.format(class_name, list(self.classes.keys())))
+
+        box = np.zeros((4,))
+        label = self.name_to_label(class_name)
+
+        bndbox    = _findNode(element, 'bndbox')
+        box[0] = _findNode(bndbox, 'xmin', 'bndbox.xmin', parse=float) - 1
+        box[1] = _findNode(bndbox, 'ymin', 'bndbox.ymin', parse=float) - 1
+        box[2] = _findNode(bndbox, 'xmax', 'bndbox.xmax', parse=float) - 1
+        box[3] = _findNode(bndbox, 'ymax', 'bndbox.ymax', parse=float) - 1
+
+        return truncated, difficult, box, label
+
+    def __parse_annotations(self, xml_root):
+        """ Parse all annotations under the xml_root.
+        """
+        annotations = {'labels': np.empty((len(xml_root.findall('object')),)), 'bboxes': np.empty((len(xml_root.findall('object')), 4))}
+        for i, element in enumerate(xml_root.iter('object')):
+            try:
+                truncated, difficult, box, label = self.__parse_annotation(element)
+            except ValueError as e:
+                raise_from(ValueError('could not parse object #{}: {}'.format(i, e)), None)
+
+            if truncated and self.skip_truncated:
+                continue
+            if difficult and self.skip_difficult:
+                continue
+
+            annotations['bboxes'][i, :] = box
+            annotations['labels'][i] = label
+
+        return annotations
+
+    def load_annotations(self, image_index):
+        """ Load annotations for an image_index.
+        """
+        filename = self.image_names[image_index] + '.xml'
+        try:
+            tree = ET.parse(os.path.join(self.data_dir, 'Annotations', filename))
+            return self.__parse_annotations(tree.getroot())
+        except ET.ParseError as e:
+            raise_from(ValueError('invalid annotations file: {}: {}'.format(filename, e)), None)
+        except ValueError as e:
+            raise_from(ValueError('invalid annotations file: {}: {}'.format(filename, e)), None)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from pycocotools.cocoeval import COCOeval
+
+from tensorflow import keras
+import numpy as np
+import json
+
+import progressbar
+assert(callable(progressbar.progressbar)), "Using wrong progressbar module, install 'progressbar2' instead."
+
+
+def evaluate_coco(generator, model, threshold=0.05):
+    """ Use the pycocotools to evaluate a COCO model on a dataset.
+
+    Args
+        generator : The generator for generating the evaluation data.
+        model     : The model to evaluate.
+        threshold : The score threshold to use.
+    """
+    # start collecting results
+    results = []
+    image_ids = []
+    for index in progressbar.progressbar(range(generator.size()), prefix='COCO evaluation: '):
+        image = generator.load_image(index)
+        image = generator.preprocess_image(image)
+        image, scale = generator.resize_image(image)
+
+        if keras.backend.image_data_format() == 'channels_first':
+            image = image.transpose((2, 0, 1))
+
+        # run network
+        boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
+
+        # correct boxes for image scale
+        boxes /= scale
+
+        # change to (x, y, w, h) (MS COCO standard)
+        boxes[:, :, 2] -= boxes[:, :, 0]
+        boxes[:, :, 3] -= boxes[:, :, 1]
+
+        # compute predicted labels and scores
+        for box, score, label in zip(boxes[0], scores[0], labels[0]):
+            # scores are sorted, so we can break
+            if score < threshold:
+                break
+
+            # append detection for each positively labeled class
+            image_result = {
+                'image_id'    : generator.image_ids[index],
+                'category_id' : generator.label_to_coco_label(label),
+                'score'       : float(score),
+                'bbox'        : box.tolist(),
+            }
+
+            # append detection to results
+            results.append(image_result)
+
+        # append image to list of processed images
+        image_ids.append(generator.image_ids[index])
+
+    if not len(results):
+        return
+
+    # write output
+    json.dump(results, open('{}_bbox_results.json'.format(generator.set_name), 'w'), indent=4)
+    json.dump(image_ids, open('{}_processed_image_ids.json'.format(generator.set_name), 'w'), indent=4)
+
+    # load results in COCO evaluation tool
+    coco_true = generator.coco
+    coco_pred = coco_true.loadRes('{}_bbox_results.json'.format(generator.set_name))
+
+    # run COCO evaluation
+    coco_eval = COCOeval(coco_true, coco_pred, 'bbox')
+    coco_eval.params.imgIds = image_ids
+    coco_eval.evaluate()
+    coco_eval.accumulate()
+    coco_eval.summarize()
+    return coco_eval.stats

+import warnings
+
+
+def label_color(label):
+    """ Return a color from a set of predefined colors. Contains 80 colors in total.
+
+    Args
+        label: The label to get the color for.
+
+    Returns
+        A list of three values representing a RGB color.
+
+        If no color is defined for a certain label, the color green is returned and a warning is printed.
+    """
+    if label < len(colors):
+        return colors[label]
+    else:
+        warnings.warn('Label {} has no color, returning default.'.format(label))
+        return (0, 255, 0)
+
+
+"""
+Generated using:
+
+```
+colors = [list((matplotlib.colors.hsv_to_rgb([x, 1.0, 1.0]) * 255).astype(int)) for x in np.arange(0, 1, 1.0 / 80)]
+shuffle(colors)
+pprint(colors)
+```
+"""
+colors = [
+    [31  , 0   , 255] ,
+    [0   , 159 , 255] ,
+    [255 , 95  , 0]   ,
+    [255 , 19  , 0]   ,
+    [255 , 0   , 0]   ,
+    [255 , 38  , 0]   ,
+    [0   , 255 , 25]  ,
+    [255 , 0   , 133] ,
+    [255 , 172 , 0]   ,
+    [108 , 0   , 255] ,
+    [0   , 82  , 255] ,
+    [0   , 255 , 6]   ,
+    [255 , 0   , 152] ,
+    [223 , 0   , 255] ,
+    [12  , 0   , 255] ,
+    [0   , 255 , 178] ,
+    [108 , 255 , 0]   ,
+    [184 , 0   , 255] ,
+    [255 , 0   , 76]  ,
+    [146 , 255 , 0]   ,
+    [51  , 0   , 255] ,
+    [0   , 197 , 255] ,
+    [255 , 248 , 0]   ,
+    [255 , 0   , 19]  ,
+    [255 , 0   , 38]  ,
+    [89  , 255 , 0]   ,
+    [127 , 255 , 0]   ,
+    [255 , 153 , 0]   ,
+    [0   , 255 , 255] ,
+    [0   , 255 , 216] ,
+    [0   , 255 , 121] ,
+    [255 , 0   , 248] ,
+    [70  , 0   , 255] ,
+    [0   , 255 , 159] ,
+    [0   , 216 , 255] ,
+    [0   , 6   , 255] ,
+    [0   , 63  , 255] ,
+    [31  , 255 , 0]   ,
+    [255 , 57  , 0]   ,
+    [255 , 0   , 210] ,
+    [0   , 255 , 102] ,
+    [242 , 255 , 0]   ,
+    [255 , 191 , 0]   ,
+    [0   , 255 , 63]  ,
+    [255 , 0   , 95]  ,
+    [146 , 0   , 255] ,
+    [184 , 255 , 0]   ,
+    [255 , 114 , 0]   ,
+    [0   , 255 , 235] ,
+    [255 , 229 , 0]   ,
+    [0   , 178 , 255] ,
+    [255 , 0   , 114] ,
+    [255 , 0   , 57]  ,
+    [0   , 140 , 255] ,
+    [0   , 121 , 255] ,
+    [12  , 255 , 0]   ,
+    [255 , 210 , 0]   ,
+    [0   , 255 , 44]  ,
+    [165 , 255 , 0]   ,
+    [0   , 25  , 255] ,
+    [0   , 255 , 140] ,
+    [0   , 101 , 255] ,
+    [0   , 255 , 82]  ,
+    [223 , 255 , 0]   ,
+    [242 , 0   , 255] ,
+    [89  , 0   , 255] ,
+    [165 , 0   , 255] ,
+    [70  , 255 , 0]   ,
+    [255 , 0   , 172] ,
+    [255 , 76  , 0]   ,
+    [203 , 255 , 0]   ,
+    [204 , 0   , 255] ,
+    [255 , 0   , 229] ,
+    [255 , 133 , 0]   ,
+    [127 , 0   , 255] ,
+    [0   , 235 , 255] ,
+    [0   , 255 , 197] ,
+    [255 , 0   , 191] ,
+    [0   , 44  , 255] ,
+    [50  , 255 , 0]
+]

+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Sergey Karayev
+# --------------------------------------------------------
+
+cimport cython
+import numpy as np
+cimport numpy as np
+
+
+def compute_overlap(
+    np.ndarray[double, ndim=2] boxes,
+    np.ndarray[double, ndim=2] query_boxes
+):
+    """
+    Args
+        a: (N, 4) ndarray of float
+        b: (K, 4) ndarray of float
+
+    Returns
+        overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[double, ndim=2] overlaps = np.zeros((N, K), dtype=np.float64)
+    cdef double iw, ih, box_area
+    cdef double ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0]) *
+            (query_boxes[k, 3] - query_boxes[k, 1])
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0]) 
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1]) 
+                )
+                if ih > 0:
+                    ua = np.float64(
+                        (boxes[n, 2] - boxes[n, 0]) *
+                        (boxes[n, 3] - boxes[n, 1]) +
+                        box_area - iw * ih
+                    )
+                    overlaps[n, k] = iw * ih / ua
+    return overlaps

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import configparser
+import numpy as np
+from tensorflow import keras
+from ..utils.anchors import AnchorParameters
+
+
+def read_config_file(config_path):
+    config = configparser.ConfigParser()
+
+    with open(config_path, 'r') as file:
+        config.read_file(file)
+
+    assert 'anchor_parameters' in config, \
+        "Malformed config file. Verify that it contains the anchor_parameters section."
+
+    config_keys = set(config['anchor_parameters'])
+    default_keys = set(AnchorParameters.default.__dict__.keys())
+
+    assert config_keys <= default_keys, \
+        "Malformed config file. These keys are not valid: {}".format(config_keys - default_keys)
+
+    if 'pyramid_levels' in config:
+        assert('levels' in config['pyramid_levels']), "pyramid levels specified by levels key"
+
+    return config
+
+
+def parse_anchor_parameters(config):
+    ratios  = np.array(list(map(float, config['anchor_parameters']['ratios'].split(' '))), keras.backend.floatx())
+    scales  = np.array(list(map(float, config['anchor_parameters']['scales'].split(' '))), keras.backend.floatx())
+    sizes   = list(map(int, config['anchor_parameters']['sizes'].split(' ')))
+    strides = list(map(int, config['anchor_parameters']['strides'].split(' ')))
+    assert (len(sizes) == len(strides)), "sizes and strides should have an equal number of values"
+
+    return AnchorParameters(sizes, strides, ratios, scales)
+
+
+def parse_pyramid_levels(config):
+    levels = list(map(int, config['pyramid_levels']['levels'].split(' ')))
+
+    return levels

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from .anchors import compute_overlap
+from .visualization import draw_detections, draw_annotations
+
+from tensorflow import keras
+import numpy as np
+import os
+import time
+
+import cv2
+import progressbar
+assert(callable(progressbar.progressbar)), "Using wrong progressbar module, install 'progressbar2' instead."
+
+
+def _compute_ap(recall, precision):
+    """ Compute the average precision, given the recall and precision curves.
+
+    Code originally from https://github.com/rbgirshick/py-faster-rcnn.
+
+    # Arguments
+        recall:    The recall curve (list).
+        precision: The precision curve (list).
+    # Returns
+        The average precision as computed in py-faster-rcnn.
+    """
+    # correct AP calculation
+    # first append sentinel values at the end
+    mrec = np.concatenate(([0.], recall, [1.]))
+    mpre = np.concatenate(([0.], precision, [0.]))
+
+    # compute the precision envelope
+    for i in range(mpre.size - 1, 0, -1):
+        mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
+
+    # to calculate area under PR curve, look for points
+    # where X axis (recall) changes value
+    i = np.where(mrec[1:] != mrec[:-1])[0]
+
+    # and sum (\Delta recall) * prec
+    ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
+    return ap
+
+
+def _get_detections(generator, model, score_threshold=0.05, max_detections=100, save_path=None):
+    """ Get the detections from the model using the generator.
+
+    The result is a list of lists such that the size is:
+        all_detections[num_images][num_classes] = detections[num_detections, 4 + num_classes]
+
+    # Arguments
+        generator       : The generator used to run images through the model.
+        model           : The model to run on the images.
+        score_threshold : The score confidence threshold to use.
+        max_detections  : The maximum number of detections to use per image.
+        save_path       : The path to save the images with visualized detections to.
+    # Returns
+        A list of lists containing the detections for each image in the generator.
+    """
+    all_detections = [[None for i in range(generator.num_classes()) if generator.has_label(i)] for j in range(generator.size())]
+    all_inferences = [None for i in range(generator.size())]
+
+    for i in progressbar.progressbar(range(generator.size()), prefix='Running network: '):
+        raw_image    = generator.load_image(i)
+        image, scale = generator.resize_image(raw_image.copy())
+        image = generator.preprocess_image(image)
+
+        if keras.backend.image_data_format() == 'channels_first':
+            image = image.transpose((2, 0, 1))
+
+        # run network
+        start = time.time()
+        boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))[:3]
+        inference_time = time.time() - start
+
+        # correct boxes for image scale
+        boxes /= scale
+
+        # select indices which have a score above the threshold
+        indices = np.where(scores[0, :] > score_threshold)[0]
+
+        # select those scores
+        scores = scores[0][indices]
+
+        # find the order with which to sort the scores
+        scores_sort = np.argsort(-scores)[:max_detections]
+
+        # select detections
+        image_boxes      = boxes[0, indices[scores_sort], :]
+        image_scores     = scores[scores_sort]
+        image_labels     = labels[0, indices[scores_sort]]
+        image_detections = np.concatenate([image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_labels, axis=1)], axis=1)
+
+        if save_path is not None:
+            draw_annotations(raw_image, generator.load_annotations(i), label_to_name=generator.label_to_name)
+            draw_detections(raw_image, image_boxes, image_scores, image_labels, label_to_name=generator.label_to_name, score_threshold=score_threshold)
+
+            cv2.imwrite(os.path.join(save_path, '{}.png'.format(i)), raw_image)
+
+        # copy detections to all_detections
+        for label in range(generator.num_classes()):
+            if not generator.has_label(label):
+                continue
+
+            all_detections[i][label] = image_detections[image_detections[:, -1] == label, :-1]
+
+        all_inferences[i] = inference_time
+
+    return all_detections, all_inferences
+
+
+def _get_annotations(generator):
+    """ Get the ground truth annotations from the generator.
+
+    The result is a list of lists such that the size is:
+        all_detections[num_images][num_classes] = annotations[num_detections, 5]
+
+    # Arguments
+        generator : The generator used to retrieve ground truth annotations.
+    # Returns
+        A list of lists containing the annotations for each image in the generator.
+    """
+    all_annotations = [[None for i in range(generator.num_classes())] for j in range(generator.size())]
+
+    for i in progressbar.progressbar(range(generator.size()), prefix='Parsing annotations: '):
+        # load the annotations
+        annotations = generator.load_annotations(i)
+
+        # copy detections to all_annotations
+        for label in range(generator.num_classes()):
+            if not generator.has_label(label):
+                continue
+
+            all_annotations[i][label] = annotations['bboxes'][annotations['labels'] == label, :].copy()
+
+    return all_annotations
+
+
+def evaluate(
+    generator,
+    model,
+    iou_threshold=0.5,
+    score_threshold=0.05,
+    max_detections=100,
+    save_path=None
+):
+    """ Evaluate a given dataset using a given model.
+
+    # Arguments
+        generator       : The generator that represents the dataset to evaluate.
+        model           : The model to evaluate.
+        iou_threshold   : The threshold used to consider when a detection is positive or negative.
+        score_threshold : The score confidence threshold to use for detections.
+        max_detections  : The maximum number of detections to use per image.
+        save_path       : The path to save images with visualized detections to.
+    # Returns
+        A dict mapping class names to mAP scores.
+    """
+    # gather all detections and annotations
+    all_detections, all_inferences = _get_detections(generator, model, score_threshold=score_threshold, max_detections=max_detections, save_path=save_path)
+    all_annotations    = _get_annotations(generator)
+    average_precisions = {}
+
+    # all_detections = pickle.load(open('all_detections.pkl', 'rb'))
+    # all_annotations = pickle.load(open('all_annotations.pkl', 'rb'))
+    # pickle.dump(all_detections, open('all_detections.pkl', 'wb'))
+    # pickle.dump(all_annotations, open('all_annotations.pkl', 'wb'))
+
+    # process detections and annotations
+    for label in range(generator.num_classes()):
+        if not generator.has_label(label):
+            continue
+
+        false_positives = np.zeros((0,))
+        true_positives  = np.zeros((0,))
+        scores          = np.zeros((0,))
+        num_annotations = 0.0
+
+        for i in range(generator.size()):
+            detections           = all_detections[i][label]
+            annotations          = all_annotations[i][label]
+            num_annotations     += annotations.shape[0]
+            detected_annotations = []
+
+            for d in detections:
+                scores = np.append(scores, d[4])
+
+                if annotations.shape[0] == 0:
+                    false_positives = np.append(false_positives, 1)
+                    true_positives  = np.append(true_positives, 0)
+                    continue
+
+                overlaps            = compute_overlap(np.expand_dims(d, axis=0), annotations)
+                assigned_annotation = np.argmax(overlaps, axis=1)
+                max_overlap         = overlaps[0, assigned_annotation]
+
+                if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations:
+                    false_positives = np.append(false_positives, 0)
+                    true_positives  = np.append(true_positives, 1)
+                    detected_annotations.append(assigned_annotation)
+                else:
+                    false_positives = np.append(false_positives, 1)
+                    true_positives  = np.append(true_positives, 0)
+
+        # no annotations -> AP for this class is 0 (is this correct?)
+        if num_annotations == 0:
+            average_precisions[label] = 0, 0
+            continue
+
+        # sort by score
+        indices         = np.argsort(-scores)
+        false_positives = false_positives[indices]
+        true_positives  = true_positives[indices]
+
+        # compute false positives and true positives
+        false_positives = np.cumsum(false_positives)
+        true_positives  = np.cumsum(true_positives)
+
+        # compute recall and precision
+        recall    = true_positives / num_annotations
+        precision = true_positives / np.maximum(true_positives + false_positives, np.finfo(np.float64).eps)
+
+        # compute average precision
+        average_precision  = _compute_ap(recall, precision)
+        average_precisions[label] = average_precision, num_annotations
+
+    # inference time
+    inference_time = np.sum(all_inferences) / generator.size()
+
+    return average_precisions, inference_time

+"""
+Copyright 2017-2019 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import tensorflow as tf
+
+
+def setup_gpu(gpu_id):
+    try:
+        visible_gpu_indices = [int(id) for id in gpu_id.split(',')]
+        available_gpus = tf.config.list_physical_devices('GPU')
+        visible_gpus = [gpu for idx, gpu in enumerate(available_gpus) if idx in visible_gpu_indices]
+
+        if visible_gpus:
+            try:
+                # Currently, memory growth needs to be the same across GPUs.
+                for gpu in available_gpus:
+                    tf.config.experimental.set_memory_growth(gpu, True)
+
+                # Use only the selcted gpu.
+                tf.config.set_visible_devices(visible_gpus, 'GPU')
+            except RuntimeError as e:
+                # Visible devices must be set before GPUs have been initialized.
+                print(e)
+
+            logical_gpus = tf.config.list_logical_devices('GPU')
+            print(len(available_gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
+        else:
+            tf.config.set_visible_devices([], 'GPU')
+    except ValueError:
+        tf.config.set_visible_devices([], 'GPU')

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+
+def freeze(model):
+    """ Set all layers in a model to non-trainable.
+
+    The weights for these layers will not be updated during training.
+
+    This function modifies the given model in-place,
+    but it also returns the modified model to allow easy chaining with other functions.
+    """
+    for layer in model.layers:
+        layer.trainable = False
+    return model

+"""
+Copyright 2017-2019 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from __future__ import print_function
+
+import tensorflow as tf
+import sys
+
+MINIMUM_TF_VERSION = 2, 3, 0
+BLACKLISTED_TF_VERSIONS = []
+
+
+def tf_version():
+    """ Get the Tensorflow version.
+        Returns
+            tuple of (major, minor, patch).
+    """
+    return tuple(map(int, tf.version.VERSION.split('-')[0].split('.')))
+
+
+def tf_version_ok(minimum_tf_version=MINIMUM_TF_VERSION, blacklisted=BLACKLISTED_TF_VERSIONS):
+    """ Check if the current Tensorflow version is higher than the minimum version.
+    """
+    return tf_version() >= minimum_tf_version and tf_version() not in blacklisted
+
+
+def assert_tf_version(minimum_tf_version=MINIMUM_TF_VERSION, blacklisted=BLACKLISTED_TF_VERSIONS):
+    """ Assert that the Tensorflow version is up to date.
+    """
+    detected = tf.version.VERSION
+    required = '.'.join(map(str, minimum_tf_version))
+    assert(tf_version_ok(minimum_tf_version, blacklisted)), 'You are using tensorflow version {}. The minimum required version is {} (blacklisted: {}).'.format(detected, required, blacklisted)
+
+
+def check_tf_version():
+    """ Check that the Tensorflow version is up to date. If it isn't, print an error message and exit the script.
+    """
+    try:
+        assert_tf_version()
+    except AssertionError as e:
+        print(e, file=sys.stderr)
+        sys.exit(1)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import cv2
+import numpy as np
+
+from .colors import label_color
+
+
+def draw_box(image, box, color, thickness=2):
+    """ Draws a box on an image with a given color.
+
+    # Arguments
+        image     : The image to draw on.
+        box       : A list of 4 elements (x1, y1, x2, y2).
+        color     : The color of the box.
+        thickness : The thickness of the lines to draw a box with.
+    """
+    b = np.array(box).astype(int)
+    cv2.rectangle(image, (b[0], b[1]), (b[2], b[3]), color, thickness, cv2.LINE_AA)
+
+
+def draw_caption(image, box, caption):
+    """ Draws a caption above the box in an image.
+
+    # Arguments
+        image   : The image to draw on.
+        box     : A list of 4 elements (x1, y1, x2, y2).
+        caption : String containing the text to draw.
+    """
+    b = np.array(box).astype(int)
+    cv2.putText(image, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1, (0, 0, 0), 2)
+    cv2.putText(image, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1)
+
+
+def draw_boxes(image, boxes, color, thickness=2):
+    """ Draws boxes on an image with a given color.
+
+    # Arguments
+        image     : The image to draw on.
+        boxes     : A [N, 4] matrix (x1, y1, x2, y2).
+        color     : The color of the boxes.
+        thickness : The thickness of the lines to draw boxes with.
+    """
+    for b in boxes:
+        draw_box(image, b, color, thickness=thickness)
+
+
+def draw_detections(image, boxes, scores, labels, color=None, label_to_name=None, score_threshold=0.5):
+    """ Draws detections in an image.
+
+    # Arguments
+        image           : The image to draw on.
+        boxes           : A [N, 4] matrix (x1, y1, x2, y2).
+        scores          : A list of N classification scores.
+        labels          : A list of N labels.
+        color           : The color of the boxes. By default the color from keras_retinanet.utils.colors.label_color will be used.
+        label_to_name   : (optional) Functor for mapping a label to a name.
+        score_threshold : Threshold used for determining what detections to draw.
+    """
+    selection = np.where(scores > score_threshold)[0]
+
+    for i in selection:
+        c = color if color is not None else label_color(labels[i])
+        draw_box(image, boxes[i, :], color=c)
+
+        # draw labels
+        caption = (label_to_name(labels[i]) if label_to_name else labels[i]) + ': {0:.2f}'.format(scores[i])
+        draw_caption(image, boxes[i, :], caption)
+
+
+def draw_annotations(image, annotations, color=(0, 255, 0), label_to_name=None):
+    """ Draws annotations in an image.
+
+    # Arguments
+        image         : The image to draw on.
+        annotations   : A [N, 5] matrix (x1, y1, x2, y2, label) or dictionary containing bboxes (shaped [N, 4]) and labels (shaped [N]).
+        color         : The color of the boxes. By default the color from keras_retinanet.utils.colors.label_color will be used.
+        label_to_name : (optional) Functor for mapping a label to a name.
+    """
+    if isinstance(annotations, np.ndarray):
+        annotations = {'bboxes': annotations[:, :4], 'labels': annotations[:, 4]}
+
+    assert('bboxes' in annotations)
+    assert('labels' in annotations)
+    assert(annotations['bboxes'].shape[0] == annotations['labels'].shape[0])
+
+    for i in range(annotations['bboxes'].shape[0]):
+        label   = annotations['labels'][i]
+        c       = color if color is not None else label_color(label)
+        caption = '{}'.format(label_to_name(label) if label_to_name else label)
+        draw_caption(image, annotations['bboxes'][i], caption)
+        draw_box(image, annotations['bboxes'][i], color=c)

+cython
+keras-resnet==0.2.0
+git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI
+h5py
+keras
+matplotlib
+numpy>=1.14
+opencv-python>=3.3.0
+pillow
+progressbar2
+tensorflow>=2.3.0

+# ignore:
+# E201 whitespace after '['
+# E202 whitespace before ']'
+# E203 whitespace before ':'
+# E221 multiple spaces before operator
+# E241 multiple spaces after ','
+# E251 unexpected spaces around keyword / parameter equals
+# E501 line too long (85 > 79 characters)
+# W504 line break after binary operator
+[tool:pytest]
+flake8-max-line-length = 100
+flake8-ignore = E201 E202 E203 E221 E241 E251 E402 E501 W504

+import setuptools
+from setuptools.extension import Extension
+from distutils.command.build_ext import build_ext as DistUtilsBuildExt
+
+
+class BuildExtension(setuptools.Command):
+    description     = DistUtilsBuildExt.description
+    user_options    = DistUtilsBuildExt.user_options
+    boolean_options = DistUtilsBuildExt.boolean_options
+    help_options    = DistUtilsBuildExt.help_options
+
+    def __init__(self, *args, **kwargs):
+        from setuptools.command.build_ext import build_ext as SetupToolsBuildExt
+
+        # Bypass __setatrr__ to avoid infinite recursion.
+        self.__dict__['_command'] = SetupToolsBuildExt(*args, **kwargs)
+
+    def __getattr__(self, name):
+        return getattr(self._command, name)
+
+    def __setattr__(self, name, value):
+        setattr(self._command, name, value)
+
+    def initialize_options(self, *args, **kwargs):
+        return self._command.initialize_options(*args, **kwargs)
+
+    def finalize_options(self, *args, **kwargs):
+        ret = self._command.finalize_options(*args, **kwargs)
+        import numpy
+        self.include_dirs.append(numpy.get_include())
+        return ret
+
+    def run(self, *args, **kwargs):
+        return self._command.run(*args, **kwargs)
+
+
+extensions = [
+    Extension(
+        'keras_retinanet.utils.compute_overlap',
+        ['keras_retinanet/utils/compute_overlap.pyx']
+    ),
+]
+
+
+setuptools.setup(
+    name             = 'keras-retinanet',
+    version          = '1.0.0',
+    description      = 'Keras implementation of RetinaNet object detection.',
+    url              = 'https://github.com/fizyr/keras-retinanet',
+    author           = 'Hans Gaiser',
+    author_email     = 'h.gaiser@fizyr.com',
+    maintainer       = 'Hans Gaiser',
+    maintainer_email = 'h.gaiser@fizyr.com',
+    cmdclass         = {'build_ext': BuildExtension},
+    packages         = setuptools.find_packages(),
+    install_requires = ['keras-resnet==0.2.0', 'six', 'numpy', 'cython', 'Pillow', 'opencv-python', 'progressbar2'],
+    entry_points     = {
+        'console_scripts': [
+            'retinanet-train=keras_retinanet.bin.train:main',
+            'retinanet-evaluate=keras_retinanet.bin.evaluate:main',
+            'retinanet-debug=keras_retinanet.bin.debug:main',
+            'retinanet-convert-model=keras_retinanet.bin.convert_model:main',
+        ],
+    },
+    ext_modules    = extensions,
+    setup_requires = ["cython>=0.28", "numpy>=1.14.0"]
+)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import numpy as np
+from tensorflow import keras
+import keras_retinanet.backend
+
+
+def test_bbox_transform_inv():
+    boxes = np.array([[
+        [100, 100, 200, 200],
+        [100, 100, 300, 300],
+        [100, 100, 200, 300],
+        [100, 100, 300, 200],
+        [80,  120, 200, 200],
+        [80,  120, 300, 300],
+        [80,  120, 200, 300],
+        [80,  120, 300, 200],
+    ]])
+    boxes = keras.backend.variable(boxes)
+
+    deltas = np.array([[
+        [0   , 0  , 0   , 0   ],
+        [0   , 0.1, 0   , 0   ],
+        [-0.3, 0  , 0   , 0   ],
+        [0.2 , 0.2, 0   , 0   ],
+        [0   , 0  , 0.1 , 0   ],
+        [0   , 0  , 0   , -0.3],
+        [0   , 0  , 0.2 , 0.2 ],
+        [0.1 , 0.2, -0.3, 0.4 ],
+    ]])
+    deltas = keras.backend.variable(deltas)
+
+    expected = np.array([[
+        [100  , 100  , 200   , 200  ],
+        [100  , 104  , 300   , 300  ],
+        [ 94  , 100  , 200   , 300  ],
+        [108  , 104  , 300   , 200  ],
+        [ 80  , 120  , 202.4 , 200  ],
+        [ 80  , 120  , 300   , 289.2],
+        [ 80  , 120  , 204.8 , 307.2],
+        [ 84.4, 123.2, 286.8 , 206.4]
+    ]])
+
+    result = keras_retinanet.backend.bbox_transform_inv(boxes, deltas)
+    result = keras.backend.eval(result)
+
+    np.testing.assert_array_almost_equal(result, expected, decimal=2)
+
+
+def test_shift():
+    shape  = (2, 3)
+    stride = 8
+
+    anchors = np.array([
+        [-8,  -8,  8,  8],
+        [-16, -16, 16, 16],
+        [-12, -12, 12, 12],
+        [-12, -16, 12, 16],
+        [-16, -12, 16, 12]
+    ], dtype=keras.backend.floatx())
+
+    expected = [
+        # anchors for (0, 0)
+        [4 - 8,  4 - 8,  4 + 8,  4 + 8],
+        [4 - 16, 4 - 16, 4 + 16, 4 + 16],
+        [4 - 12, 4 - 12, 4 + 12, 4 + 12],
+        [4 - 12, 4 - 16, 4 + 12, 4 + 16],
+        [4 - 16, 4 - 12, 4 + 16, 4 + 12],
+
+        # anchors for (0, 1)
+        [12 - 8,  4 - 8,  12 + 8,  4 + 8],
+        [12 - 16, 4 - 16, 12 + 16, 4 + 16],
+        [12 - 12, 4 - 12, 12 + 12, 4 + 12],
+        [12 - 12, 4 - 16, 12 + 12, 4 + 16],
+        [12 - 16, 4 - 12, 12 + 16, 4 + 12],
+
+        # anchors for (0, 2)
+        [20 - 8,  4 - 8,  20 + 8,  4 + 8],
+        [20 - 16, 4 - 16, 20 + 16, 4 + 16],
+        [20 - 12, 4 - 12, 20 + 12, 4 + 12],
+        [20 - 12, 4 - 16, 20 + 12, 4 + 16],
+        [20 - 16, 4 - 12, 20 + 16, 4 + 12],
+
+        # anchors for (1, 0)
+        [4 - 8,  12 - 8,  4 + 8,  12 + 8],
+        [4 - 16, 12 - 16, 4 + 16, 12 + 16],
+        [4 - 12, 12 - 12, 4 + 12, 12 + 12],
+        [4 - 12, 12 - 16, 4 + 12, 12 + 16],
+        [4 - 16, 12 - 12, 4 + 16, 12 + 12],
+
+        # anchors for (1, 1)
+        [12 - 8,  12 - 8,  12 + 8,  12 + 8],
+        [12 - 16, 12 - 16, 12 + 16, 12 + 16],
+        [12 - 12, 12 - 12, 12 + 12, 12 + 12],
+        [12 - 12, 12 - 16, 12 + 12, 12 + 16],
+        [12 - 16, 12 - 12, 12 + 16, 12 + 12],
+
+        # anchors for (1, 2)
+        [20 - 8,  12 - 8,  20 + 8,  12 + 8],
+        [20 - 16, 12 - 16, 20 + 16, 12 + 16],
+        [20 - 12, 12 - 12, 20 + 12, 12 + 12],
+        [20 - 12, 12 - 16, 20 + 12, 12 + 16],
+        [20 - 16, 12 - 12, 20 + 16, 12 + 12],
+    ]
+
+    result = keras_retinanet.backend.shift(shape, stride, anchors)
+    result = keras.backend.eval(result)
+
+    np.testing.assert_array_equal(result, expected)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import keras_retinanet.backend
+import keras_retinanet.bin.train
+from tensorflow import keras
+
+import warnings
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def clear_session():
+    # run before test (do nothing)
+    yield
+    # run after test, clear keras session
+    keras.backend.clear_session()
+
+
+def test_coco():
+    # ignore warnings in this test
+    warnings.simplefilter('ignore')
+
+    # run training / evaluation
+    keras_retinanet.bin.train.main([
+        '--epochs=1',
+        '--steps=1',
+        '--no-weights',
+        '--no-snapshots',
+        'coco',
+        'tests/test-data/coco',
+    ])
+
+
+def test_pascal():
+    # ignore warnings in this test
+    warnings.simplefilter('ignore')
+
+    # run training / evaluation
+    keras_retinanet.bin.train.main([
+        '--epochs=1',
+        '--steps=1',
+        '--no-weights',
+        '--no-snapshots',
+        'pascal',
+        'tests/test-data/pascal',
+    ])
+
+
+def test_csv():
+    # ignore warnings in this test
+    warnings.simplefilter('ignore')
+
+    # run training / evaluation
+    keras_retinanet.bin.train.main([
+        '--epochs=1',
+        '--steps=1',
+        '--no-weights',
+        '--no-snapshots',
+        'csv',
+        'tests/test-data/csv/annotations.csv',
+        'tests/test-data/csv/classes.csv',
+    ])
+
+
+def test_vgg():
+    # ignore warnings in this test
+    warnings.simplefilter('ignore')
+
+    # run training / evaluation
+    keras_retinanet.bin.train.main([
+        '--backbone=vgg16',
+        '--epochs=1',
+        '--steps=1',
+        '--no-weights',
+        '--no-snapshots',
+        '--freeze-backbone',
+        'coco',
+        'tests/test-data/coco',
+    ])

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+import keras_retinanet.backend
+import keras_retinanet.layers
+
+import numpy as np
+
+
+class TestFilterDetections(object):
+    def test_simple(self):
+        # create simple FilterDetections layer
+        filter_detections_layer = keras_retinanet.layers.FilterDetections()
+
+        # create simple input
+        boxes = np.array([[
+            [0, 0, 10, 10],
+            [0, 0, 10, 10],  # this will be suppressed
+        ]], dtype=keras.backend.floatx())
+        boxes = keras.backend.constant(boxes)
+
+        classification = np.array([[
+            [0, 0.9],  # this will be suppressed
+            [0, 1],
+        ]], dtype=keras.backend.floatx())
+        classification = keras.backend.constant(classification)
+
+        # compute output
+        actual_boxes, actual_scores, actual_labels = filter_detections_layer.call([boxes, classification])
+        actual_boxes  = keras.backend.eval(actual_boxes)
+        actual_scores = keras.backend.eval(actual_scores)
+        actual_labels = keras.backend.eval(actual_labels)
+
+        # define expected output
+        expected_boxes = -1 * np.ones((1, 300, 4), dtype=keras.backend.floatx())
+        expected_boxes[0, 0, :] = [0, 0, 10, 10]
+
+        expected_scores = -1 * np.ones((1, 300), dtype=keras.backend.floatx())
+        expected_scores[0, 0] = 1
+
+        expected_labels = -1 * np.ones((1, 300), dtype=keras.backend.floatx())
+        expected_labels[0, 0] = 1
+
+        # assert actual and expected are equal
+        np.testing.assert_array_equal(actual_boxes, expected_boxes)
+        np.testing.assert_array_equal(actual_scores, expected_scores)
+        np.testing.assert_array_equal(actual_labels, expected_labels)
+
+    def test_simple_with_other(self):
+        # create simple FilterDetections layer
+        filter_detections_layer = keras_retinanet.layers.FilterDetections()
+
+        # create simple input
+        boxes = np.array([[
+            [0, 0, 10, 10],
+            [0, 0, 10, 10],  # this will be suppressed
+        ]], dtype=keras.backend.floatx())
+        boxes = keras.backend.constant(boxes)
+
+        classification = np.array([[
+            [0, 0.9],  # this will be suppressed
+            [0, 1],
+        ]], dtype=keras.backend.floatx())
+        classification = keras.backend.constant(classification)
+
+        other = []
+        other.append(np.array([[
+            [0, 1234],  # this will be suppressed
+            [0, 5678],
+        ]], dtype=keras.backend.floatx()))
+        other.append(np.array([[
+            5678,  # this will be suppressed
+            1234,
+        ]], dtype=keras.backend.floatx()))
+        other = [keras.backend.constant(o) for o in other]
+
+        # compute output
+        actual = filter_detections_layer.call([boxes, classification] + other)
+        actual_boxes  = keras.backend.eval(actual[0])
+        actual_scores = keras.backend.eval(actual[1])
+        actual_labels = keras.backend.eval(actual[2])
+        actual_other  = [keras.backend.eval(a) for a in actual[3:]]
+
+        # define expected output
+        expected_boxes = -1 * np.ones((1, 300, 4), dtype=keras.backend.floatx())
+        expected_boxes[0, 0, :] = [0, 0, 10, 10]
+
+        expected_scores = -1 * np.ones((1, 300), dtype=keras.backend.floatx())
+        expected_scores[0, 0] = 1
+
+        expected_labels = -1 * np.ones((1, 300), dtype=keras.backend.floatx())
+        expected_labels[0, 0] = 1
+
+        expected_other = []
+        expected_other.append(-1 * np.ones((1, 300, 2), dtype=keras.backend.floatx()))
+        expected_other[-1][0, 0, :] = [0, 5678]
+        expected_other.append(-1 * np.ones((1, 300), dtype=keras.backend.floatx()))
+        expected_other[-1][0, 0] = 1234
+
+        # assert actual and expected are equal
+        np.testing.assert_array_equal(actual_boxes, expected_boxes)
+        np.testing.assert_array_equal(actual_scores, expected_scores)
+        np.testing.assert_array_equal(actual_labels, expected_labels)
+
+        for a, e in zip(actual_other, expected_other):
+            np.testing.assert_array_equal(a, e)
+
+    def test_mini_batch(self):
+        # create simple FilterDetections layer
+        filter_detections_layer = keras_retinanet.layers.FilterDetections()
+
+        # create input with batch_size=2
+        boxes = np.array([
+            [
+                [0, 0, 10, 10],  # this will be suppressed
+                [0, 0, 10, 10],
+            ],
+            [
+                [100, 100, 150, 150],
+                [100, 100, 150, 150],  # this will be suppressed
+            ],
+        ], dtype=keras.backend.floatx())
+        boxes = keras.backend.constant(boxes)
+
+        classification = np.array([
+            [
+                [0, 0.9],  # this will be suppressed
+                [0, 1],
+            ],
+            [
+                [1,   0],
+                [0.9, 0],  # this will be suppressed
+            ],
+        ], dtype=keras.backend.floatx())
+        classification = keras.backend.constant(classification)
+
+        # compute output
+        actual_boxes, actual_scores, actual_labels = filter_detections_layer.call([boxes, classification])
+        actual_boxes  = keras.backend.eval(actual_boxes)
+        actual_scores = keras.backend.eval(actual_scores)
+        actual_labels = keras.backend.eval(actual_labels)
+
+        # define expected output
+        expected_boxes = -1 * np.ones((2, 300, 4), dtype=keras.backend.floatx())
+        expected_boxes[0, 0, :] = [0, 0, 10, 10]
+        expected_boxes[1, 0, :] = [100, 100, 150, 150]
+
+        expected_scores = -1 * np.ones((2, 300), dtype=keras.backend.floatx())
+        expected_scores[0, 0] = 1
+        expected_scores[1, 0] = 1
+
+        expected_labels = -1 * np.ones((2, 300), dtype=keras.backend.floatx())
+        expected_labels[0, 0] = 1
+        expected_labels[1, 0] = 0
+
+        # assert actual and expected are equal
+        np.testing.assert_array_equal(actual_boxes, expected_boxes)
+        np.testing.assert_array_equal(actual_scores, expected_scores)
+        np.testing.assert_array_equal(actual_labels, expected_labels)

+"""
+Copyright 2017-2018 Fizyr (https://fizyr.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from tensorflow import keras
+import keras_retinanet.backend
+import keras_retinanet.layers
+
+import numpy as np
+
+
+class TestAnchors(object):
+    def test_simple(self):
+        # create simple Anchors layer
+        anchors_layer = keras_retinanet.layers.Anchors(
+            size=32,
+            stride=8,
+            ratios=np.array([1], keras.backend.floatx()),
+            scales=np.array([1], keras.backend.floatx()),
+        )
+
+        # create fake features input (only shape is used anyway)
+        features = np.zeros((1, 2, 2, 1024), dtype=keras.backend.floatx())
+        features = keras.backend.variable(features)
+
+        # call the Anchors layer
+        anchors = anchors_layer.call(features)
+        anchors = keras.backend.eval(anchors)
+
+        # expected anchor values
+        expected = np.array([[
+            [-12, -12, 20, 20],
+            [-4 , -12, 28, 20],
+            [-12, -4 , 20, 28],
+            [-4 , -4 , 28, 28],
+        ]], dtype=keras.backend.floatx())
+
+        # test anchor values
+        np.testing.assert_array_equal(anchors, expected)
+
+    # mark test to fail
+    def test_mini_batch(self):
+        # create simple Anchors layer
+        anchors_layer = keras_retinanet.layers.Anchors(
+            size=32,
+            stride=8,
+            ratios=np.array([1], dtype=keras.backend.floatx()),
+            scales=np.array([1], dtype=keras.backend.floatx()),
+        )
+
+        # create fake features input with batch_size=2
+        features = np.zeros((2, 2, 2, 1024), dtype=keras.backend.floatx())
+        features = keras.backend.variable(features)
+
+        # call the Anchors layer
+        anchors = anchors_layer.call(features)
+        anchors = keras.backend.eval(anchors)
+
+        # expected anchor values
+        expected = np.array([[
+            [-12, -12, 20, 20],
+            [-4 , -12, 28, 20],
+            [-12, -4 , 20, 28],
+            [-4 , -4 , 28, 28],
+        ]], dtype=keras.backend.floatx())
+        expected = np.tile(expected, (2, 1, 1))
+
+        # test anchor values
+        np.testing.assert_array_equal(anchors, expected)
+
+
+class TestUpsampleLike(object):
+    def test_simple(self):
+        # create simple UpsampleLike layer
+        upsample_like_layer = keras_retinanet.layers.UpsampleLike()
+
+        # create input source
+        source   = np.zeros((1, 2, 2, 1), dtype=keras.backend.floatx())
+        source   = keras.backend.variable(source)
+        target   = np.zeros((1, 5, 5, 1), dtype=keras.backend.floatx())
+        expected = target
+        target   = keras.backend.variable(target)
+
+        # compute output
+        actual = upsample_like_layer.call([source, target])
+        actual = keras.backend.eval(actual)
+
+        np.testing.assert_array_equal(actual, expected)
+
+    def test_mini_batch(self):
+        # create simple UpsampleLike layer
+        upsample_like_layer = keras_retinanet.layers.UpsampleLike()
+
+        # create input source
+        source = np.zeros((2, 2, 2, 1), dtype=keras.backend.floatx())
+        source = keras.backend.variable(source)
+
+        target   = np.zeros((2, 5, 5, 1), dtype=keras.backend.floatx())
+        expected = target
+        target   = keras.backend.variable(target)
+
+        # compute output
+        actual = upsample_like_layer.call([source, target])
+        actual = keras.backend.eval(actual)
+
+        np.testing.assert_array_equal(actual, expected)
+
+
+class TestRegressBoxes(object):
+    def test_simple(self):
+        mean = [0, 0, 0, 0]
+        std  = [0.2, 0.2, 0.2, 0.2]
+
+        # create simple RegressBoxes layer
+        regress_boxes_layer = keras_retinanet.layers.RegressBoxes(mean=mean, std=std)
+
+        # create input
+        anchors = np.array([[
+            [0 , 0 , 10 , 10 ],
+            [50, 50, 100, 100],
+            [20, 20, 40 , 40 ],
+        ]], dtype=keras.backend.floatx())
+        anchors = keras.backend.variable(anchors)
+
+        regression = np.array([[
+            [0  , 0  , 0  , 0  ],
+            [0.1, 0.1, 0  , 0  ],
+            [0  , 0  , 0.1, 0.1],
+        ]], dtype=keras.backend.floatx())
+        regression = keras.backend.variable(regression)
+
+        # compute output
+        actual = regress_boxes_layer.call([anchors, regression])
+        actual = keras.backend.eval(actual)
+
+        # compute expected output
+        expected = np.array([[
+            [0 , 0 , 10  , 10  ],
+            [51, 51, 100 , 100 ],
+            [20, 20, 40.4, 40.4],
+        ]], dtype=keras.backend.floatx())
+
+        np.testing.assert_array_almost_equal(actual, expected, decimal=2)
+
+    # mark test to fail
+    def test_mini_batch(self):
+        mean = [0, 0, 0, 0]
+        std  = [0.2, 0.2, 0.2, 0.2]
+
+        # create simple RegressBoxes layer
+        regress_boxes_layer = keras_retinanet.layers.RegressBoxes(mean=mean, std=std)
+
+        # create input
+        anchors = np.array([
+            [
+                [0 , 0 , 10 , 10 ],  # 1
+                [50, 50, 100, 100],  # 2
+                [20, 20, 40 , 40 ],  # 3
+            ],
+            [
+                [20, 20, 40 , 40 ],  # 3
+                [0 , 0 , 10 , 10 ],  # 1
+                [50, 50, 100, 100],  # 2
+            ],
+        ], dtype=keras.backend.floatx())
+        anchors = keras.backend.variable(anchors)
+
+        regression = np.array([
+            [
+                [0  , 0  , 0  , 0  ],  # 1
+                [0.1, 0.1, 0  , 0  ],  # 2
+                [0  , 0  , 0.1, 0.1],  # 3
+            ],
+            [
+                [0  , 0  , 0.1, 0.1],  # 3
+                [0  , 0  , 0  , 0  ],  # 1
+                [0.1, 0.1, 0  , 0  ],  # 2
+            ],
+        ], dtype=keras.backend.floatx())
+        regression = keras.backend.variable(regression)
+
+        # compute output
+        actual = regress_boxes_layer.call([anchors, regression])
+        actual = keras.backend.eval(actual)
+
+        # compute expected output
+        expected = np.array([
+            [
+                [0 , 0 , 10  , 10  ],  # 1
+                [51, 51, 100 , 100 ],  # 2
+                [20, 20, 40.4, 40.4],  # 3
+            ],
+            [
+                [20, 20, 40.4, 40.4],  # 3
+                [0 , 0 , 10  , 10  ],  # 1
+                [51, 51, 100 , 100 ],  # 2
+            ],
+        ], dtype=keras.backend.floatx())
+
+        np.testing.assert_array_almost_equal(actual, expected, decimal=2)

+"""
+Copyright 2018 vidosits (https://github.com/vidosits/)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import warnings
+import pytest
+import numpy as np
+from tensorflow import keras
+from keras_retinanet import losses
+from keras_retinanet.models.densenet import DenseNetBackbone
+
+parameters = ['densenet121']
+
+
+@pytest.mark.parametrize("backbone", parameters)
+def test_backbone(backbone):
+    # ignore warnings in this test
+    warnings.simplefilter('ignore')
+
+    num_classes = 10
+
+    inputs = np.zeros((1, 200, 400, 3), dtype=np.float32)
+    targets = [np.zeros((1, 14814, 5), dtype=np.float32), np.zeros((1, 14814, num_classes + 1))]
+
+    inp = keras.layers.Input(inputs[0].shape)
+
+    densenet_backbone = DenseNetBackbone(backbone)
+    model = densenet_backbone.retinanet(num_classes=num_classes, inputs=inp)
+    model.summary()
+
+    # compile model
+    model.compile(
+        loss={
+            'regression': losses.smooth_l1(),
+            'classification': losses.focal()
+        },
+        optimizer=keras.optimizers.Adam(lr=1e-5, clipnorm=0.001))
+
+    model.fit(inputs, targets, batch_size=1)