test_detection.py

#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
#
# 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 paddle.fluid as fluid
import paddle.fluid.layers as layers
from paddle.fluid.layers import detection
from paddle.fluid.framework import Program, program_guard
import unittest
import contextlib
import numpy as np
from unittests.test_imperative_base import new_program_scope
from paddle.fluid.dygraph import base
from paddle.fluid import core
import paddle

paddle.enable_static()


class LayerTest(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.seed = 111

    @classmethod
    def tearDownClass(cls):
        pass

    def _get_place(self, force_to_use_cpu=False):
        # this option for ops that only have cpu kernel
        if force_to_use_cpu:
            return core.CPUPlace()
        else:
            if core.is_compiled_with_cuda():
                return core.CUDAPlace(0)
            return core.CPUPlace()

    @contextlib.contextmanager
    def static_graph(self):
        with new_program_scope():
            fluid.default_startup_program().random_seed = self.seed
            fluid.default_main_program().random_seed = self.seed
            yield

    def get_static_graph_result(self,
                                feed,
                                fetch_list,
                                with_lod=False,
                                force_to_use_cpu=False):
        exe = fluid.Executor(self._get_place(force_to_use_cpu))
        exe.run(fluid.default_startup_program())
        return exe.run(fluid.default_main_program(),
                       feed=feed,
                       fetch_list=fetch_list,
                       return_numpy=(not with_lod))

    @contextlib.contextmanager
    def dynamic_graph(self, force_to_use_cpu=False):
        with fluid.dygraph.guard(
                self._get_place(force_to_use_cpu=force_to_use_cpu)):
            fluid.default_startup_program().random_seed = self.seed
            fluid.default_main_program().random_seed = self.seed
            yield


class TestDetection(unittest.TestCase):

    def test_detection_output(self):
        program = Program()
        with program_guard(program):
            pb = layers.data(name='prior_box',
                             shape=[10, 4],
                             append_batch_size=False,
                             dtype='float32')
            pbv = layers.data(name='prior_box_var',
                              shape=[10, 4],
                              append_batch_size=False,
                              dtype='float32')
            loc = layers.data(name='target_box',
                              shape=[2, 10, 4],
                              append_batch_size=False,
                              dtype='float32')
            scores = layers.data(name='scores',
                                 shape=[2, 10, 20],
                                 append_batch_size=False,
                                 dtype='float32')
            out = layers.detection_output(scores=scores,
                                          loc=loc,
                                          prior_box=pb,
                                          prior_box_var=pbv)
            out2, index = layers.detection_output(scores=scores,
                                                  loc=loc,
                                                  prior_box=pb,
                                                  prior_box_var=pbv,
                                                  return_index=True)
            self.assertIsNotNone(out)
            self.assertIsNotNone(out2)
            self.assertIsNotNone(index)
            self.assertEqual(out.shape[-1], 6)
        print(str(program))

    def test_box_coder_api(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[4], dtype='float32')
            y = layers.data(name='z', shape=[4], dtype='float32', lod_level=1)
            bcoder = layers.box_coder(prior_box=x,
                                      prior_box_var=[0.1, 0.2, 0.1, 0.2],
                                      target_box=y,
                                      code_type='encode_center_size')
            self.assertIsNotNone(bcoder)
        print(str(program))

    def test_box_coder_error(self):
        program = Program()
        with program_guard(program):
            x1 = fluid.data(name='x1', shape=[10, 4], dtype='int32')
            y1 = fluid.data(name='y1',
                            shape=[10, 4],
                            dtype='float32',
                            lod_level=1)
            x2 = fluid.data(name='x2', shape=[10, 4], dtype='float32')
            y2 = fluid.data(name='y2',
                            shape=[10, 4],
                            dtype='int32',
                            lod_level=1)

            self.assertRaises(TypeError,
                              layers.box_coder,
                              prior_box=x1,
                              prior_box_var=[0.1, 0.2, 0.1, 0.2],
                              target_box=y1,
                              code_type='encode_center_size')
            self.assertRaises(TypeError,
                              layers.box_coder,
                              prior_box=x2,
                              prior_box_var=[0.1, 0.2, 0.1, 0.2],
                              target_box=y2,
                              code_type='encode_center_size')

    def test_detection_api(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[4], dtype='float32')
            y = layers.data(name='y', shape=[4], dtype='float32')
            z = layers.data(name='z', shape=[4], dtype='float32', lod_level=1)
            iou = layers.iou_similarity(x=x, y=y)
            bcoder = layers.box_coder(prior_box=x,
                                      prior_box_var=y,
                                      target_box=z,
                                      code_type='encode_center_size')
            self.assertIsNotNone(iou)
            self.assertIsNotNone(bcoder)

            matched_indices, matched_dist = layers.bipartite_match(iou)
            self.assertIsNotNone(matched_indices)
            self.assertIsNotNone(matched_dist)

            gt = layers.data(name='gt',
                             shape=[1, 1],
                             dtype='int32',
                             lod_level=1)
            trg, trg_weight = layers.target_assign(gt,
                                                   matched_indices,
                                                   mismatch_value=0)
            self.assertIsNotNone(trg)
            self.assertIsNotNone(trg_weight)

            gt2 = layers.data(name='gt2',
                              shape=[10, 4],
                              dtype='float32',
                              lod_level=1)
            trg, trg_weight = layers.target_assign(gt2,
                                                   matched_indices,
                                                   mismatch_value=0)
            self.assertIsNotNone(trg)
            self.assertIsNotNone(trg_weight)

        print(str(program))

    def test_ssd_loss(self):
        program = Program()
        with program_guard(program):
            pb = layers.data(name='prior_box',
                             shape=[10, 4],
                             append_batch_size=False,
                             dtype='float32')
            pbv = layers.data(name='prior_box_var',
                              shape=[10, 4],
                              append_batch_size=False,
                              dtype='float32')
            loc = layers.data(name='target_box', shape=[10, 4], dtype='float32')
            scores = layers.data(name='scores', shape=[10, 21], dtype='float32')
            gt_box = layers.data(name='gt_box',
                                 shape=[4],
                                 lod_level=1,
                                 dtype='float32')
            gt_label = layers.data(name='gt_label',
                                   shape=[1],
                                   lod_level=1,
                                   dtype='int32')
            loss = layers.ssd_loss(loc, scores, gt_box, gt_label, pb, pbv)
            self.assertIsNotNone(loss)
            self.assertEqual(loss.shape[-1], 1)
        print(str(program))


class TestPriorBox(unittest.TestCase):

    def test_prior_box(self):
        program = Program()
        with program_guard(program):
            data_shape = [3, 224, 224]
            images = fluid.layers.data(name='pixel',
                                       shape=data_shape,
                                       dtype='float32')
            conv1 = fluid.layers.conv2d(images, 3, 3, 2)
            box, var = layers.prior_box(input=conv1,
                                        image=images,
                                        min_sizes=[100.0],
                                        aspect_ratios=[1.],
                                        flip=True,
                                        clip=True)
            assert len(box.shape) == 4
            assert box.shape == var.shape
            assert box.shape[3] == 4


class TestPriorBox2(unittest.TestCase):

    def test_prior_box(self):
        program = Program()
        with program_guard(program):
            data_shape = [None, 3, None, None]
            images = fluid.data(name='pixel', shape=data_shape, dtype='float32')
            conv1 = fluid.layers.conv2d(images, 3, 3, 2)
            box, var = layers.prior_box(input=conv1,
                                        image=images,
                                        min_sizes=[100.0],
                                        aspect_ratios=[1.],
                                        flip=True,
                                        clip=True)
            assert len(box.shape) == 4
            assert box.shape == var.shape
            assert box.shape[3] == 4


class TestDensityPriorBox(unittest.TestCase):

    def test_density_prior_box(self):
        program = Program()
        with program_guard(program):
            data_shape = [3, 224, 224]
            images = fluid.layers.data(name='pixel',
                                       shape=data_shape,
                                       dtype='float32')
            conv1 = fluid.layers.conv2d(images, 3, 3, 2)
            box, var = layers.density_prior_box(input=conv1,
                                                image=images,
                                                densities=[3, 4],
                                                fixed_sizes=[50., 60.],
                                                fixed_ratios=[1.0],
                                                clip=True)
            assert len(box.shape) == 4
            assert box.shape == var.shape
            assert box.shape[-1] == 4


class TestAnchorGenerator(unittest.TestCase):

    def test_anchor_generator(self):
        data_shape = [3, 224, 224]
        images = fluid.layers.data(name='pixel',
                                   shape=data_shape,
                                   dtype='float32')
        conv1 = fluid.layers.conv2d(images, 3, 3, 2)
        anchor, var = fluid.layers.anchor_generator(
            input=conv1,
            anchor_sizes=[64, 128, 256, 512],
            aspect_ratios=[0.5, 1.0, 2.0],
            variance=[0.1, 0.1, 0.2, 0.2],
            stride=[16.0, 16.0],
            offset=0.5)
        assert len(anchor.shape) == 4
        assert anchor.shape == var.shape
        assert anchor.shape[3] == 4


class TestGenerateProposalLabels(unittest.TestCase):

    def check_out(self, outs):
        rois = outs[0]
        labels_int32 = outs[1]
        bbox_targets = outs[2]
        bbox_inside_weights = outs[3]
        bbox_outside_weights = outs[4]
        assert rois.shape[1] == 4
        assert rois.shape[0] == labels_int32.shape[0]
        assert rois.shape[0] == bbox_targets.shape[0]
        assert rois.shape[0] == bbox_inside_weights.shape[0]
        assert rois.shape[0] == bbox_outside_weights.shape[0]
        assert bbox_targets.shape[1] == 4 * self.class_nums
        assert bbox_inside_weights.shape[1] == 4 * self.class_nums
        assert bbox_outside_weights.shape[1] == 4 * self.class_nums
        if len(outs) == 6:
            max_overlap_with_gt = outs[5]
            assert max_overlap_with_gt.shape[0] == rois.shape[0]

    def test_generate_proposal_labels(self):
        program = Program()
        with program_guard(program):
            rpn_rois = fluid.data(name='rpn_rois',
                                  shape=[4, 4],
                                  dtype='float32',
                                  lod_level=1)
            gt_classes = fluid.data(name='gt_classes',
                                    shape=[6],
                                    dtype='int32',
                                    lod_level=1)
            is_crowd = fluid.data(name='is_crowd',
                                  shape=[6],
                                  dtype='int32',
                                  lod_level=1)
            gt_boxes = fluid.data(name='gt_boxes',
                                  shape=[6, 4],
                                  dtype='float32',
                                  lod_level=1)
            im_info = fluid.data(name='im_info', shape=[1, 3], dtype='float32')
            max_overlap = fluid.data(name='max_overlap',
                                     shape=[4],
                                     dtype='float32',
                                     lod_level=1)
            self.class_nums = 5
            outs = fluid.layers.generate_proposal_labels(
                rpn_rois=rpn_rois,
                gt_classes=gt_classes,
                is_crowd=is_crowd,
                gt_boxes=gt_boxes,
                im_info=im_info,
                batch_size_per_im=2,
                fg_fraction=0.5,
                fg_thresh=0.5,
                bg_thresh_hi=0.5,
                bg_thresh_lo=0.0,
                bbox_reg_weights=[0.1, 0.1, 0.2, 0.2],
                class_nums=self.class_nums)
            outs_1 = fluid.layers.generate_proposal_labels(
                rpn_rois=rpn_rois,
                gt_classes=gt_classes,
                is_crowd=is_crowd,
                gt_boxes=gt_boxes,
                im_info=im_info,
                batch_size_per_im=2,
                fg_fraction=0.5,
                fg_thresh=0.5,
                bg_thresh_hi=0.5,
                bg_thresh_lo=0.0,
                bbox_reg_weights=[0.1, 0.1, 0.2, 0.2],
                class_nums=self.class_nums,
                is_cascade_rcnn=True,
                max_overlap=max_overlap,
                return_max_overlap=True)

            self.check_out(outs)
            self.check_out(outs_1)
            rois = outs[0]


class TestGenerateMaskLabels(unittest.TestCase):

    def test_generate_mask_labels(self):
        program = Program()
        with program_guard(program):
            im_info = layers.data(name='im_info',
                                  shape=[1, 3],
                                  dtype='float32',
                                  lod_level=1,
                                  append_batch_size=False)
            gt_classes = layers.data(name='gt_classes',
                                     shape=[2, 1],
                                     dtype='int32',
                                     lod_level=1,
                                     append_batch_size=False)
            is_crowd = layers.data(name='is_crowd',
                                   shape=[2, 1],
                                   dtype='int32',
                                   lod_level=1,
                                   append_batch_size=False)
            gt_segms = layers.data(name='gt_segms',
                                   shape=[20, 2],
                                   dtype='float32',
                                   lod_level=3,
                                   append_batch_size=False)
            rois = layers.data(name='rois',
                               shape=[4, 4],
                               dtype='float32',
                               lod_level=1,
                               append_batch_size=False)
            labels_int32 = layers.data(name='labels_int32',
                                       shape=[4, 1],
                                       dtype='int32',
                                       lod_level=1,
                                       append_batch_size=False)
            num_classes = 5
            resolution = 14
            outs = fluid.layers.generate_mask_labels(im_info=im_info,
                                                     gt_classes=gt_classes,
                                                     is_crowd=is_crowd,
                                                     gt_segms=gt_segms,
                                                     rois=rois,
                                                     labels_int32=labels_int32,
                                                     num_classes=num_classes,
                                                     resolution=resolution)
            mask_rois, roi_has_mask_int32, mask_int32 = outs
            assert mask_rois.shape[1] == 4
            assert mask_int32.shape[1] == num_classes * resolution * resolution


class TestMultiBoxHead(unittest.TestCase):

    def test_multi_box_head(self):
        data_shape = [3, 224, 224]
        mbox_locs, mbox_confs, box, var = self.multi_box_head_output(data_shape)

        assert len(box.shape) == 2
        assert box.shape == var.shape
        assert box.shape[1] == 4
        assert mbox_locs.shape[1] == mbox_confs.shape[1]

    def multi_box_head_output(self, data_shape):
        images = fluid.layers.data(name='pixel',
                                   shape=data_shape,
                                   dtype='float32')
        conv1 = fluid.layers.conv2d(images, 3, 3, 2)
        conv2 = fluid.layers.conv2d(conv1, 3, 3, 2)
        conv3 = fluid.layers.conv2d(conv2, 3, 3, 2)
        conv4 = fluid.layers.conv2d(conv3, 3, 3, 2)
        conv5 = fluid.layers.conv2d(conv4, 3, 3, 2)

        mbox_locs, mbox_confs, box, var = layers.multi_box_head(
            inputs=[conv1, conv2, conv3, conv4, conv5, conv5],
            image=images,
            num_classes=21,
            min_ratio=20,
            max_ratio=90,
            aspect_ratios=[[2.], [2., 3.], [2., 3.], [2., 3.], [2.], [2.]],
            base_size=300,
            offset=0.5,
            flip=True,
            clip=True)

        return mbox_locs, mbox_confs, box, var


class TestDetectionMAP(unittest.TestCase):

    def test_detection_map(self):
        program = Program()
        with program_guard(program):
            detect_res = layers.data(name='detect_res',
                                     shape=[10, 6],
                                     append_batch_size=False,
                                     dtype='float32')
            label = layers.data(name='label',
                                shape=[10, 6],
                                append_batch_size=False,
                                dtype='float32')

            map_out = detection.detection_map(detect_res, label, 21)
            self.assertIsNotNone(map_out)
            self.assertEqual(map_out.shape, (1, ))
        print(str(program))


class TestRpnTargetAssign(unittest.TestCase):

    def test_rpn_target_assign(self):
        program = Program()
        with program_guard(program):
            bbox_pred_shape = [10, 50, 4]
            cls_logits_shape = [10, 50, 2]
            anchor_shape = [50, 4]

            bbox_pred = layers.data(name='bbox_pred',
                                    shape=bbox_pred_shape,
                                    append_batch_size=False,
                                    dtype='float32')
            cls_logits = layers.data(name='cls_logits',
                                     shape=cls_logits_shape,
                                     append_batch_size=False,
                                     dtype='float32')
            anchor_box = layers.data(name='anchor_box',
                                     shape=anchor_shape,
                                     append_batch_size=False,
                                     dtype='float32')
            anchor_var = layers.data(name='anchor_var',
                                     shape=anchor_shape,
                                     append_batch_size=False,
                                     dtype='float32')
            gt_boxes = layers.data(name='gt_boxes',
                                   shape=[4],
                                   lod_level=1,
                                   dtype='float32')
            is_crowd = layers.data(name='is_crowd',
                                   shape=[1, 10],
                                   dtype='int32',
                                   lod_level=1,
                                   append_batch_size=False)
            im_info = layers.data(name='im_info',
                                  shape=[1, 3],
                                  dtype='float32',
                                  lod_level=1,
                                  append_batch_size=False)
            outs = layers.rpn_target_assign(bbox_pred=bbox_pred,
                                            cls_logits=cls_logits,
                                            anchor_box=anchor_box,
                                            anchor_var=anchor_var,
                                            gt_boxes=gt_boxes,
                                            is_crowd=is_crowd,
                                            im_info=im_info,
                                            rpn_batch_size_per_im=256,
                                            rpn_straddle_thresh=0.0,
                                            rpn_fg_fraction=0.5,
                                            rpn_positive_overlap=0.7,
                                            rpn_negative_overlap=0.3,
                                            use_random=False)
            pred_scores = outs[0]
            pred_loc = outs[1]
            tgt_lbl = outs[2]
            tgt_bbox = outs[3]
            bbox_inside_weight = outs[4]

            self.assertIsNotNone(pred_scores)
            self.assertIsNotNone(pred_loc)
            self.assertIsNotNone(tgt_lbl)
            self.assertIsNotNone(tgt_bbox)
            self.assertIsNotNone(bbox_inside_weight)
            assert pred_scores.shape[1] == 1
            assert pred_loc.shape[1] == 4
            assert pred_loc.shape[1] == tgt_bbox.shape[1]
            print(str(program))


class TestGenerateProposals(LayerTest):

    def test_generate_proposals(self):
        scores_np = np.random.rand(2, 3, 4, 4).astype('float32')
        bbox_deltas_np = np.random.rand(2, 12, 4, 4).astype('float32')
        im_info_np = np.array([[8, 8, 0.5], [6, 6, 0.5]]).astype('float32')
        anchors_np = np.reshape(np.arange(4 * 4 * 3 * 4),
                                [4, 4, 3, 4]).astype('float32')
        variances_np = np.ones((4, 4, 3, 4)).astype('float32')

        with self.static_graph():
            scores = fluid.data(name='scores',
                                shape=[2, 3, 4, 4],
                                dtype='float32')
            bbox_deltas = fluid.data(name='bbox_deltas',
                                     shape=[2, 12, 4, 4],
                                     dtype='float32')
            im_info = fluid.data(name='im_info', shape=[2, 3], dtype='float32')
            anchors = fluid.data(name='anchors',
                                 shape=[4, 4, 3, 4],
                                 dtype='float32')
            variances = fluid.data(name='var',
                                   shape=[4, 4, 3, 4],
                                   dtype='float32')
            rois, roi_probs, rois_num = fluid.layers.generate_proposals(
                scores,
                bbox_deltas,
                im_info,
                anchors,
                variances,
                pre_nms_top_n=10,
                post_nms_top_n=5,
                return_rois_num=True)
            rois_stat, roi_probs_stat, rois_num_stat = self.get_static_graph_result(
                feed={
                    'scores': scores_np,
                    'bbox_deltas': bbox_deltas_np,
                    'im_info': im_info_np,
                    'anchors': anchors_np,
                    'var': variances_np
                },
                fetch_list=[rois, roi_probs, rois_num],
                with_lod=False)

        with self.dynamic_graph():
            scores_dy = base.to_variable(scores_np)
            bbox_deltas_dy = base.to_variable(bbox_deltas_np)
            im_info_dy = base.to_variable(im_info_np)
            anchors_dy = base.to_variable(anchors_np)
            variances_dy = base.to_variable(variances_np)
            rois, roi_probs, rois_num = fluid.layers.generate_proposals(
                scores_dy,
                bbox_deltas_dy,
                im_info_dy,
                anchors_dy,
                variances_dy,
                pre_nms_top_n=10,
                post_nms_top_n=5,
                return_rois_num=True)
            rois_dy = rois.numpy()
            roi_probs_dy = roi_probs.numpy()
            rois_num_dy = rois_num.numpy()

        self.assertTrue(np.array_equal(np.array(rois_stat), rois_dy))
        self.assertTrue(np.array_equal(np.array(roi_probs_stat), roi_probs_dy))
        self.assertTrue(np.array_equal(np.array(rois_num_stat), rois_num_dy))


class TestYoloDetection(unittest.TestCase):

    def test_yolov3_loss(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[30, 7, 7], dtype='float32')
            gt_box = layers.data(name='gt_box', shape=[10, 4], dtype='float32')
            gt_label = layers.data(name='gt_label', shape=[10], dtype='int32')
            gt_score = layers.data(name='gt_score', shape=[10], dtype='float32')
            loss = layers.yolov3_loss(x,
                                      gt_box,
                                      gt_label, [10, 13, 30, 13], [0, 1],
                                      10,
                                      0.7,
                                      32,
                                      gt_score=gt_score,
                                      use_label_smooth=False)

            self.assertIsNotNone(loss)

    def test_yolo_box(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[30, 7, 7], dtype='float32')
            img_size = layers.data(name='img_size', shape=[2], dtype='int32')
            boxes, scores = layers.yolo_box(x, img_size, [10, 13, 30, 13], 10,
                                            0.01, 32)
            self.assertIsNotNone(boxes)
            self.assertIsNotNone(scores)

    def test_yolov3_loss_with_scale(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[30, 7, 7], dtype='float32')
            gt_box = layers.data(name='gt_box', shape=[10, 4], dtype='float32')
            gt_label = layers.data(name='gt_label', shape=[10], dtype='int32')
            gt_score = layers.data(name='gt_score', shape=[10], dtype='float32')
            loss = layers.yolov3_loss(x,
                                      gt_box,
                                      gt_label, [10, 13, 30, 13], [0, 1],
                                      10,
                                      0.7,
                                      32,
                                      gt_score=gt_score,
                                      use_label_smooth=False,
                                      scale_x_y=1.2)

            self.assertIsNotNone(loss)

    def test_yolo_box_with_scale(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[30, 7, 7], dtype='float32')
            img_size = layers.data(name='img_size', shape=[2], dtype='int32')
            boxes, scores = layers.yolo_box(x,
                                            img_size, [10, 13, 30, 13],
                                            10,
                                            0.01,
                                            32,
                                            scale_x_y=1.2)
            self.assertIsNotNone(boxes)
            self.assertIsNotNone(scores)


class TestBoxClip(unittest.TestCase):

    def test_box_clip(self):
        program = Program()
        with program_guard(program):
            input_box = layers.data(name='input_box',
                                    shape=[7, 4],
                                    dtype='float32',
                                    lod_level=1)
            im_info = layers.data(name='im_info', shape=[3], dtype='float32')
            out = layers.box_clip(input_box, im_info)
            self.assertIsNotNone(out)


class TestMulticlassNMS(unittest.TestCase):

    def test_multiclass_nms(self):
        program = Program()
        with program_guard(program):
            bboxes = layers.data(name='bboxes',
                                 shape=[-1, 10, 4],
                                 dtype='float32')
            scores = layers.data(name='scores', shape=[-1, 10], dtype='float32')
            output = layers.multiclass_nms(bboxes, scores, 0.3, 400, 200, 0.7)
            self.assertIsNotNone(output)

    def test_multiclass_nms_error(self):
        program = Program()
        with program_guard(program):
            bboxes1 = fluid.data(name='bboxes1',
                                 shape=[10, 10, 4],
                                 dtype='int32')
            scores1 = fluid.data(name='scores1',
                                 shape=[10, 10],
                                 dtype='float32')
            bboxes2 = fluid.data(name='bboxes2',
                                 shape=[10, 10, 4],
                                 dtype='float32')
            scores2 = fluid.data(name='scores2', shape=[10, 10], dtype='int32')
            self.assertRaises(TypeError,
                              layers.multiclass_nms,
                              bboxes=bboxes1,
                              scores=scores1,
                              score_threshold=0.5,
                              nms_top_k=400,
                              keep_top_k=200)
            self.assertRaises(TypeError,
                              layers.multiclass_nms,
                              bboxes=bboxes2,
                              scores=scores2,
                              score_threshold=0.5,
                              nms_top_k=400,
                              keep_top_k=200)


class TestMulticlassNMS2(unittest.TestCase):

    def test_multiclass_nms2(self):
        program = Program()
        with program_guard(program):
            bboxes = layers.data(name='bboxes',
                                 shape=[-1, 10, 4],
                                 dtype='float32')
            scores = layers.data(name='scores', shape=[-1, 10], dtype='float32')
            output = fluid.contrib.multiclass_nms2(bboxes, scores, 0.3, 400,
                                                   200, 0.7)
            output2, index = fluid.contrib.multiclass_nms2(bboxes,
                                                           scores,
                                                           0.3,
                                                           400,
                                                           200,
                                                           0.7,
                                                           return_index=True)
            self.assertIsNotNone(output)
            self.assertIsNotNone(output2)
            self.assertIsNotNone(index)


class TestCollectFpnPropsals(LayerTest):

    def test_collect_fpn_proposals(self):
        multi_bboxes_np = []
        multi_scores_np = []
        rois_num_per_level_np = []
        for i in range(4):
            bboxes_np = np.random.rand(5, 4).astype('float32')
            scores_np = np.random.rand(5, 1).astype('float32')
            rois_num = np.array([2, 3]).astype('int32')
            multi_bboxes_np.append(bboxes_np)
            multi_scores_np.append(scores_np)
            rois_num_per_level_np.append(rois_num)

        with self.static_graph():
            multi_bboxes = []
            multi_scores = []
            rois_num_per_level = []
            for i in range(4):
                bboxes = fluid.data(name='rois' + str(i),
                                    shape=[5, 4],
                                    dtype='float32',
                                    lod_level=1)
                scores = fluid.data(name='scores' + str(i),
                                    shape=[5, 1],
                                    dtype='float32',
                                    lod_level=1)
                rois_num = fluid.data(name='rois_num' + str(i),
                                      shape=[None],
                                      dtype='int32')

                multi_bboxes.append(bboxes)
                multi_scores.append(scores)
                rois_num_per_level.append(rois_num)

            fpn_rois, rois_num = layers.collect_fpn_proposals(
                multi_bboxes,
                multi_scores,
                2,
                5,
                10,
                rois_num_per_level=rois_num_per_level)
            feed = {}
            for i in range(4):
                feed['rois' + str(i)] = multi_bboxes_np[i]
                feed['scores' + str(i)] = multi_scores_np[i]
                feed['rois_num' + str(i)] = rois_num_per_level_np[i]
            fpn_rois_stat, rois_num_stat = self.get_static_graph_result(
                feed=feed, fetch_list=[fpn_rois, rois_num], with_lod=True)
            fpn_rois_stat = np.array(fpn_rois_stat)
            rois_num_stat = np.array(rois_num_stat)

        with self.dynamic_graph():
            multi_bboxes_dy = []
            multi_scores_dy = []
            rois_num_per_level_dy = []
            for i in range(4):
                bboxes_dy = base.to_variable(multi_bboxes_np[i])
                scores_dy = base.to_variable(multi_scores_np[i])
                rois_num_dy = base.to_variable(rois_num_per_level_np[i])
                multi_bboxes_dy.append(bboxes_dy)
                multi_scores_dy.append(scores_dy)
                rois_num_per_level_dy.append(rois_num_dy)
            fpn_rois_dy, rois_num_dy = fluid.layers.collect_fpn_proposals(
                multi_bboxes_dy,
                multi_scores_dy,
                2,
                5,
                10,
                rois_num_per_level=rois_num_per_level_dy)
            fpn_rois_dy = fpn_rois_dy.numpy()
            rois_num_dy = rois_num_dy.numpy()

        self.assertTrue(np.array_equal(fpn_rois_stat, fpn_rois_dy))
        self.assertTrue(np.array_equal(rois_num_stat, rois_num_dy))

    def test_collect_fpn_proposals_error(self):

        def generate_input(bbox_type, score_type, name):
            multi_bboxes = []
            multi_scores = []
            for i in range(4):
                bboxes = fluid.data(name='rois' + name + str(i),
                                    shape=[10, 4],
                                    dtype=bbox_type,
                                    lod_level=1)
                scores = fluid.data(name='scores' + name + str(i),
                                    shape=[10, 1],
                                    dtype=score_type,
                                    lod_level=1)
                multi_bboxes.append(bboxes)
                multi_scores.append(scores)
            return multi_bboxes, multi_scores

        program = Program()
        with program_guard(program):
            bbox1 = fluid.data(name='rois',
                               shape=[5, 10, 4],
                               dtype='float32',
                               lod_level=1)
            score1 = fluid.data(name='scores',
                                shape=[5, 10, 1],
                                dtype='float32',
                                lod_level=1)
            bbox2, score2 = generate_input('int32', 'float32', '2')
            self.assertRaises(TypeError,
                              layers.collect_fpn_proposals,
                              multi_rois=bbox1,
                              multi_scores=score1,
                              min_level=2,
                              max_level=5,
                              post_nms_top_n=2000)
            self.assertRaises(TypeError,
                              layers.collect_fpn_proposals,
                              multi_rois=bbox2,
                              multi_scores=score2,
                              min_level=2,
                              max_level=5,
                              post_nms_top_n=2000)


class TestDistributeFpnProposals(LayerTest):

    def test_distribute_fpn_proposals(self):
        rois_np = np.random.rand(10, 4).astype('float32')
        rois_num_np = np.array([4, 6]).astype('int32')
        with self.static_graph():
            rois = fluid.data(name='rois', shape=[10, 4], dtype='float32')
            rois_num = fluid.data(name='rois_num', shape=[None], dtype='int32')
            multi_rois, restore_ind, rois_num_per_level = layers.distribute_fpn_proposals(
                fpn_rois=rois,
                min_level=2,
                max_level=5,
                refer_level=4,
                refer_scale=224,
                rois_num=rois_num)
            fetch_list = multi_rois + [restore_ind] + rois_num_per_level
            output_stat = self.get_static_graph_result(feed={
                'rois': rois_np,
                'rois_num': rois_num_np
            },
                                                       fetch_list=fetch_list,
                                                       with_lod=True)
            output_stat_np = []
            for output in output_stat:
                output_np = np.array(output)
                if len(output_np) > 0:
                    output_stat_np.append(output_np)

        with self.dynamic_graph():
            rois_dy = base.to_variable(rois_np)
            rois_num_dy = base.to_variable(rois_num_np)
            multi_rois_dy, restore_ind_dy, rois_num_per_level_dy = layers.distribute_fpn_proposals(
                fpn_rois=rois_dy,
                min_level=2,
                max_level=5,
                refer_level=4,
                refer_scale=224,
                rois_num=rois_num_dy)
            print(type(multi_rois_dy))
            output_dy = multi_rois_dy + [restore_ind_dy] + rois_num_per_level_dy
            output_dy_np = []
            for output in output_dy:
                output_np = output.numpy()
                if len(output_np) > 0:
                    output_dy_np.append(output_np)

        for res_stat, res_dy in zip(output_stat_np, output_dy_np):
            self.assertTrue(np.array_equal(res_stat, res_dy))

    def test_distribute_fpn_proposals_error(self):
        program = Program()
        with program_guard(program):
            fpn_rois = fluid.data(name='data_error',
                                  shape=[10, 4],
                                  dtype='int32',
                                  lod_level=1)
            self.assertRaises(TypeError,
                              layers.distribute_fpn_proposals,
                              fpn_rois=fpn_rois,
                              min_level=2,
                              max_level=5,
                              refer_level=4,
                              refer_scale=224)


class TestBoxDecoderAndAssign(unittest.TestCase):

    def test_box_decoder_and_assign(self):
        program = Program()
        with program_guard(program):
            pb = fluid.data(name='prior_box', shape=[None, 4], dtype='float32')
            pbv = fluid.data(name='prior_box_var', shape=[4], dtype='float32')
            loc = fluid.data(name='target_box',
                             shape=[None, 4 * 81],
                             dtype='float32')
            scores = fluid.data(name='scores',
                                shape=[None, 81],
                                dtype='float32')
            decoded_box, output_assign_box = fluid.layers.box_decoder_and_assign(
                pb, pbv, loc, scores, 4.135)
            self.assertIsNotNone(decoded_box)
            self.assertIsNotNone(output_assign_box)

    def test_box_decoder_and_assign_error(self):

        def generate_input(pb_type, pbv_type, loc_type, score_type, name):
            pb = fluid.data(name='prior_box' + name,
                            shape=[None, 4],
                            dtype=pb_type)
            pbv = fluid.data(name='prior_box_var' + name,
                             shape=[4],
                             dtype=pbv_type)
            loc = fluid.data(name='target_box' + name,
                             shape=[None, 4 * 81],
                             dtype=loc_type)
            scores = fluid.data(name='scores' + name,
                                shape=[None, 81],
                                dtype=score_type)
            return pb, pbv, loc, scores

        program = Program()
        with program_guard(program):
            pb1, pbv1, loc1, scores1 = generate_input('int32', 'float32',
                                                      'float32', 'float32', '1')
            pb2, pbv2, loc2, scores2 = generate_input('float32', 'float32',
                                                      'int32', 'float32', '2')
            pb3, pbv3, loc3, scores3 = generate_input('float32', 'float32',
                                                      'float32', 'int32', '3')
            self.assertRaises(TypeError,
                              layers.box_decoder_and_assign,
                              prior_box=pb1,
                              prior_box_var=pbv1,
                              target_box=loc1,
                              box_score=scores1,
                              box_clip=4.0)
            self.assertRaises(TypeError,
                              layers.box_decoder_and_assign,
                              prior_box=pb2,
                              prior_box_var=pbv2,
                              target_box=loc2,
                              box_score=scores2,
                              box_clip=4.0)
            self.assertRaises(TypeError,
                              layers.box_decoder_and_assign,
                              prior_box=pb3,
                              prior_box_var=pbv3,
                              target_box=loc3,
                              box_score=scores3,
                              box_clip=4.0)


if __name__ == '__main__':
    paddle.enable_static()
    unittest.main()