Merge pull request #125 from klassen9/feature/resize_4d_conversion

Add resize to change_3d_tensors_to_4d transformation

Author: maltanar

src/qonnx/analysis/topology.py

@@ -56,7 +56,10 @@ def all_tensors_f32(model):
     annotations notwithstanding.
 
     Returns {"all_tensors_f32": Bool}."""
-    all_tensors = model.make_empty_exec_context().items()
+    exec_ctx = model.make_empty_exec_context()
+    # remove the special empty string entry in the context since it has no tensor
+    exec_ctx.pop("")
+    all_tensors = exec_ctx.items()
     non_f32_tensors = filter(lambda x: x[1].dtype != np.float32, all_tensors)
     return {"all_tensors_f32": len(list(non_f32_tensors)) == 0}
 

src/qonnx/core/modelwrapper.py

@@ -510,6 +510,9 @@ def make_empty_exec_context(self):
         # fill in the constants provided by the initializers (TensorProto to npy)
         for t in graph.initializer:
             execution_context[t.name] = np_helper.to_array(t)
+        # for nodes that use empty string as input (=default value), create a
+        # dummy entry in the context
+        execution_context[""] = None
         return execution_context
 
     def check_all_tensor_shapes_specified(self, fix_missing_init_shape=False):
@@ -525,7 +528,9 @@ def check_all_tensor_shapes_specified(self, fix_missing_init_shape=False):
         # see https://github.com/fastmachinelearning/qonnx/issues/33
         for n in graph.node:
             for i in n.input:
-                ret = (self.get_tensor_shape(i, fix_missing_init_shape=fix_missing_init_shape) is not None) and ret
+                # skip tensor names with empty string (indicates defaults)
+                if i != "":
+                    ret = (self.get_tensor_shape(i, fix_missing_init_shape=fix_missing_init_shape) is not None) and ret
             for o in n.output:
                 ret = (self.get_tensor_shape(o, fix_missing_init_shape=fix_missing_init_shape) is not None) and ret
         return ret

src/qonnx/transformation/change_3d_tensors_to_4d.py

@@ -64,6 +64,7 @@ def _find_invalid_nodes(model):
         "Reshape",
         "MaxPool",
         "Upsample",
+        "Resize",
     ]
     invalid_nodes = []
     for n in model.graph.node:
@@ -194,6 +195,43 @@ def apply(self, model):
                 assert list(scales.shape) == [3]
                 scales = np.append(scales, np.asarray(1.0, dtype=np.float32))
                 model.set_initializer(n.input[1], scales)
+            elif node_op_type == "Resize":
+                assert "axes" not in [x.name for x in n.attribute], "%s: Axes attribute is not supported." % n.name
+                assert not (len(n.input) in (3, 4) and model.get_initializer(n.input[1]) is not None), (
+                    "%s: ROI input is not supported." % n.name
+                )
+                if len(n.input) == 2:
+                    # Resize version 10
+                    scales = model.get_initializer(n.input[1])
+                    scales = np.append(scales, np.asarray(1.0, dtype=np.float32))
+                    model.set_initializer(n.input[1], scales)
+                elif len(n.input) == 3:
+                    # Resize version 11 and up (no size input)
+                    scales = model.get_initializer(n.input[2])
+                    scales = np.append(scales, np.asarray(1.0, dtype=np.float32))
+                    model.set_initializer(n.input[2], scales)
+                elif len(n.input) == 4:
+                    scales_exists = (model.get_initializer(n.input[2]) is not None) and (
+                        len(model.get_initializer(n.input[2])) != 0
+                    )
+                    sizes_exists = (model.get_initializer(n.input[3]) is not None) and (
+                        len(model.get_initializer(n.input[3])) != 0
+                    )
+                    assert scales_exists ^ sizes_exists, (
+                        "%s: Either scales or the target output size must "
+                        "be specified. Specifying both is prohibited." % n.name
+                    )
+                    if scales_exists:
+                        # Scales parameter is a 1d list of upsampling factors along each axis
+                        scales = model.get_initializer(n.input[2])
+                        scales = np.append(scales, np.asarray(1.0, dtype=np.float32))
+                        model.set_initializer(n.input[2], scales)
+                    else:
+                        # Size parameter is a 1d list of the target size along each axis
+                        sizes = model.get_initializer(n.input[3])
+                        sizes = np.append(sizes, np.asarray(1.0, dtype=np.int64))
+                        model.set_initializer(n.input[3], sizes)
+                input_shape.append(1)
 
         # Change format of each input/value_info/output tensor
         for k, v in all_tensors.items():

tests/transformation/test_4d_conversion.py

@@ -31,6 +31,7 @@
 import numpy as np
 import onnx
 import onnx.parser as oprs
+from onnx.helper import make_opsetid
 
 import qonnx.core.onnx_exec as oxe
 from qonnx.core.datatype import DataType
@@ -328,7 +329,76 @@ def create_conv_upsample():
     return model
 
 
-@pytest.mark.parametrize("test_model", ["Quartz", "VGG", "ConvUpsample"])
+def create_resize(opset):
+    """
+    Creates an model for testing the 3D to 4D transform of the resize node.
+    """
+    resize_node1 = onnx.helper.make_node(
+        "Resize",
+        inputs=["in_resize1", "roi_resize1", "scales_resize1", "sizes_resize1"],
+        outputs=["out_resize1"],
+        name="Resize1",
+        mode="nearest",
+    )
+
+    resize_node2 = onnx.helper.make_node(
+        "Resize",
+        inputs=["out_resize1", "roi_resize2", "scales_resize2"],
+        outputs=["out_resize2"],
+        name="Resize2",
+        mode="nearest",
+    )
+
+    in_resize1 = onnx.helper.make_tensor_value_info("in_resize1", onnx.TensorProto.FLOAT, [1, 32, 4])
+    out_resize1 = onnx.helper.make_tensor_value_info("out_resize1", onnx.TensorProto.FLOAT, [1, 32, 8])
+    out_resize2 = onnx.helper.make_tensor_value_info("out_resize2", onnx.TensorProto.FLOAT, [1, 32, 16])
+
+    roi_resize1 = onnx.helper.make_tensor_value_info("roi_resize1", onnx.TensorProto.FLOAT, [4])
+    scales_resize1 = onnx.helper.make_tensor_value_info("scales_resize1", onnx.TensorProto.FLOAT, [])
+    sizes_resize1 = onnx.helper.make_tensor_value_info("sizes_resize1", onnx.TensorProto.INT64, [3])
+
+    roi_resize2 = onnx.helper.make_tensor_value_info("roi_resize2", onnx.TensorProto.FLOAT, [4])
+    scales_resize2 = onnx.helper.make_tensor_value_info("scales_resize2", onnx.TensorProto.FLOAT, [3])
+
+    list_of_nodes = [
+        resize_node1,
+        resize_node2,
+    ]
+    list_of_value_infos = [
+        out_resize1,
+        roi_resize1,
+        sizes_resize1,
+        scales_resize1,
+        roi_resize2,
+        scales_resize2,
+    ]
+
+    graph = onnx.helper.make_graph(
+        nodes=list_of_nodes,
+        name="4d_conversion_resize_test_graph",
+        inputs=[in_resize1],
+        outputs=[out_resize2],
+        value_info=list_of_value_infos,
+    )
+
+    onnx_model = qonnx_make_model(
+        graph, producer_name="4d_conversion_resize_test-model", opset_imports=[make_opsetid("", opset)]
+    )
+    model = ModelWrapper(onnx_model)
+
+    model.set_initializer("sizes_resize1", np.array([1, 32, 8], dtype=np.int64))
+    if opset == 11:
+        model.set_initializer("scales_resize1", np.array([], dtype=np.float32))
+    elif opset == 13:
+        model.graph.node[0].input[2] = ""
+    else:
+        assert False, f"Undefined opset {opset} for Resize testcase creator"
+    model.set_initializer("scales_resize2", np.array([1.0, 1.0, 2.0], dtype=np.float32))
+    model = model.transform(InferShapes())
+    return model
+
+
+@pytest.mark.parametrize("test_model", ["Quartz", "VGG", "ConvUpsample", "Resize11", "Resize13"])
 def test_4d_conversion(test_model):
     """
     Test for the 3D to 4D transformation with a valid graph.
@@ -340,6 +410,8 @@ def test_4d_conversion(test_model):
         model = create_arbitrary_model_vgg()
     elif test_model == "ConvUpsample":
         model = create_conv_upsample()
+    elif "Resize" in test_model:
+        model = create_resize(opset=int(test_model.replace("Resize", "")))
     else:
         raise Exception("Unknown test_model in test_4d_conversion")