Add ops for rcnn models and UT

Author: RandyShuai

tests/run_pretrained_models.yaml

@@ -374,3 +374,17 @@ style-transfer:
   outputs:
     - output:0
 
+faster_rcnn_inception_v2_coco:
+  url: http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_v2_coco_2018_01_28.tar.gz
+  model: faster_rcnn_inception_v2_coco_2018_01_28/frozen_inference_graph.pb
+  opset_constraints:
+    "onnx":
+      "min": 11
+  input_get: get_beach
+  inputs:
+    "image_tensor:0": [1, 224, 224, 3]
+  outputs:
+    - detection_boxes:0
+    - detection_classes:0
+    - detection_scores:0
+    - num_detections:0

tests/test_backend.py

@@ -36,6 +36,8 @@
 _INPUT1 = "input1:0"
 _TFINPUT2 = "input2"
 _INPUT2 = "input2:0"
+_TFINPUT3 = "input3"
+_INPUT3 = "input3:0"
 _TFOUTPUT = "output"
 _OUTPUT = "output:0"
 _TFOUTPUT1 = "output1"
@@ -2470,6 +2472,74 @@ def test_batch_to_spacend(self):
         _ = tf.batch_to_space_nd(input_x, block_size, crop, name=_TFOUTPUT)
         self._run_test_case([_OUTPUT], {_INPUT: input_val})
 
+    @check_opset_min_version(11, "BatchToSpaceND")
+    def test_batch_to_spacend_non_const(self):
+        input_x_val = np.random.random_sample([40, 3, 5, 100]).astype(np.float32)  # NHWC
+        block_shape_val = np.array([2, 2]).astype(np.int64)
+        crops_val = np.array([[1, 0], [2, 1]]).astype(np.int64)
+        input_x = tf.placeholder(dtype=tf.float32, shape=input_x_val.shape, name=_TFINPUT)
+        block_shape = tf.placeholder(dtype=tf.int64, shape=block_shape_val.shape, name=_TFINPUT1)
+        crops = tf.placeholder(dtype=tf.int64, shape=crops_val.shape, name=_TFINPUT2)
+        _ = tf.batch_to_space_nd(input_x, block_shape, crops, name=_TFOUTPUT)
+        self._run_test_case([_OUTPUT], {_INPUT: input_x_val, _INPUT1: block_shape_val, _INPUT2: crops_val})
+
+    @check_opset_min_version(11, "SpaceToBatchND")
+    def test_space_to_batchnd_non_const(self):
+        input_x_val = np.random.random_sample([40, 5, 7, 66]).astype(np.float32)  # NHWC
+        block_size_val = np.array([2, 2]).astype(np.int64)
+        pad_val = np.array([[0, 1], [2, 1]]).astype(np.int64)
+        input_x = tf.placeholder(dtype=tf.float32, shape=input_x_val.shape, name=_TFINPUT)
+        block_size = tf.placeholder(dtype=tf.int64, shape=block_size_val.shape, name=_TFINPUT1)
+        pad = tf.placeholder(dtype=tf.int64, shape=pad_val.shape, name=_TFINPUT2)
+        _ = tf.space_to_batch_nd(input_x, block_size, pad, name=_TFOUTPUT)
+        self._run_test_case([_OUTPUT], {_INPUT: input_x_val, _INPUT1: block_size_val, _INPUT2: pad_val})
+
+    @check_opset_min_version(11, "CropAndResize")
+    def test_crop_and_resize_linear(self):
+        input_x_val = np.random.randint(low=0, high=256, size=[2, 36, 36, 3]).astype(np.float32)  # NHWC
+        boxes_val = np.array([[0.5, 0.7, 0.7, 0.9], [0.2, 0.4, 0.4, 0.6]]).astype(np.float32)
+        box_ind_val = np.array([1, 0]).astype(np.int32)
+        corp_size_val = np.array([20, 20]).astype(np.int32)
+        input_x = tf.placeholder(dtype=tf.float32, shape=input_x_val.shape, name=_TFINPUT)
+        boxes = tf.placeholder(dtype=tf.float32, shape=boxes_val.shape, name=_TFINPUT1)
+        box_ind = tf.placeholder(dtype=tf.int32, shape=box_ind_val.shape, name=_TFINPUT2)
+        corp_size = tf.placeholder(dtype=tf.int32, shape=corp_size_val.shape, name=_TFINPUT3)
+        _ = tf.image.crop_and_resize(input_x, boxes, box_ind, corp_size, name=_TFOUTPUT, method='bilinear')
+        self._run_test_case([_OUTPUT],
+                            {_INPUT: input_x_val, _INPUT1: boxes_val, _INPUT2: box_ind_val, _INPUT3: corp_size_val},
+                            rtol=1e-05, atol=1e-04)
+
+    @check_tf_min_version("1.9")
+    @check_opset_min_version(11, "CropAndResize")
+    def test_crop_and_resize_nearest(self):
+        input_x_val = np.random.randint(low=0, high=256, size=[1, 36, 36, 3]).astype(np.float32)  # NHWC
+        boxes_val = np.array([[0.2, 0.4, 0.6, 0.8]]).astype(np.float32)
+        box_ind_val = np.array([0]).astype(np.int32)
+        corp_size_val = np.array([30, 30]).astype(np.int32)
+        input_x = tf.placeholder(dtype=tf.float32, shape=input_x_val.shape, name=_TFINPUT)
+        boxes = tf.placeholder(dtype=tf.float32, shape=boxes_val.shape, name=_TFINPUT1)
+        box_ind = tf.placeholder(dtype=tf.int32, shape=box_ind_val.shape, name=_TFINPUT2)
+        corp_size = tf.placeholder(dtype=tf.int32, shape=corp_size_val.shape, name=_TFINPUT3)
+        _ = tf.image.crop_and_resize(input_x, boxes, box_ind, corp_size, name=_TFOUTPUT, method='nearest')
+        self._run_test_case([_OUTPUT],
+                            {_INPUT: input_x_val, _INPUT1: boxes_val, _INPUT2: box_ind_val, _INPUT3: corp_size_val},
+                            rtol=1e-05, atol=1e-04)
+
+    @check_opset_min_version(11, "CropAndResize")
+    def test_crop_and_resize_extrapolation(self):
+        input_x_val = np.random.randint(low=0, high=256, size=[1, 36, 36, 3]).astype(np.float32)  # NHWC
+        boxes_val = np.array([[0.2, 0.4, 1.2, 1.4]]).astype(np.float32)
+        box_ind_val = np.array([0]).astype(np.int32)
+        corp_size_val = np.array([40, 40]).astype(np.int32)
+        input_x = tf.placeholder(dtype=tf.float32, shape=input_x_val.shape, name=_TFINPUT)
+        boxes = tf.placeholder(dtype=tf.float32, shape=boxes_val.shape, name=_TFINPUT1)
+        box_ind = tf.placeholder(dtype=tf.int32, shape=box_ind_val.shape, name=_TFINPUT2)
+        corp_size = tf.placeholder(dtype=tf.int32, shape=corp_size_val.shape, name=_TFINPUT3)
+        _ = tf.image.crop_and_resize(input_x, boxes, box_ind, corp_size, name=_TFOUTPUT, extrapolation_value=1.0)
+        self._run_test_case([_OUTPUT],
+                            {_INPUT: input_x_val, _INPUT1: boxes_val, _INPUT2: box_ind_val, _INPUT3: corp_size_val},
+                            rtol=1e-04, atol=1e-03)
+
     def test_batch_to_space3d(self):
         block_size = [2, 2]
         crop = [[0, 1], [2, 1]]
