Exemple #1
0
def test_rpn_regression():
    keras.backend.set_learning_phase(1)

    anchors = 9

    metadata = keras.backend.variable(numpy.array([[224, 224, 1]]))

    layer = keras_rcnn.layers.RPNRegressionLoss(anchors=anchors)

    rr, cc = 14, 14

    stride = 16

    all_anchors = keras_rcnn.backend.shift((rr, cc), stride)

    # only keep anchors inside the image
    inds_inside, y_true = anchor_target.inside_image(
        all_anchors, metadata[0]
    )

    scores = keras.backend.variable(numpy.zeros((1, 14, 14, anchors * 2)))
    deltas = keras.backend.variable(numpy.zeros((1, 14, 14, anchors * 4)))

    expected_loss = 0

    anchors, rpn_labels, bounding_box_targets = \
        keras_rcnn.layers.AnchorTarget()(
            [scores, keras.backend.expand_dims(y_true, 0), metadata])

    numpy.testing.assert_array_equal(
        layer.call([deltas, bounding_box_targets, rpn_labels]), deltas)

    assert len(layer.losses) == 1

    assert numpy.isclose(keras.backend.eval(layer.losses[0]), expected_loss)
def test_unmap():
    stride = 16
    features = (14, 14)
    anchors = 9
    total_anchors = features[0] * features[1] * anchors
    img_info = keras.backend.variable([[224, 224, 3]])
    gt_boxes = numpy.zeros((91, 4))
    gt_boxes = keras.backend.variable(gt_boxes)

    all_anchors = keras_rcnn.backend.shift(features, stride)

    inds_inside, all_inside_anchors = anchor_target.inside_image(
        all_anchors, img_info[0])

    argmax_overlaps_indices, labels = anchor_target.label(
        gt_boxes, all_inside_anchors, inds_inside)
    bbox_reg_targets = keras_rcnn.backend.bbox_transform(
        all_inside_anchors,
        keras.backend.gather(gt_boxes, argmax_overlaps_indices)
    )

    labels = anchor_target.unmap(labels,
                                 total_anchors,
                                 inds_inside,
                                 fill=-1)
    bbox_reg_targets = anchor_target.unmap(
        bbox_reg_targets, total_anchors, inds_inside, fill=0)

    assert keras.backend.eval(labels).shape == (total_anchors,)
    assert keras.backend.eval(bbox_reg_targets).shape == (total_anchors, 4)
def test_overlapping():
    stride = 16
    features = (14, 14)
    img_info = keras.backend.variable([[224, 224, 3]])
    gt_boxes = numpy.zeros((91, 4))
    gt_boxes = keras.backend.variable(gt_boxes)
    img_info = img_info[0]

    all_anchors = keras_rcnn.backend.shift(features, stride)

    inds_inside, all_inside_anchors = anchor_target.inside_image(
        all_anchors, img_info)

    a, max_overlaps, gt_argmax_overlaps_inds = anchor_target.overlapping(
        all_inside_anchors, gt_boxes, inds_inside)

    a = keras.backend.eval(a)
    max_overlaps = keras.backend.eval(max_overlaps)
    gt_argmax_overlaps_inds = keras.backend.eval(gt_argmax_overlaps_inds)

    assert a.shape == (376,)

    assert max_overlaps.shape == (376,)

    assert gt_argmax_overlaps_inds.shape == (91,)
Exemple #4
0
def test_overlapping():
    stride = 16
    features = (7, 7)
    img_info = keras.backend.variable([[112, 112, 3]])
    gt_boxes = numpy.zeros((91, 4))
    gt_boxes = keras.backend.variable(gt_boxes)

    all_anchors = keras_rcnn.backend.shift(features, stride)

    inds_inside, all_inside_anchors = anchor_target.inside_image(
        all_anchors, img_info[0], allowed_border=1)

    all_inside_anchors = keras_rcnn.backend.clip(all_inside_anchors,
                                                 img_info[0][:2])

    a, max_overlaps, gt_argmax_overlaps_inds = anchor_target.overlapping(
        all_inside_anchors, gt_boxes, inds_inside)

    a = keras.backend.eval(a)
    max_overlaps = keras.backend.eval(max_overlaps)
    gt_argmax_overlaps_inds = keras.backend.eval(gt_argmax_overlaps_inds)

    assert a.shape == (32, )

    assert max_overlaps.shape == (32, )

    assert gt_argmax_overlaps_inds.shape == (91, )
