test_detection.py 13.3 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14
#
# 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.

15 16
from __future__ import print_function

17 18 19
import paddle.fluid as fluid
import paddle.fluid.layers as layers
from paddle.fluid.framework import Program, program_guard
C
chengduoZH 已提交
20
import unittest
21 22


23
class TestDetection(unittest.TestCase):
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
    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',
Y
Yuan Gao 已提交
39
                shape=[2, 10, 4],
40 41 42 43
                append_batch_size=False,
                dtype='float32')
            scores = layers.data(
                name='scores',
Y
Yuan Gao 已提交
44
                shape=[2, 10, 20],
45 46 47 48 49
                append_batch_size=False,
                dtype='float32')
            out = layers.detection_output(
                scores=scores, loc=loc, prior_box=pb, prior_box_var=pbv)
            self.assertIsNotNone(out)
50
            self.assertEqual(out.shape[-1], 6)
51
        print(str(program))
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

    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)

86
        print(str(program))
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

    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)
110
        print(str(program))
111 112


113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
class TestPriorBox(unittest.TestCase):
    def test_prior_box(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)
        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


131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
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


149 150
class TestGenerateProposalLabels(unittest.TestCase):
    def test_generate_proposal_labels(self):
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
        program = Program()
        with program_guard(program):
            rpn_rois = layers.data(
                name='rpn_rois',
                shape=[4, 4],
                dtype='float32',
                lod_level=1,
                append_batch_size=False)
            gt_classes = layers.data(
                name='gt_classes',
                shape=[6],
                dtype='int32',
                lod_level=1,
                append_batch_size=False)
            is_crowd = layers.data(
                name='is_crowd',
                shape=[6],
                dtype='int32',
                lod_level=1,
                append_batch_size=False)
            gt_boxes = layers.data(
                name='gt_boxes',
                shape=[6, 4],
                dtype='float32',
                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)
            class_nums = 5
            rois, labels_int32, bbox_targets, bbox_inside_weights, bbox_outside_weights = 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=class_nums)
            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 * class_nums
            assert bbox_inside_weights.shape[1] == 4 * class_nums
            assert bbox_outside_weights.shape[1] == 4 * class_nums
205 206


207 208
class TestMultiBoxHead(unittest.TestCase):
    def test_multi_box_head(self):
209
        data_shape = [3, 224, 224]
210
        mbox_locs, mbox_confs, box, var = self.multi_box_head_output(data_shape)
211 212 213 214

        assert len(box.shape) == 2
        assert box.shape == var.shape
        assert box.shape[1] == 4
Y
Yuan Gao 已提交
215
        assert mbox_locs.shape[1] == mbox_confs.shape[1]
216 217

    def multi_box_head_output(self, data_shape):
C
chengduoZH 已提交
218 219
        images = fluid.layers.data(
            name='pixel', shape=data_shape, dtype='float32')
220 221 222 223 224
        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)
C
chengduoZH 已提交
225

226
        mbox_locs, mbox_confs, box, var = layers.multi_box_head(
C
chengduoZH 已提交
227 228
            inputs=[conv1, conv2, conv3, conv4, conv5, conv5],
            image=images,
229
            num_classes=21,
C
chengduoZH 已提交
230 231 232 233 234 235 236
            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)
C
chengduoZH 已提交
237

238
        return mbox_locs, mbox_confs, box, var
C
chengduoZH 已提交
239 240


241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
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')

256
            map_out = layers.detection_map(detect_res, label, 21)
257 258
            self.assertIsNotNone(map_out)
            self.assertEqual(map_out.shape, (1, ))
259
        print(str(program))
260 261


262 263 264 265
class TestRpnTargetAssign(unittest.TestCase):
    def test_rpn_target_assign(self):
        program = Program()
        with program_guard(program):
266 267
            bbox_pred_shape = [10, 50, 4]
            cls_logits_shape = [10, 50, 2]
268 269
            anchor_shape = [50, 4]

270 271 272
            bbox_pred = layers.data(
                name='bbox_pred',
                shape=bbox_pred_shape,
273 274
                append_batch_size=False,
                dtype='float32')
275 276 277
            cls_logits = layers.data(
                name='cls_logits',
                shape=cls_logits_shape,
278 279 280 281 282 283 284 285 286 287 288 289
                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')
290 291 292 293 294 295 296 297 298 299 300 301 302 303
            gt_boxes = layers.data(
                name='gt_boxes', shape=[4], lod_level=1, dtype='float32')
            is_crowd = layers.data(
                name='is_crowd',
                shape=[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)
304
            pred_scores, pred_loc, tgt_lbl, tgt_bbox, bbox_inside_weight = layers.rpn_target_assign(
305 306
                bbox_pred=bbox_pred,
                cls_logits=cls_logits,
307 308
                anchor_box=anchor_box,
                anchor_var=anchor_var,
309 310 311
                gt_boxes=gt_boxes,
                is_crowd=is_crowd,
                im_info=im_info,
312
                rpn_batch_size_per_im=256,
313 314
                rpn_straddle_thresh=0.0,
                rpn_fg_fraction=0.5,
315
                rpn_positive_overlap=0.7,
316 317
                rpn_negative_overlap=0.3,
                use_random=False)
318

319 320 321 322
            self.assertIsNotNone(pred_scores)
            self.assertIsNotNone(pred_loc)
            self.assertIsNotNone(tgt_lbl)
            self.assertIsNotNone(tgt_bbox)
323
            self.assertIsNotNone(bbox_inside_weight)
324 325 326
            assert pred_scores.shape[1] == 1
            assert pred_loc.shape[1] == 4
            assert pred_loc.shape[1] == tgt_bbox.shape[1]
J
jerrywgz 已提交
327
            print(str(program))
328 329


330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
class TestGenerateProposals(unittest.TestCase):
    def test_generate_proposals(self):
        data_shape = [20, 64, 64]
        images = fluid.layers.data(
            name='images', shape=data_shape, dtype='float32')
        im_info = fluid.layers.data(
            name='im_info', shape=[1, 3], dtype='float32')
        anchors, variances = fluid.layers.anchor_generator(
            name='anchor_generator',
            input=images,
            anchor_sizes=[32, 64],
            aspect_ratios=[1.0],
            variance=[0.1, 0.1, 0.2, 0.2],
            stride=[16.0, 16.0],
            offset=0.5)
        num_anchors = anchors.shape[2]
        scores = fluid.layers.data(
            name='scores', shape=[1, num_anchors, 8, 8], dtype='float32')
        bbox_deltas = fluid.layers.data(
            name='bbox_deltas',
            shape=[1, num_anchors * 4, 8, 8],
            dtype='float32')
        rpn_rois, rpn_roi_probs = fluid.layers.generate_proposals(
            name='generate_proposals',
            scores=scores,
            bbox_deltas=bbox_deltas,
            im_info=im_info,
            anchors=anchors,
            variances=variances,
            pre_nms_top_n=6000,
            post_nms_top_n=1000,
            nms_thresh=0.5,
            min_size=0.1,
            eta=1.0)
        self.assertIsNotNone(rpn_rois)
        self.assertIsNotNone(rpn_roi_probs)
        print(rpn_rois.shape)


369 370
if __name__ == '__main__':
    unittest.main()
新手
引导
客服 返回
顶部