@@ -2828,9 +2898,8 @@ def test_unique(self):
         _ = tf.identity(x1_, name=_TFOUTPUT)
         _ = tf.identity(x2_, name=_TFOUTPUT1)
         # FIXME: indices in onnx are not the same as in tensorflow so don't check for now
-        #self._run_test_case([_OUTPUT, _OUTPUT1], {_INPUT: x_val})
+        # self._run_test_case([_OUTPUT, _OUTPUT1], {_INPUT: x_val})
         self._run_test_case([_OUTPUT], {_INPUT: x_val})
 
-
 if __name__ == '__main__':
     unittest_main()

tf2onnx/onnx_opset/nn.py

@@ -534,6 +534,71 @@ def version_11(cls, ctx, node, **kwargs):
         cls.version_1(ctx, node, **kwargs)
 
 
+@tf_op(["CropAndResize"])
+class CropAndResize:
+    @classmethod
+    def version_11(cls, ctx, node, **kwargs):
+        # create loop of resize to cater to tensorflow CropAndResize, one box one iteration
+        mode = "nearest" if node.get_attr("method") is not None and node.get_attr(
+            "method").s == b"nearest" else "linear"
+        extrapolation_value = float(node.get_attr("extrapolation_value", "0").f)
+        input_x = node.inputs[0]
+        boxes = node.inputs[1]
+        box_ind = node.inputs[2]
+        crop_size = node.inputs[3]
+        trip_name = utils.make_name(node.name + "_i")
+        cond_name = utils.make_name(node.name + "_cond")
+        cond_out_name = utils.make_name(node.name + "cond_out")
+        g = ctx.create_new_graph_with_same_config()
+        g.add_graph_input(trip_name, TensorProto.INT64, [1])
+        g.add_graph_input(cond_name, TensorProto.BOOL, [])
+        g.parent_graph = ctx
+        const_zero = g.make_const(utils.make_name(node.name + "_const_zero"), np.array([0], dtype=np.int32))
+        const_zero_long = g.make_const(utils.make_name(node.name + "_const_zero_long"), np.array([0], dtype=np.int64))
+        const_one = g.make_const(utils.make_name(node.name + "_const_one"), np.array([1], dtype=np.int32))
+        const_one_long = g.make_const(utils.make_name(node.name + "_const_one_long"), np.array([1], dtype=np.int64))
+        index_end = g.make_node("Add", [trip_name, const_one_long.output[0]])
+        box_index_from = g.make_node("Slice", [box_ind.output[0], trip_name, index_end.output[0]], name="Slice_a")
+        box_index_to = g.make_node("Add", [box_index_from.output[0], const_one.output[0]])
+        target_x = g.make_node("Slice", [input_x.output[0], box_index_from.output[0], box_index_to.output[0],
+                                         const_zero.output[0]], name="Slice_b")
+        transposed_x = g.make_node("Transpose", [target_x.output[0]], attr={'perm': constants.NHWC_TO_NCHW})
+        shape_of_transposed_x = g.make_node("Shape", [transposed_x.output[0]])
+        const_zero_zero = g.make_const(utils.make_name(node.name + "_const_zero_zero"),
+                                       np.array([0, 0], dtype=np.float32))
+        const_one_one = g.make_const(utils.make_name(node.name + "_const_one_one"),
+                                     np.array([1, 1], dtype=np.float32))
+        const_four = g.make_const(utils.make_name(node.name + "_const_four"), np.array([4], dtype=np.int64))
+        const_empty_float = g.make_const(utils.make_name("const_empty_float"), np.array([], dtype=np.float32))
+        first_half_of_shape = GraphBuilder(g).make_slice(
+            {"data": shape_of_transposed_x.output[0], "ends": [2], "starts": [0]})
+        box = g.make_node("Slice", [boxes.output[0], trip_name, index_end.output[0], const_zero_long.output[0]],
+                          name="Slice_c")
+        roi_raw = g.make_node("Reshape", [box.output[0], const_four.output[0]])
+        roi_raw_first_half = GraphBuilder(g).make_slice({"data": roi_raw.output[0], "ends": [2], "starts": [0]})
+        roi_raw_second_half = GraphBuilder(g).make_slice({"data": roi_raw.output[0], "ends": [4], "starts": [2]})
+        roi_concat_1 = g.make_node("Concat", [const_zero_zero.output[0], roi_raw_first_half], attr={'axis': 0})
+        roi_concat_2 = g.make_node("Concat", [const_one_one.output[0], roi_raw_second_half], attr={'axis': 0})
+        final_roi = g.make_node("Concat", [roi_concat_1.output[0], roi_concat_2.output[0]], attr={'axis': 0})
+        crop_size_int64 = g.make_node("Cast", [crop_size.output[0]], attr={'to': TensorProto.INT64})
+        final_crop_size = g.make_node("Concat", [first_half_of_shape, crop_size_int64.output[0]], {'axis': 0})
+        resized_x = g.make_node("Resize", [transposed_x.output[0], final_roi.output[0], const_empty_float.output[0],
+                                           final_crop_size.output[0]],
+                                attr={"mode": mode, "extrapolation_value": extrapolation_value,
+                                      "coordinate_transformation_mode": "tf_crop_and_resize"})
+        recovered_x = g.make_node("Transpose", [resized_x.output[0]], attr={'perm': constants.NCHW_TO_NHWC})
+        squeeze_x = g.make_node("Squeeze", inputs=[recovered_x.output[0]], attr={"axes": [0]})
+        g.make_node("Identity", [cond_name], outputs=[cond_out_name])
+        g.add_graph_output(cond_out_name, TensorProto.BOOL, [])
+        g.add_graph_output(squeeze_x.output[0], ctx.get_dtype(node.input[0]), [-1, -1, -1])
+        trip_node = ctx.make_node("Size", [box_ind.output[0]])
+        cond_const = ctx.make_const(utils.make_name("cond"), np.ones((), dtype=np.bool))
+        ctx.remove_node(node.name)
+        inner_loop = ctx.make_node("Loop", [trip_node.output[0], cond_const.output[0]], name=node.name,
+                                   outputs=node.output)
+        inner_loop.set_body_graph_as_attr("body", g)
+
+
 @tf_op(["ResizeBilinear", "ResizeNearestNeighbor"])
 class Resize:
     @classmethod