Exemple #5
0
def test_label():
    stride = 16
    feat_h, feat_w = (7, 7)
    img_info = keras.backend.variable([[112, 112, 3]])

    gt_boxes = keras.backend.variable(100 * numpy.random.random((91, 4)))
    gt_boxes = tensorflow.convert_to_tensor(gt_boxes, dtype=tensorflow.float32)

    all_anchors = keras_rcnn.backend.shift((feat_h, feat_w), stride)

    inds_inside, all_inside_anchors = anchor_target.inside_image(
        all_anchors, img_info[0], allowed_border=1)

    all_inside_anchors = keras_rcnn.backend.clip(all_inside_anchors,
                                                 img_info[0][:2])

    argmax_overlaps_inds, anchor_labels = anchor_target.label(
        gt_boxes, all_inside_anchors, inds_inside)

    result1 = keras.backend.eval(argmax_overlaps_inds)
    result2 = keras.backend.eval(anchor_labels)

    assert result1.shape == (32, ), keras.backend.eval(inds_inside).shape

    assert result2.shape == (32, )

    assert numpy.max(result2) <= 1

    assert numpy.min(result2) >= -1

    argmax_overlaps_inds, anchor_labels = anchor_target.label(
        gt_boxes, all_inside_anchors, inds_inside, clobber_positives=False)

    result1 = keras.backend.eval(argmax_overlaps_inds)
    result2 = keras.backend.eval(anchor_labels)

    assert result1.shape == (32, )

    assert result2.shape == (32, )

    assert numpy.max(result2) <= 1

    assert numpy.min(result2) >= -1

    gt_boxes = keras.backend.variable(224 * numpy.random.random((55, 4)))
    gt_boxes = tensorflow.convert_to_tensor(gt_boxes, dtype=tensorflow.float32)
    argmax_overlaps_inds, anchor_labels = anchor_target.label(
        gt_boxes, all_inside_anchors, inds_inside, clobber_positives=False)

    result1 = keras.backend.eval(argmax_overlaps_inds)
    result2 = keras.backend.eval(anchor_labels)

    assert result1.shape == (32, )

    assert result2.shape == (32, )

    assert numpy.max(result2) <= 1

    assert numpy.min(result2) >= -1
def test_label():
    stride = 16
    feat_h, feat_w = (14, 14)
    img_info = keras.backend.variable([[224, 224, 3]])

    gt_boxes = keras.backend.variable(100 * numpy.random.random((91, 4)))
    gt_boxes = tensorflow.convert_to_tensor(gt_boxes, dtype=tensorflow.float32)

    all_bbox = keras_rcnn.backend.shift((feat_h, feat_w), stride)

    inds_inside, all_inside_bbox = anchor_target.inside_image(
        all_bbox, img_info[0])

    argmax_overlaps_inds, bbox_labels = anchor_target.label(
        gt_boxes, all_inside_bbox, inds_inside)

    result1 = keras.backend.eval(argmax_overlaps_inds)
    result2 = keras.backend.eval(bbox_labels)

    assert result1.shape == (376,)

    assert result2.shape == (376,)

    assert numpy.max(result2) <= 1

    assert numpy.min(result2) >= -1

    argmax_overlaps_inds, bbox_labels = anchor_target.label(
        gt_boxes, all_inside_bbox, inds_inside, clobber_positives=False)

    result1 = keras.backend.eval(argmax_overlaps_inds)
    result2 = keras.backend.eval(bbox_labels)

    assert result1.shape == (376,)

    assert result2.shape == (376,)

    assert numpy.max(result2) <= 1

    assert numpy.min(result2) >= -1

    gt_boxes = keras.backend.variable(224 * numpy.random.random((55, 4)))
    gt_boxes = tensorflow.convert_to_tensor(gt_boxes, dtype=tensorflow.float32)
    argmax_overlaps_inds, bbox_labels = anchor_target.label(
        gt_boxes, all_inside_bbox, inds_inside, clobber_positives=False)
    result1 = keras.backend.eval(argmax_overlaps_inds)
    result2 = keras.backend.eval(bbox_labels)

    assert result1.shape == (376,)

    assert result2.shape == (376,)

    assert numpy.max(result2) <= 1

    assert numpy.min(result2) >= -1
def test_inside_image():
    stride = 16
    features = (14, 14)

    all_anchors = keras_rcnn.backend.shift(features, stride)

    img_info = (224, 224, 1)

    inds_inside, all_inside_anchors = anchor_target.inside_image(
        all_anchors, img_info)

    inds_inside = keras.backend.eval(inds_inside)

    assert inds_inside.shape == (376,)

    all_inside_anchors = keras.backend.eval(all_inside_anchors)

    assert all_inside_anchors.shape == (376, 4)
Exemple #8
0
def test_inside_image():
    stride = 16
    features = (7, 7)

    all_anchors = keras_rcnn.backend.shift(features, stride)

    img_info = numpy.array([[112, 112, 1]])

    inds_inside, all_inside_anchors = anchor_target.inside_image(
        all_anchors, img_info[0], allowed_border=1)

    all_inside_anchors = keras_rcnn.backend.clip(all_inside_anchors,
                                                 img_info[0][:2])

    inds_inside = keras.backend.eval(inds_inside)

    assert inds_inside.shape == (32, ), keras.backend.eval(all_inside_anchors)

    all_inside_anchors = keras.backend.eval(all_inside_anchors)

    assert all_inside_anchors.shape == (32, 4)