Update import and export of some ONNX ops to support newer opset vers…

…ions - this gets all ONNX unit tests to pass with onnx 1.7.

python/mxnet/contrib/onnx/mx2onnx/_op_translations.py

@@ -471,7 +471,7 @@ def convert_pad(node, **kwargs):
     pad_mode = attrs.get("mode")
 
     if pad_mode == "constant":
-        pad_value = float(attrs.get("constant_value", 0.0))
+        pad_value = np.float32(attrs.get("constant_value", 0.0))
         if opset_version >= 11:
             # starting with opset 11, pads and constant_value are inputs instead of attributes
             from onnx.helper import make_tensor, make_tensor_value_info
@@ -494,6 +494,7 @@ def convert_pad(node, **kwargs):
                 "Pad",
                 input_nodes,
                 [name],
+                mode='constant',
                 name=name
             )
             return [pads_value_node, const_value_node, pad_node]
@@ -508,16 +509,35 @@ def convert_pad(node, **kwargs):
                 name=name
             )
     else:
-        node = onnx.helper.make_node(
-            'Pad',
-            inputs=input_nodes,
-            outputs=[name],
-            mode=pad_mode,
-            pads=onnx_pad_width,
-            name=name
-        )
-
-    return [node]
+        if opset_version >= 11:
+            # starting with opset 11, pads and constant_value are inputs instead of attributes
+            from onnx.helper import make_tensor, make_tensor_value_info
+            initializer = kwargs["initializer"]
+            pads_input_name = name + "_pads"
+            pads_input_type = onnx.TensorProto.INT64
+            pads_input_shape = np.shape(np.array(onnx_pad_width))
+            pads_value_node = make_tensor_value_info(pads_input_name, pads_input_type, pads_input_shape)
+            pads_tensor_node = make_tensor(pads_input_name, pads_input_type, pads_input_shape, onnx_pad_width)
+            initializer.append(pads_tensor_node)
+            input_nodes.append(pads_input_name)
+            pad_node = onnx.helper.make_node(
+                "Pad",
+                input_nodes,
+                [name],
+                mode=pad_mode,
+                name=name
+            )
+            return [pads_value_node, pad_node]
+        else:
+            node = onnx.helper.make_node(
+                'Pad',
+                inputs=input_nodes,
+                outputs=[name],
+                mode=pad_mode,
+                pads=onnx_pad_width,
+                name=name
+            )
+            return [node]
 
 
 def create_helper_trans_node(op_name, input_node, node_name):
@@ -2155,14 +2175,34 @@ def convert_topk(node, **kwargs):
     else:
         raise NotImplementedError("ONNX expects both value and indices as output")
 
-    topk_node = onnx.helper.make_node(
-        "TopK",
-        input_nodes,
-        outputs,
-        axis=axis,
-        k=k,
-        name=name
-    )
+    opset_version = kwargs['opset_version']
+    if opset_version >= 10:
+        from onnx.helper import make_tensor, make_tensor_value_info
+        initializer = kwargs["initializer"]
+        k_input_name = name + "_k"
+        k_input_type = onnx.TensorProto.INT64
+        k_value_node = make_tensor_value_info(k_input_name, k_input_type, ())
+        k_tensor_node = make_tensor(k_input_name, k_input_type, (), k)
+        initializer.append(k_tensor_node)
+        input_nodes.append(k_input_name)
+
+        topk_node = onnx.helper.make_node(
+            "TopK",
+            input_nodes,
+            outputs,
+            axis=axis,
+            name=name
+        )
+        return [k_value_node, topk_node]
+    else:
+        topk_node = onnx.helper.make_node(
+            "TopK",
+            input_nodes,
+            outputs,
+            axis=axis,
+            k=k,
+            name=name
+        )
 
     return [topk_node]
 

python/mxnet/contrib/onnx/onnx2mx/_op_translations.py

@@ -240,11 +240,24 @@ def relu(attrs, inputs, proto_obj):
 
 def pad(attrs, inputs, proto_obj):
     """ Add padding to input tensor"""
