diff --git a/mindinsight/mindconverter/graph_based_converter/generator/generator.py b/mindinsight/mindconverter/graph_based_converter/generator/generator.py index 4d0ffd24..81c60f62 100644 --- a/mindinsight/mindconverter/graph_based_converter/generator/generator.py +++ b/mindinsight/mindconverter/graph_based_converter/generator/generator.py @@ -105,7 +105,7 @@ class CodeStruct: init_lines += init_str cons_lines += cons_str - else: # is ModuleStruct + else: # is ModuleStruct # check if this instance generated CodeStruct if GlobalContext().code_structs.get(struct.pattern_id) is None: CodeStruct(struct, repeated_submodules) diff --git a/mindinsight/mindconverter/graph_based_converter/mapper/gen_setting.py b/mindinsight/mindconverter/graph_based_converter/mapper/gen_setting.py deleted file mode 100644 index 08a5f98c..00000000 --- a/mindinsight/mindconverter/graph_based_converter/mapper/gen_setting.py +++ /dev/null @@ -1,34 +0,0 @@ -# Copyright 2020 Huawei Technologies Co., Ltd.All Rights Reserved. -# -# 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. -# ============================================================================== -"""Operation mapping setting.""" -from collections import namedtuple -import numpy as np - -from mindinsight.mindconverter.graph_based_converter.constant import InputType - -Tensor = namedtuple("Tensor", ["shape", "dtype", "reference"]) - -Setting = namedtuple("Setting", ["opt_vars_suffix", - "op_ipt_type", - "op_extra_input", - "op_extra_tensor"]) -Setting.__new__.__defaults__ = ("_opt", InputType.TENSOR.value, dict(), None) - - -def get_dtype(tensor: np.ndarray): - """Get tensor dtype.""" - if tensor.dtype == np.float16: - return "mindspore.float16" - return "mindspore.float32" diff --git a/mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/pool_mapper.py b/mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/pool_mapper.py index 5bc2162e..fc082bb1 100644 --- a/mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/pool_mapper.py +++ b/mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/pool_mapper.py @@ -54,7 +54,6 @@ class PoolMapper(ONNXToMindSporeMapper): kernel_shape = params['kernel_shape'] strides = params['strides'] dilations = params.get('dilations', (1, 1)) - ms_opt_shape = np.true_divide(np.subtract(np.array(input_shape[-len(kernel_shape):], dtype=np.float32), ((np.array(kernel_shape, dtype=np.float32) - 1) * np.array(dilations, dtype=np.float32) + 1)) + 1, @@ -123,9 +122,9 @@ class PoolMapper(ONNXToMindSporeMapper): if np.any(np.array(ms_opt_shape) > np.array(onnx_opt_shape)): raise ValueError(f"ms_opt_shape[{ms_opt_shape}] should be no larger than onnx_opt_shape[{onnx_opt_shape}].") - shape_diff = np.subtract((np.array(onnx_opt_shape) - 1)*np.array(strides), + shape_diff = np.subtract((np.array(onnx_opt_shape) - 1) * np.array(strides), np.subtract(np.array(onnx_ipt_shape), - (np.array(kernel_shape) - 1)*np.array(dilations) + 1)).tolist() + (np.array(kernel_shape) - 1) * np.array(dilations) + 1)).tolist() zero_pad_single = (0, 0) paddings = [zero_pad_single] @@ -134,7 +133,7 @@ class PoolMapper(ONNXToMindSporeMapper): paddings.append(zero_pad_single) for axis_diff in shape_diff: - paddings.append((int(axis_diff//2), int(axis_diff//2 + axis_diff % 2))) + paddings.append((int(axis_diff // 2), int(axis_diff // 2 + axis_diff % 2))) init_template_pad = f"self.pad_{{{variable_slot}}} = nn.Pad(paddings={{paddings}})" construct_template_pad = f"opt_{{{variable_slot}}} = self.pad_{{{variable_slot}}}" \ diff --git a/mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/slice_mapper.py b/mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/slice_mapper.py index 20bf91f2..6c9b61b7 100644 --- a/mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/slice_mapper.py +++ b/mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/slice_mapper.py @@ -37,7 +37,7 @@ class SliceMapper(ONNXToMindSporeMapper): def _generate_snippet_template(**kwargs): template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template( **kwargs) - weights = [weight.value for weight in kwargs.get('weights')] # start, end, axis + weights = [weight.value for weight in kwargs.get('weights')] # start, end, axis opt_shape = kwargs["raw_params"]["output_shape"] if not weights: raise ValueError("Cannot get required params from slice.") diff --git a/tests/ut/mindconverter/graph_based_converter/mapper/test_mapper.py b/tests/ut/mindconverter/graph_based_converter/mapper/test_mapper.py index 6ebdfce9..d55547bb 100644 --- a/tests/ut/mindconverter/graph_based_converter/mapper/test_mapper.py +++ b/tests/ut/mindconverter/graph_based_converter/mapper/test_mapper.py @@ -17,7 +17,6 @@ import numpy as np import pytest from mindinsight.mindconverter.graph_based_converter.mapper.base import ONNXToMindSporeMapper -from mindinsight.mindconverter.graph_based_converter.mapper.gen_setting import Setting class TestMappers: @@ -30,16 +29,7 @@ class TestMappers: 'pads': [1, 2, 3, 4], 'strides': [1, 1]}, 'weights': {'weight': np.zeros((64, 3, 1, 1), dtype=np.int32)}}, - 'expected_output': {'converter_name': 'nn.Conv2d', - 'converted_params': {'in_channels': 3, - 'out_channels': 64, - 'kernel_size': (1, 1), - 'stride': (1, 1), - 'padding': (1, 3, 2, 4), - 'pad_mode': '\"pad\"', - 'dilation': (1, 1), - 'group': 1}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Conv', 'params': {'dilations': [1, 1], @@ -47,44 +37,25 @@ class TestMappers: 'pads': [0, 0, 0, 0], 'strides': [1, 1]}, 'weights': {'weight': np.zeros((64, 3, 2, 2), dtype=np.int32)}}, - 'expected_output': {'converter_name': 'nn.Conv2d', - 'converted_params': {'in_channels': 3, - 'out_channels': 64, - 'kernel_size': (2, 2), - 'stride': (1, 1), - 'padding': 0, - 'pad_mode': '\"valid\"', - 'dilation': (1, 1), - 'group': 1}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Gemm', 'params': dict(), 'weights': {'weight': np.zeros((10, 3), dtype=np.int32), 'bias': np.zeros((10, 1), dtype=np.int32)}}, - 'expected_output': {'converter_name': 'nn.Dense', - 'converted_params': {'in_channels': 3, - 'out_channels': 10, - 'has_bias': True}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::BatchNormalization', 'params': {'epsilon': 1e-5, 'momentum': 0.9, 'output_shape': (1, 6, 224, 224)}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.BatchNorm2d', - 'converted_params': {'num_features': 6, - 'eps': 1e-5, - 'momentum': 0.9}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Relu', 'params': dict(), 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.ReLU', - 'converted_params': dict(), - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::MaxPool', 'params': {'kernel_shape': [3, 3], @@ -93,11 +64,7 @@ class TestMappers: 'input_shape': (1, 3, 224, 224), 'output_shape': (1, 3, 112, 112)}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.MaxPool2d', - 'converted_params': {'kernel_size': (3, 3), - 'stride': (2, 2), - 'pad_mode': '"same"'}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::AveragePool', 'params': {'kernel_shape': [3, 3], @@ -106,120 +73,86 @@ class TestMappers: 'input_shape': (1, 3, 224, 224), 'output_shape': (1, 3, 112, 112)}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.AvgPool2d', - 'converted_params': {'kernel_size': (3, 3), - 'stride': (2, 2), - 'pad_mode': '"same"'}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::GlobalAveragePool', 'params': {'input_shape': (1, 3, 10, 10), 'output_shape': (1, 3, 1, 1)}, 'weights': ''}, - 'expected_output': {'converter_name': 'nn.AvgPool2d', - 'converted_params': {'kernel_size': (10, 10)}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Flatten', 'params': dict(), 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.Flatten', - 'converted_params': dict(), - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Add', 'params': dict(), 'weights': dict()}, - 'expected_output': {'converter_name': 'P.TensorAdd', - 'converted_params': dict(), - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Pad', 'params': {'pads': [0, 1, 2, 3], 'value': 0, 'mode': 'constant'}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.Pad', - 'converted_params': {'paddings': ((0, 2), (1, 3)), - 'mode': '\"CONSTANT\"'}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Pad', 'params': {'pads': [0, 1, 2, 3], 'mode': 'reflect'}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.Pad', - 'converted_params': {'paddings': ((0, 2), (1, 3)), - 'mode': '\"REFLECT\"'}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Pad', 'params': {'pads': [0, 1, 2, 3], 'value': 1, 'mode': 'constant'}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.Pad', - 'converted_params': {'paddings': ((0, 2), (1, 3)), - 'mode': '{UNSUPPORTED: value is NOT 0}\"CONSTANT\"'}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Pad', 'params': {'pads': [0, 1, 2, 3], 'mode': 'edge'}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.Pad', - 'converted_params': {'paddings': ((0, 2), (1, 3)), - 'mode': '{UNSUPPORTED: \"edge\"}\"UNKNOWN\"'}, - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::ReduceMean', 'params': {'keepdims': 0, 'axes': [1, 2]}, 'weights': dict()}, - 'expected_output': {'converter_name': 'P.ReduceMean', - 'converted_params': {'keep_dims': False}, - 'converted_settings': {'values': {'axis': (1, 2)}}} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::ReduceMean', 'params': {'keepdims': 1, 'axes': [1]}, 'weights': dict()}, - 'expected_output': {'converter_name': 'P.ReduceMean', - 'converted_params': {'keep_dims': True}, - 'converted_settings': {'values': {'axis': 1}}} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Concat', 'params': {'axis': 0}, 'weights': dict()}, - 'expected_output': {'converter_name': 'P.Concat', - 'converted_params': {'axis': 0}, - 'converted_settings': {'input_type': "list"}} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Clip', 'params': {'max': 6, 'min': 0}, 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.ReLU6', - 'converted_params': dict(), - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Clip', 'params': dict(), 'weights': dict()}, - 'expected_output': {'converter_name': 'nn.ReLU', - 'converted_params': dict(), - 'converted_settings': Setting()} + 'expected_output': {} }, { 'input': {'op_name': 'onnx::Clip', 'params': {'max': 3, 'min': 2}, 'weights': dict()}, - 'expected_output': {'converter_name': None, - 'converted_params': dict(), - 'converted_settings': Setting()} + 'expected_output': {} }]) def test_mapper(self, params): """Test mapper function.""" - mapper = ONNXToMindSporeMapper() - _, _, _, _ = \ - mapper.convert(params['input']['op_name'], params['input']['params'], params['input']['weights']) + _, _, _, _ = ONNXToMindSporeMapper.convert(params['input']['op_name'], + params['input']['params'], + params['input']['weights'])