-    new_attrs = translation_utils._fix_attribute_names(attrs, {'pads'  : 'pad_width',
-                                                               'value' : 'constant_value'
-                                                              })
-    new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))
-    return 'pad', new_attrs, inputs
+    opset_version = proto_obj.opset_version
+    if 'mode' not in attrs.keys():
+        attrs['mode'] = 'constant'
+    if opset_version >= 11:
+        pads = list(proto_obj._params[inputs[1].name].asnumpy())
+        pads = tuple([int(i) for i in pads])
+        new_attrs = translation_utils._add_extra_attributes(attrs, {'pad_width': pads})
+        if len(inputs) == 3:
+            const = proto_obj._params[inputs[2].name].asnumpy()[0]
+            new_attrs = translation_utils._add_extra_attributes(new_attrs, {'constant_value': const})
+        new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))
+        return 'pad', new_attrs, inputs[0]
+    else:
+        new_attrs = translation_utils._fix_attribute_names(attrs, {'pads'  : 'pad_width',
+                                                                   'value' : 'constant_value'
+                                                                  })
+        new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))
+        return 'pad', new_attrs, inputs
 
 def matrix_multiplication(attrs, inputs, proto_obj):
     """Performs general matrix multiplication"""
@@ -367,7 +380,7 @@ def deconv(attrs, inputs, proto_obj):
     new_attrs = translation_utils._fix_bias('Deconvolution', new_attrs, len(inputs))
 
     new_attrs = translation_utils._fix_channels('Deconvolution', new_attrs, inputs, proto_obj)
-    kernel = new_attrs['kernel']
+    kernel = new_attrs['kernel'] if 'kernel' in new_attrs else []
     stride = new_attrs['stride'] if 'stride' in new_attrs else []
     padding = new_attrs['pad'] if 'pad' in new_attrs else []
     dilations = new_attrs['dilate'] if 'dilate' in new_attrs else []
@@ -522,15 +535,30 @@ def _slice(attrs, inputs, proto_obj):
     """Returns a slice of the input tensor along multiple axes."""
     input_tensor_data = proto_obj.model_metadata.get('input_tensor_data')[0]
     input_shape = input_tensor_data[1]
-    new_attrs = translation_utils._fix_attribute_names(attrs,
-                                                       {'axes' : 'axis',
-                                                        'ends' : 'end',
-                                                        'starts' : 'begin'})
-    # onnx slice provides slicing on multiple axis. Adding multiple slice_axis operator
-    # for multiple axes from mxnet
-    begin = new_attrs.get('begin')
-    end = list(new_attrs.get('end'))
-    axes = new_attrs.get('axis', tuple(range(len(begin))))
+
+    if proto_obj.opset_version >= 10:
+        begin = proto_obj._params[inputs[1].name].asnumpy()
+        end = proto_obj._params[inputs[2].name].asnumpy()
+        if len(inputs) >= 4:
+            axes = list(proto_obj._params[inputs[3].name].asnumpy())
+            axes = tuple([int(i) for i in axes])
+        else:
+            axes = tuple(range(len(begin)))
+        new_attrs = translation_utils._add_extra_attributes(attrs, {'axes' : axes,
+                                                                    'begin' : begin,
+                                                                    'end' : end
+                                                                   })
+    else:
+        new_attrs = translation_utils._fix_attribute_names(attrs,
+                                                           {'axes' : 'axis',
+                                                            'ends' : 'end',
+                                                            'starts' : 'begin'})
+        # onnx slice provides slicing on multiple axis. Adding multiple slice_axis operator
+        # for multiple axes from mxnet
+        begin = new_attrs.get('begin')
+        end = list(new_attrs.get('end'))
+        axes = new_attrs.get('axis', tuple(range(len(begin))))
+
     for i, axis in enumerate(axes):
         end[i] = None if end[i] >= input_shape[axis] else end[i]
     slice_op = symbol.slice_axis(inputs[0], axis=axes[0], begin=begin[0], end=end[0])
@@ -826,4 +854,10 @@ def topk(attrs, inputs, proto_obj):
     new_attrs = translation_utils._add_extra_attributes(attrs,
                                                         {'ret_typ': 'both',
                                                          'dtype': 'int64'})
-    return 'topk', new_attrs, inputs
+    opset_version = proto_obj.opset_version
+    if opset_version >= 10:
+        k_vals = proto_obj._params[inputs[1].name].asnumpy()
+        new_attrs = translation_utils._add_extra_attributes(new_attrs, {'k': k_vals})
+        return 'topk', new_attrs, inputs[0]
+    else:
+        return 'topk', new_attrs, inputs