!917 Refactor GraphNode and optimize code generation.

From: @liuchongming74
Reviewed-by: 
Signed-off-by:

mindinsight/mindconverter/graph_based_converter/common/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+# ==============================================================================
+"""Common instance and utils of graph based converter."""

mindinsight/mindconverter/graph_based_converter/common/code_fragment.py

@@ -0,0 +1,218 @@
+# 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.
+# ==============================================================================
+"""Define CodeLine object."""
+import abc
+
+
+class TrainableParams:
+    """Trainable parameters."""
+
+    def __init__(self, shape, dtype, reference):
+        self.param_name = None
+        self.shape = shape
+        self.dtype = dtype
+        self.reference = reference  # Weight name in global npy.
+
+
+class CodeSetting:
+    """Code generation settings."""
+
+    def __init__(self):
+        self.output_vars_suffix = []
+        self.operation_input_type = None  # Construct input type, tensor or list.
+        self.operation_extra_input = dict()  # `values` in original setting dict.
+        self.operation_extra_tensor = None  # For `MatMul`, `BiasAdd` op, need a tensor
+
+
+class Fragment(abc.ABC):
+    """
+    Define comment attributes of code generation.
+
+    Args:
+        operation (str): Operation name in MindSpore.
+        actual_args (dict): Actual arg values.
+        settings (namedTuple): Code generation setting.
+    """
+
+    def __init__(self, operation, actual_args, input_shape, output_shape, settings=None):
+        self._operation = operation
+        self._input_shape = input_shape
+        self._output_shape = output_shape
+        self._declared_variable_name = None
+        self._output_var_name = list()  # Output variable name(could be multi-opt).
+        self._operation_inputs = list()  # Index indices the order of input.
+        self._operation_extra_inputs = settings
+        self._code_setting = settings
+        self._formal_args_list = dict()
+        self._actual_args_list = actual_args  # Key is the param_key, value is the corresponding value.
+        self._node_type = ""
+
+    @property
+    def code_setting(self):
+        return self._code_setting
+
+    @property
+    def node_type(self):
+        """Node type getter."""
+        return self._node_type
+
+    @node_type.setter
+    def node_type(self, t):
+        """Node type setter."""
+        self._node_type = t
+
+    @property
+    def operation_extra_inputs(self):
+        """Getter of extra operation inputs."""
+        return self._operation_extra_inputs
+
+    @property
+    def declared_var_name(self):
+        """Declared variable name getter."""
+        return self._declared_variable_name
+
+    @declared_var_name.setter
+    def declared_var_name(self, var):
+        """Setter of declared variable name."""
+        self._declared_variable_name = var
+
+    @property
+    def output_var_name(self) -> str:
+        """Getter of output variable name."""
+        return ", ".join(self._output_var_name)
+
+    @output_var_name.setter
+    def output_var_name(self, opt_vars):
+        """
+        Output variable name setter.
+
+        Args:
+            opt_vars (list[str]): Output variable name.
+        """
+        self._output_var_name = opt_vars
+
+    @property
+    def operation_inputs(self):
+        """
+        Operation getter.
+
+        Returns:
+            list[Fragment], list of inputs.
+        """
+        return self._operation_inputs
+
+    def update_operation_inputs(self, ipt):
+        """
+        Update operation inputs.
+
+        Args:
+            ipt (Fragment): Where input comes from.
+        """
+        self._operation_inputs.append(ipt)
+
+    @property
+    def operation(self):
+        """
+        Operation getter.
+
+        Returns:
+            str, operation name to be initialized.
+        """
+        return self._operation
+
+    @operation.setter
+    def operation(self, op: str):
+        """
+        Operation setter.
+
+        Args:
+            op (str): Operation name.
+        """
+        self._operation = op
+
+    @property
+    def actual_args(self) -> dict:
+        """Getter of actual args."""
+        return self._actual_args_list
+
+    @property
+    def formal_args(self) -> dict:
+        """Get formal args."""
+        return self._formal_args_list
+
+    def update_formal_args(self, formal_args: dict):
+        """
+        Update formal args.
+
+        Args:
+            formal_args (dict): To be updated args.
+        """
+        return self._formal_args_list.update(formal_args)
+
+    @property
+    def input_shape(self):
+        return self._input_shape
+
+    @property
+    def output_shape(self):
+        return self._output_shape
+
+
+class CodeFragment(Fragment):
+    """
+    Manage the variables related with code generation.
+
+    For single operation type node, the variables in `CodeLine` stands for:
+    ```python
+    class Module(nn.Cell):
+        def __init__ (self, ...):
+            super(Module, self).__init__()
+            self.<CodeLine.declared_variable_name> = <CodeLine.operation>(<CodeLine.scalar_args>,
+                                                                          <CodeLine.init_trainable_params>)
+            self.<CodeLine.trainable_params[k].param_name> = Tensor(<CodeLine.trainable_params[k].shape>,
+                                                                    dtype=<CodeLine._trainable_params[k].dtype>)
+
+        def construct(self, x, ...):
+            <CodeLine.output_var_name> = self.<CodeLine.declared_variable_name>(<CodeLine.operation_inputs>)
+            ...
+            return output
+    ```
+
+    Args:
+        operation (str): Operation name in MindSpore.
+        actual_args (dict): Actual arg values.
+        settings (namedTuple): Code generation setting.
+    """
+
+    def __init__(self, operation, actual_args, settings, input_shape, output_shape,
+                 trainable_params=None):
+        super(CodeFragment, self).__init__(operation=operation, actual_args=actual_args,
+                                           input_shape=input_shape, output_shape=output_shape,
+                                           settings=settings)
+        self._trainable_params = dict()  # External weights, like Matmul.
+        self._init_trainable_params = trainable_params  # Can put into operation init method, like Conv2d.
+
+    @property
+    def trainable_params(self):
+        return self._trainable_params
+
+
+class ModuleFragment(Fragment):
+    """Manage module type code variables."""
+
+    def __init__(self, operation, actual_args, settings, input_shape, output_shape):
+        super(ModuleFragment, self).__init__(operation=operation, actual_args=actual_args,
+                                             input_shape=input_shape, output_shape=output_shape,
+                                             settings=settings)

mindinsight/mindconverter/graph_based_converter/common/utils.py

@@ -0,0 +1,29 @@
+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+"""Define common utils."""
+from mindinsight.mindconverter.graph_based_converter.constant import SEPARATOR_IN_ONNX_OP
+
+
+def is_converted(operation: str):
+    """
+    Whether convert successful.
+
+    Args:
+        operation (str): Operation name.
+
+    Returns:
+        bool, true or false.
+    """
+    return operation and SEPARATOR_IN_ONNX_OP not in operation

mindinsight/mindconverter/graph_based_converter/hierarchical_tree/__init__.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Hierarchical tree module."""
 import re
+
 from mindinsight.mindconverter.common.log import logger as log
 from .hierarchical_tree import HierarchicalTree
 from ..third_party_graph.onnx_graph_node import OnnxGraphNode
@@ -36,7 +37,6 @@ def _tf_model_node_name_reformat(node: OnnxGraphNode, node_name):
     """
     scope_name = node.scope_name
     new_name = None
-    parent = ""
     regex = r"(?P<parent>.+/)(?P<op>\w+)"
     match = re.match(regex, scope_name)
     parent = match.group("parent")
@@ -74,12 +74,13 @@ class HierarchicalTreeFactory:
                           f"Cannot find {node_name}'s input shape."
                 log.error(err_msg)
             if isinstance(node_inst, OnnxGraphNode):
-                node_name_with_scope = _tf_model_node_name_reformat(
-                    node_inst, node_name)
+                node_name_with_scope = _tf_model_node_name_reformat(node_inst, node_name)
                 node_scope_name[node_name] = node_name_with_scope
                 node_name = node_name_with_scope
 
-            tree.insert(node_inst, node_name, node_input, node_output)
+            node_inst.add_input_and_output_shape(node_input, node_output)
+            tree.insert(node_inst, node_name)
+
         if node_scope_name:
             return tree, node_scope_name
         return tree

mindinsight/mindconverter/graph_based_converter/hierarchical_tree/hierarchical_tree.py

@@ -25,17 +25,18 @@ from treelib import Tree, Node
 from mindinsight.mindconverter.common.log import logger as log
 
 from .name_mgr import ModuleNameMgr, GlobalVarNameMgr
+from ..common.utils import is_converted
 from ..mapper.base import Mapper
 from ..third_party_graph.pytorch_graph_node import PyTorchGraphNode
 from ..third_party_graph.onnx_graph_node import OnnxGraphNode
-from ..constant import SEPARATOR_IN_SCOPE, SEPARATOR_BTW_NAME_AND_ID, FIRST_LEVEL_INDENT, CodeFormatConfig
+from ..constant import SEPARATOR_IN_SCOPE
+from ..constant import CodeFormatConfig
+from ..constant import SEPARATOR_BTW_NAME_AND_ID, FIRST_LEVEL_INDENT
 from ..constant import NEW_LINE, SECOND_LEVEL_INDENT
 from ..constant import NodeType
 from ..report_generator import ReportGenerator
 from ...common.exceptions import NodeTypeNotSupport
 
-GLOBAL_VAR_NAME_MGR = GlobalVarNameMgr()
-
 
 class HierarchicalTree(Tree):
     """Define hierarchical tree."""
@@ -46,6 +47,8 @@ class HierarchicalTree(Tree):
     _root_created = False
     ROOT_LEVEL = 0
 
+    GLOBAL_VAR_NAME_MGR = GlobalVarNameMgr()
+
     def __init__(self):
         super(HierarchicalTree, self).__init__()
         self._hierarchical_order = dict()
@@ -62,6 +65,7 @@ class HierarchicalTree(Tree):
         self._module_vars = dict()
         # scope name mapping record for easy node searching
         self._scope_name_map = dict()
+        self.code_fragment_recorder = dict()
 
     @property
     def tree_identifier(self):
@@ -82,19 +86,15 @@ class HierarchicalTree(Tree):
                 return None
         return self._nodes[nid]
 
-    def insert(self, node: Union[PyTorchGraphNode, OnnxGraphNode],
-               node_name: str, input_shape, output_shape):
+    def insert(self, node: Union[PyTorchGraphNode, OnnxGraphNode], node_name: str):
         """
         Insert node into hierarchical tree.
 
         Args:
             node_name (str): Node name.
             node (Union[PyTorchGraphNode, OnnxGraphNode]): Node to be inserted.
-            output_shape (tuple): Output tensor shape.
-            input_shape (tuple): Input tensor shape.
 
         """
-        node.add_input_and_output_shape(input_shape, output_shape)
         scopes = node_name.split(SEPARATOR_IN_SCOPE)
         for idx, scope in enumerate(scopes):
             parent = SEPARATOR_IN_SCOPE.join(scopes[:idx])
@@ -125,10 +125,9 @@ class HierarchicalTree(Tree):
                 tgt_node.precursor_nodes = node.precursor_nodes
                 tgt_node.node_type = (NodeType.OPERATION if idx == len(scopes) - 1
                                       else NodeType.MODULE).value
-                tgt_node.tag = scope.split(SEPARATOR_BTW_NAME_AND_ID)[0]
                 tgt_node.variable_name = self._get_var_name(identifier)
                 self.create_node(
-                    tag=tgt_node.tag,
+                    tag=scope.split(SEPARATOR_BTW_NAME_AND_ID)[0],
                     identifier=identifier,
                     parent=parent,
                     data=tgt_node
@@ -276,8 +275,7 @@ class HierarchicalTree(Tree):
                     node.data.replace_with_arg(arg, arg)
         return node
 
-    @staticmethod
-    def _clear_unused_args(node, used_args):
+    def _clear_unused_args(self, node, used_args):
         """
         Clear unused args.
 
@@ -290,7 +288,9 @@ class HierarchicalTree(Tree):
         """
         args_in_code = list(node.data.args_in_code.keys())
         for arg in args_in_code:
-            ori_arg = arg.replace(f"_{node.data.variable_name}", "")
+            ori_arg = arg.replace(
+                f"_{self.code_fragment_recorder[node.identifier].declared_var_name}", ""
+            )
             if ori_arg not in used_args:
                 node.data.args_in_code.pop(arg)
         return node
@@ -323,6 +323,8 @@ class HierarchicalTree(Tree):
                 # 1. Generate args for each node in this level.
                 if node.data.node_type == NodeType.MODULE.value:
                     self._create_module_args_and_vars(node, mapper)
+                if depth == depths[-1]:
+                    self.code_fragment_recorder[node.identifier] = node.data.param_transform(mapper, "")
 
         # Module merging based on all nodes.
         self._module_merging()
@@ -345,30 +347,29 @@ class HierarchicalTree(Tree):
                     # then assign the created module name to current node,
                     # and delete unused args.
                     module_name = self._created_module[module_key]
-                    nd_inst.data.froze_node_type_and_module_name(node_type,
-                                                                 module_name)
+                    self.code_fragment_recorder[nd_inst.identifier].operation = module_name
+                    self.code_fragment_recorder[nd_inst.identifier].node_type = node_type
                     self._preprocess_node_args(nd_inst, module_key)
                     continue
 
-                module_name = nd_inst.data.module_name
+                module_name = nd_inst.tag
+
                 if node_type == NodeType.CLASS.value:
                     module_name = f"{module_name[0].upper()}{module_name[1:]}"
 
                 # After node_type and module_name is frozen,
                 # then it's unchangeable.
                 module_name = self._module_mgr.get_name(module_name)
-                nd_inst.data.froze_node_type_and_module_name(node_type,
-                                                             module_name)
+                self.code_fragment_recorder[nd_inst.identifier].operation = module_name
+                self.code_fragment_recorder[nd_inst.identifier].node_type = node_type
 
                 # 3. Pre-process node args.
                 nd_inst = self._preprocess_node_args(nd_inst, module_key)
                 # 4. Post-process child node args.
                 for _, scsr_nd_name in enumerate(nd_inst.successors(self.tree_identifier)):
-                    self._postprocess_node_args(
-                        self.get_node(scsr_nd_name), module_key)
+                    self._postprocess_node_args(self.get_node(scsr_nd_name), module_key)
                 # 5. Generate code.
-                snippets.add(
-                    func(nd_inst, nd_inst.data.module_name, module_key))
+                snippets.add(func(nd_inst, self.code_fragment_recorder[nd_inst.identifier].operation, module_key))
 
             code_blocks.extend(snippets)
 
@@ -437,7 +438,7 @@ class HierarchicalTree(Tree):
         module_list = []
         for node_name in node.successors(self.tree_identifier):
             c_nd = self.get_node(node_name)
-            operator = c_nd.data.op_in_ms or c_nd.data.module_name
+            operator = self.code_fragment_recorder[c_nd.identifier].operation
 
             if c_nd.data.node_type != NodeType.OPERATION.value:
                 hash_key = c_nd.data.hash_key or self.hash_key(c_nd)
@@ -445,14 +446,16 @@ class HierarchicalTree(Tree):
                     operator = self._created_module[hash_key]
 
             args = c_nd.data.args_in_code
-            if c_nd.data.node_type == NodeType.OPERATION.value and \
-                    not c_nd.data.convert_successful():
+            if c_nd.data.node_type == NodeType.OPERATION.value and not is_converted(
+                    self.code_fragment_recorder[c_nd.identifier].operation):
                 args.update({"input_shape": c_nd.data.input_shape,
                              "output_shape": c_nd.data.output_shape})
 
             # Generate code statement.
-            expr = ", ".join([f"{k.replace(f'_{c_nd.data.variable_name}', '')}={v}"
-                              for k, v in args.items()])
+            expr = ", ".join(
+                [f"{k.replace(f'_{self.code_fragment_recorder[c_nd.identifier].declared_var_name}', '')}={v}"
+                 for k, v in args.items()]
+            )
             code_line = f"{operator}({expr})"
             module_list.append(code_line)
 
@@ -547,14 +550,16 @@ class HierarchicalTree(Tree):
 
         if idx != 0:
             # Get previous node output variable name.
-            ipt_args_in_construct = self._get_previous_opt_var(
-                cur_nd_inst, pre_nd_inst)
+            ipt_args_in_construct = self._get_previous_opt_var(cur_nd_inst, pre_nd_inst)
         if idx != len(pre_nd_inst.successors(self.tree_identifier)) - 1:
             # Set opt variable name.
-            opt_arg_in_construct = cur_nd_inst.data.opt_var_name
+            opt_arg_in_construct = f"{self.code_fragment_recorder[cur_nd_inst.identifier].declared_var_name}_opt"
 
         declare, call = cur_nd_inst.data.to_code(ipt_args_in_construct=ipt_args_in_construct,
-                                                 output_var=opt_arg_in_construct)
+                                                 variable_name=self.code_fragment_recorder[
+                                                     cur_nd_inst.identifier].declared_var_name,
+                                                 output_var=opt_arg_in_construct,
+                                                 code_fragment=self.code_fragment_recorder[cur_nd_inst.identifier])
 
         return declare, call
 
@@ -588,7 +593,9 @@ class HierarchicalTree(Tree):
             if e not in pre_nd.successors(self.tree_identifier):
                 while True:
                     if p_nd.identifier in pre_nd.successors(self.tree_identifier):
-                        ipt_lst.append(p_nd.data.opt_var_name)
+                        ipt_lst.append(
+                            f"{self.code_fragment_recorder[p_nd.identifier].declared_var_name}_opt"
+                        )
                         break
                     pre_nd_name = p_nd.predecessor(self.tree_identifier)
                     if not pre_nd_name:
@@ -597,7 +604,9 @@ class HierarchicalTree(Tree):
                     p_nd = self.get_node(pre_nd_name)
                 continue
 
-            ipt_lst.append(p_nd.data.opt_var_name)
+            ipt_lst.append(
+                f"{self.code_fragment_recorder[p_nd.identifier].declared_var_name}_opt"
+            )
         return ipt_lst
 
     def _get_previous_opt_var(self, cur_nd, pre_nd):
@@ -619,12 +628,11 @@ class HierarchicalTree(Tree):
                 cur_nd = self.get_node(p_nd[0])
         return ", ".join(self._find_all_previous_opt_var_(cur_nd, pre_nd))
 
-    def hash_key(self, node, depth: int = 0):
+    def hash_key(self, node):
         """
         Generate hash key for each node.
 
         Args:
-            depth (int): Recursion depth.
             node (Node): Node.
 
         Returns:
@@ -633,13 +641,17 @@ class HierarchicalTree(Tree):
         scsr_topo_order = []
         for s in node.successors(self.tree_identifier):
             cur_nd = self.get_node(s)
-            if cur_nd.data.hash_key:
-                scsr_topo_order.append(f"{cur_nd.data.hash_key}[{depth}]")
-                continue
             if cur_nd.data.node_type in {NodeType.MODULE.value,
                                          NodeType.FUNC.value,
                                          NodeType.CLASS.value}:
-                scsr_topo_order.append(self.hash_key(cur_nd, depth + 1))
+                if cur_nd.data.hash_key:
+                    scsr_topo_order.append(f"({cur_nd.data.hash_key})")
+                    continue
+
+                raise ValueError("Current node doesn't have hash key.")
+
+            if cur_nd.data.hash_key:
+                scsr_topo_order.append(cur_nd.data.hash_key)
                 continue
         unique_key = "->".join(scsr_topo_order)
         node.data.hash_key = unique_key
@@ -675,12 +687,11 @@ class HierarchicalTree(Tree):
         """
         # All args and value pair in current node module.
         module_args = dict()
-        module_settings = dict()
         module_key = self.hash_key(node)
         created = False
 
         if module_key not in self._vars_mgr_in_module:
-            self._vars_mgr_in_module[module_key] = GLOBAL_VAR_NAME_MGR
+            self._vars_mgr_in_module[module_key] = self.GLOBAL_VAR_NAME_MGR
             self._module_vars[module_key] = []
         else:
             created = True
@@ -688,33 +699,29 @@ class HierarchicalTree(Tree):
         # Sub-modules in the module could have arg name conflicts.
         for idx, successor_name in enumerate(node.successors(self.tree_identifier)):
             nd_inst = self.get_node(successor_name)
-            # Generate variable name here, then
-            # to generate args.
+            # Generation of params must behind variable assigment.
             if created:
-                nd_inst.data.variable_name = self._module_vars[module_key][idx]
+                variable_name = self._module_vars[module_key][idx]
             else:
-                variable_name = nd_inst.data.op_name or nd_inst.data.module_name
-                variable_name = self._vars_mgr_in_module[module_key].get_name(
-                    variable_name)
-                nd_inst.data.variable_name = variable_name
+                variable_name = nd_inst.data.op_name or nd_inst.tag
+                variable_name = self._vars_mgr_in_module[module_key].get_name(variable_name)
 
-            # Generation of params must behind variable assigment.
-            nd_inst.data.param_transform(mapper)
+            code_fragment = nd_inst.data.param_transform(mapper, variable_name)
+            code_fragment.declared_var_name = variable_name
+            self.code_fragment_recorder[nd_inst.identifier] = code_fragment
 
             module_args.update(nd_inst.data.args_in_code)
-            module_settings.update(nd_inst.data.settings_in_code)
 
             if not created:
-                self._module_vars[module_key].append(
-                    nd_inst.data.variable_name)
+                self._module_vars[module_key].append(variable_name)
 
         node.data.args_in_code = module_args
 
         # Collect module args of `module_key`.
         if module_key not in self._merged_module:
-            self._merged_module[module_key] = [node.data.args_in_code]
+            self._merged_module[module_key] = [deepcopy(node.data.args_in_code)]
         else:
-            self._merged_module[module_key].append(node.data.args_in_code)
+            self._merged_module[module_key].append(deepcopy(node.data.args_in_code))
 
     @staticmethod
     def _create_operation_args(node, mapper):

mindinsight/mindconverter/graph_based_converter/hierarchical_tree/name_mgr.py

@@ -63,6 +63,10 @@ START_IDX = 0
 class GlobalVarNameMgr:
     """Global variable name mgr."""
 
+    def __init__(self):
+        global_op_namespace.clear()
+        global_var_namespace.clear()
+
     @staticmethod
     def _get_name(name):
         """Deal with op name."""

mindinsight/mindconverter/graph_based_converter/mapper/base.py

@@ -87,7 +87,7 @@ class ONNXToMindSporeMapper(Mapper, abc.ABC):
         module_name = TABLE.get(op_name)
 
         if not module_name:
-            return None, dict(), dict()
+            return None, dict(), None, dict()
 
         pos = module_name.rfind(".")
         try:
@@ -101,7 +101,7 @@ class ONNXToMindSporeMapper(Mapper, abc.ABC):
             # If mapper can not be found, then skip it.
             err_msg = f"Converting {op_name} failed, see {str(e)}"
             log.error(err_msg)
-            return None, dict(), dict()
+            return None, dict(), None, dict()
 
         try:
             converter_name = op_name_converter(
@@ -110,13 +110,13 @@ class ONNXToMindSporeMapper(Mapper, abc.ABC):
             converted_weights = weights_converter(
                 weights=weights) if weights else dict()
             converted_params.update(converted_weights)
-            converted_settings = settings_converter(params=params)
+            converted_settings = settings_converter(params=params, weights=weights)
         except (AttributeError, KeyError, ValueError, TypeError, IndexError) as e:
             err_msg = f"Converting {op_name} failed, see {str(e)}"
             log.error(err_msg)
-            return None, dict(), dict()
+            return None, dict(), None, dict()
 
-        return converter_name, converted_params, converted_settings
+        return converter_name, converted_params, converted_settings, converted_weights
 
     @staticmethod
     def _operation_name_in_ms(*args, **kwargs):

mindinsight/mindconverter/graph_based_converter/mapper/gen_setting.py

@@ -0,0 +1,34 @@
+# 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"

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/batch_norm_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class BatchNormMapper(ONNXToMindSporeMapper):
@@ -39,4 +40,4 @@ class BatchNormMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/conv_mapper.py

@@ -16,6 +16,7 @@
 import re
 import numpy as np
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 def _convert_padding(**kwargs):
@@ -35,6 +36,7 @@ def _convert_padding(**kwargs):
 
 class ConvMapper(ONNXToMindSporeMapper):
     """Conv2d mapper."""
+
     @staticmethod
     def convert_params_torch(**kwargs):
         """Convert params from PyTorch to MindSpore"""
@@ -148,4 +150,4 @@ class ConvMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/dense_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class DenseMapper(ONNXToMindSporeMapper):
@@ -41,4 +42,4 @@ class DenseMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/flatten_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class FlattenMapper(ONNXToMindSporeMapper):
@@ -33,4 +34,4 @@ class FlattenMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/global_pool_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class GlobalPoolMapper(ONNXToMindSporeMapper):
@@ -25,8 +26,7 @@ class GlobalPoolMapper(ONNXToMindSporeMapper):
             op_name = 'nn.AvgPool{}d'
         else:
             op_name = 'nn.MaxPool{}d'
-        dim = 1 if len(kwargs['params']['input_shape']) == 3\
-            else 2
+        dim = 1 if len(kwargs['params']['input_shape']) == 3 else 2
         return op_name.format(dim)
 
     @staticmethod
@@ -49,4 +49,4 @@ class GlobalPoolMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/mat_mul_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting, Tensor, get_dtype
 
 
 class MatMulMapper(ONNXToMindSporeMapper):
@@ -33,4 +34,12 @@ class MatMulMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        weights = kwargs.get("weights")
+        if not weights:
+            return Setting()
+        tensor, ref = None, ""
+        for t_name, t_value in weights.items():
+            tensor = t_value
+            ref = t_name
+        return Setting(op_extra_tensor=Tensor(shape=tensor.shape,
+                                              dtype=get_dtype(tensor), reference=ref))

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/pad_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 def _padding_format_convert(padding: list):
@@ -77,4 +78,4 @@ class PadMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/pool_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class PoolMapper(ONNXToMindSporeMapper):
@@ -49,4 +50,4 @@ class PoolMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/relu_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class ReLUMapper(ONNXToMindSporeMapper):
@@ -45,4 +46,4 @@ class ReLUMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/nn/softmax_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class SoftmaxMapper(ONNXToMindSporeMapper):
@@ -37,4 +38,4 @@ class SoftmaxMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        return Setting()

mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/add_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting, Tensor, get_dtype
 
 
 class AddMapper(ONNXToMindSporeMapper):
@@ -33,4 +34,12 @@ class AddMapper(ONNXToMindSporeMapper):
 
     @staticmethod
     def _convert_settings(**kwargs):
-        return dict()
+        weights = kwargs.get("weights")
+        if not weights:
+            return Setting()
+        tensor, ref = None, ""
+        for t_name, t_value in weights.items():
+            tensor = t_value
+            ref = t_name
+        return Setting(op_extra_tensor=Tensor(shape=tensor.shape,
+                                              dtype=get_dtype(tensor), reference=ref))

mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/concat_mapper.py

@@ -15,6 +15,7 @@
 """Mapper module."""
 from mindinsight.mindconverter.graph_based_converter.constant import InputType
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class ConcatMapper(ONNXToMindSporeMapper):
@@ -36,4 +37,4 @@ class ConcatMapper(ONNXToMindSporeMapper):
     @staticmethod
     def _convert_settings(**kwargs):
         input_type = InputType.LIST.value
-        return {'input_type': input_type}
+        return Setting(op_ipt_type=input_type)

mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/reduce_mean_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class ReduceMeanMapper(ONNXToMindSporeMapper):
@@ -40,4 +41,4 @@ class ReduceMeanMapper(ONNXToMindSporeMapper):
             axis = params['axes'][0] if len(params['axes']) == 1 else tuple(params['axes'])
         else:
             axis = tuple()
-        return {'values': {'axis': axis}}
+        return Setting(op_extra_input={'axis': axis})

mindinsight/mindconverter/graph_based_converter/mapper/impl/ops/transpose_mapper.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mapper module."""
 from ...base import ONNXToMindSporeMapper
+from ...gen_setting import Setting
 
 
 class TransposeMapper(ONNXToMindSporeMapper):
@@ -40,4 +41,4 @@ class TransposeMapper(ONNXToMindSporeMapper):
             perm = tuple(perm)
             converted_params['input_perm'] = perm
 
-        return {'values': converted_params}
+        return Setting(op_extra_input=converted_params)

mindinsight/mindconverter/graph_based_converter/third_party_graph/base.py

@@ -15,10 +15,13 @@
 """Define graph entity."""
 import abc
 from collections import OrderedDict
+from copy import deepcopy
 
 from mindinsight.mindconverter.common.log import logger as log
-from ..constant import SEPARATOR_IN_ONNX_OP
+from ..common.code_fragment import CodeFragment
+from ..constant import NodeType, InputType
 from ..mapper.base import Mapper
+from ...common.exceptions import NodeInputTypeNotSupport
 
 
 class GraphParser(metaclass=abc.ABCMeta):
@@ -287,26 +290,10 @@ class GraphNode(abc.ABC):
         self._op_params = dict()
         self._scope_name = None
         self._op_shape = None
-        # Operation in mindspore.
-        self._op_in_ms = None
-        # Params in mindspore.
-        self._params_in_ms = dict()
-        # Settings in mindspore.
-        self._settings_in_ms = dict()
         # Node type of current node, e.g. class, module, operation.
         self._node_type = None
-        # Tag name on tree.
-        self._tag_on_tree = None
         # Function, class or operation needed args.
         self._args_in_code = dict()
-        # Operation needed settings.
-        self._settings_in_code = dict()
-        # Variable name declared in init block.
-        self._variable_name = None
-        # Output variable name declared in construct block.
-        self._opt_var_name = None
-        # Function or class name in code.
-        self._module_name = None
         # Unique key of node.
         self._hash_key = None
         # Input shape of current op.
@@ -317,37 +304,18 @@ class GraphNode(abc.ABC):
         self._weight = None
 
     @property
-    def opt_var_name(self):
+    def weight(self):
+        return self._weight
+
+    @staticmethod
+    def get_opt_var_name(variable_name):
         """
         Output variable name.
 
         Returns:
             str, variable name.
         """
-        return f"{self.variable_name}_opt"
-
-    @opt_var_name.setter
-    def opt_var_name(self, v):
-        """
-        Set variable name.
-
-        Args:
-            v (str): Name.
-
-        """
-        self._opt_var_name = v
-
-    @property
-    def op_in_ms(self):
-        """
-        Operation in mindspore.
-
-        Returns:
-            str, operation name.
-        """
-        if self._op_in_ms and SEPARATOR_IN_ONNX_OP in self._op_in_ms:
-            return self._op_in_ms.replace(SEPARATOR_IN_ONNX_OP, ".")
-        return self._op_in_ms
+        return f"{variable_name}_opt"
 
     @property
     def args_in_code(self):
@@ -370,27 +338,6 @@ class GraphNode(abc.ABC):
         """
         self._args_in_code = args
 
-    @property
-    def settings_in_code(self):
-        """
-        Settings in code.
-
-        Returns:
-            dict, settings.
-        """
-        return self._settings_in_code
-
-    @settings_in_code.setter
-    def settings_in_code(self, settings):
-        """
-        Settings in code.
-
-        Args:
-            settings(dict): Settings.
-
-        """
-        self._settings_in_code = settings
-
     @property
     def input_shape(self):
         """
@@ -411,16 +358,6 @@ class GraphNode(abc.ABC):
         """
         return self._opt_shape
 
-    @property
-    def tag(self):
-        """Tag on hierarchical tree."""
-        return self._tag_on_tree
-
-    @tag.setter
-    def tag(self, t):
-        """Tag on hierarchical tree."""
-        self._tag_on_tree = t
-
     def is_empty(self):
         """
         Whether is empty.
@@ -536,7 +473,7 @@ class GraphNode(abc.ABC):
         """Replace actual parameter with formal parameter."""
 
     @abc.abstractmethod
-    def _get_arg_name(self, arg):
+    def _get_arg_name(self, arg, variable_name):
         """Get arg name for func or class."""
 
     @abc.abstractmethod
@@ -553,13 +490,8 @@ class GraphNode(abc.ABC):
     def real_name(self, **kwargs):
         """Setter of `real_name`."""
 
-    @property
-    @abc.abstractmethod
-    def variable_name(self):
-        """Getter of `variable_name`."""
-
     @abc.abstractmethod
-    def to_code(self, ipt_args_in_construct: str, output_var: str):
+    def to_code(self, ipt_args_in_construct: str, variable_name: str, output_var: str, code_fragment):
         """Graph node to MindSpore code."""
 
     @abc.abstractmethod
@@ -570,40 +502,86 @@ class GraphNode(abc.ABC):
     def add_input_and_output_shape(self, input_shape, output_shape):
         """Add the node input shape."""
 
-    @abc.abstractmethod
-    def froze_node_type_and_module_name(self, node_type, module_name):
-        """Make node_type can not be changed."""
+    @staticmethod
+    def _generate_ipt_args_settings_in_construct(ipt_args_in_construct, settings):
+        """
+        Generate input with args and settings in construct.
 
-    @abc.abstractmethod
-    def convert_successful(self):
-        """Whether convert successful."""
+        Args:
+            ipt_args_in_construct (str): Input args in construct.
+            settings (Setting): Settings in operator.
+
+        Returns:
+            str, args of each node in generated construct statement.
+        """
+        if settings and settings.op_ipt_type:
+            input_type = settings.op_ipt_type
+            if input_type == InputType.TENSOR.value:
+                ipt_args_settings_in_construct = ipt_args_in_construct
+            elif input_type == InputType.LIST.value:
+                ipt_args_settings_in_construct = f"({ipt_args_in_construct})"
+            else:
+                raise NodeInputTypeNotSupport(f"Input type[{input_type}] is not supported now.")
+        else:
+            ipt_args_settings_in_construct = ipt_args_in_construct
+
+        if settings and settings.op_extra_input:
+            settings_value = settings.op_extra_input
+            if settings_value:
+                settings_in_construct = ', '.join([f"{setting_val}" for _, setting_val in settings_value.items()])
+                ipt_args_settings_in_construct = ', '.join((ipt_args_settings_in_construct, settings_in_construct))
 
-    def param_transform(self, mapper: Mapper):
+        return ipt_args_settings_in_construct
+
+    def param_transform(self, mapper: Mapper, variable_name):
         """
-        Transform param in pytorch operation into mindspore.
+        Transform param in PyTorch operation into MindSpore.
 
         Args:
+            variable_name (str): Variable name.
             mapper (ONNXToMindSporeMapper): Mapper between onnx operation
-                and mindspore.
+                and MindSpore.
 
         Returns:
             dict, transformed params.
         """
-        import copy
-        params = copy.deepcopy(self._op_params)
+        if self._node_type != NodeType.OPERATION.value:
+            args = deepcopy(self._args_in_code)
+            self._args_in_code = dict()
+            for arg, value in args.items():
+                self._args_in_code[self._get_arg_name(arg, variable_name)] = value
+            return CodeFragment(operation="", actual_args=args, settings=None,
+                                input_shape=self.input_shape, output_shape=self.output_shape)
+
+        if self.transformed:
+            raise ValueError("Already transformed.")
+
+        params = deepcopy(self._op_params)
         params.update({"input_shape": self.input_shape,
                        "output_shape": self.output_shape})
 
-        op_name_in_mindspore, ms_params, ms_settings = mapper.convert(op_name=self.op_name,
-                                                                      params=params,
-                                                                      weights=self._weight)
-        if op_name_in_mindspore:
-            self._op_in_ms = op_name_in_mindspore
-            self._params_in_ms = ms_params
-            self._settings_in_ms = ms_settings
+        ms_op, ms_params, ms_settings, ms_weights = mapper.convert(op_name=self.op_name,
+                                                                   params=params,
+                                                                   weights=self._weight)
+
+        if ms_op:
+            code_fragment = CodeFragment(operation=ms_op,
+                                         actual_args=ms_params,
+                                         settings=ms_settings,
+                                         input_shape=self.input_shape,
+                                         output_shape=self.output_shape,
+                                         trainable_params=ms_weights)
         else:
-            self._op_in_ms = self._op_name
-            self._params_in_ms = self._op_params
-            self._settings_in_ms = dict()
+            code_fragment = CodeFragment(operation=self._op_name,
+                                         actual_args=self._op_params,
+                                         settings=None,
+                                         input_shape=self.input_shape,
+                                         output_shape=self.output_shape,
+                                         trainable_params=self._weight)
+
+        for arg, value in code_fragment.actual_args.items():
+            self._args_in_code[self._get_arg_name(arg, variable_name)] = value
+
+        self.transformed = True
 
-        return self._op_in_ms, self._params_in_ms, self._settings_in_ms
+        return code_fragment

mindinsight/mindconverter/graph_based_converter/third_party_graph/graph_parser.py

@@ -38,7 +38,6 @@ class PyTorchGraphParser(GraphParser):
             error = FileNotFoundError("`model_path` must be assigned with "
                                       "an existed file path.")
             log.error(str(error))
-            log.exception(error)
             raise error
 
         try:

mindinsight/mindconverter/graph_based_converter/third_party_graph/input_node.py

@@ -21,24 +21,18 @@ from ..constant import SEPARATOR_IN_SCOPE, NodeType
 
 class InputNode(GraphNode):
     """
-    Pytorch Input Node.
+    PyTorch Input Node.
 
     Args:
         input_shape: Input shape of module.
 
     """
 
-    def convert_successful(self):
-        """
-        Whether convert successful.
-
-        Returns:
-            bool, true or false.
-        """
-        return False
+    def _get_arg_name(self, arg, variable_name):
+        raise NotImplementedError()
 
-    def froze_node_type_and_module_name(self, node_type, module_name):
-        pass
+    def to_code(self, ipt_args_in_construct: str, variable_name: str, output_var: str, code_fragment):
+        raise NotImplementedError()
 
     def _get_raw_params(self, node):
         pass
@@ -56,9 +50,6 @@ class InputNode(GraphNode):
     def replace_with_arg(self, src_arg, tgt_arg):
         pass
 
-    def _get_arg_name(self, arg):
-        pass
-
     def add_input_and_output_shape(self, input_shape, output_shape):
         pass
 
@@ -116,15 +107,8 @@ class InputNode(GraphNode):
     def real_name(self):
         return
 
-    @property
-    def variable_name(self):
-        return
-
     def to_ir(self):
         """
         No need to implement for now.
         """
         raise NotImplementedError()
-
-    def to_code(self, ipt_args_in_construct: str, output_var: str):
-        raise NotImplementedError()

mindinsight/mindconverter/graph_based_converter/third_party_graph/onnx_graph.py

@@ -22,7 +22,6 @@ from .onnx_graph_node import OnnxGraphNode
 from .graph_parser import TFGraphParser
 from .onnx_utils import OnnxDataLoader
 
-
 NONE_SCOPE_OP = {
     "onnx::Add": "Add",
     "onnx::Flatten": "Flatten",

mindinsight/mindconverter/graph_based_converter/third_party_graph/onnx_graph_node.py

@@ -13,14 +13,13 @@
 # limitations under the License.
 # ==============================================================================
 """Define ONNX graph node."""
+from importlib import import_module
 
-from copy import deepcopy
 from .base import GraphNode
+from ..common.utils import is_converted
 
-from ..constant import NodeType, SEPARATOR_IN_SCOPE, \
-    SEPARATOR_BTW_NAME_AND_ID, LEFT_BUCKET, RIGHT_BUCKET, SEPARATOR_IN_ONNX_OP, InputType
-from ..mapper.base import Mapper
-from ...common.exceptions import NodeInputTypeNotSupport
+from ..constant import NodeType, SEPARATOR_IN_SCOPE, SEPARATOR_BTW_NAME_AND_ID, LEFT_BUCKET, RIGHT_BUCKET, \
+    SEPARATOR_IN_ONNX_OP
 
 
 class OnnxGraphNode(GraphNode):
@@ -39,16 +38,13 @@ class OnnxGraphNode(GraphNode):
         self._op_params = self._get_raw_params(node.raw_node) if node else None
         self._op_name = "onnx::" + node.op_type if node else None
         self._scope_name = node.scope_name if node else None
-        self._opt_var_name = None
-        self._variable_name = self._extract_var_name(self._scope_name)
-        self._module_name = None
         self._weight = weight
 
     def clear_args_of_declaration(self):
         """Clear `self._args_in_code`."""
         self._args_in_code = dict()
 
-    def _get_arg_name(self, arg):
+    def _get_arg_name(self, arg, variable_name):
         """
         Get arg name.
 
@@ -58,7 +54,7 @@ class OnnxGraphNode(GraphNode):
         Returns:
             str, arg name in function or class declaration.
         """
-        return f"{arg}_{self._variable_name}"
+        return f"{arg}_{variable_name}"
 
     @property
     def hash_key(self):
@@ -84,51 +80,6 @@ class OnnxGraphNode(GraphNode):
         """
         self._hash_key = h
 
-    @property
-    def variable_name(self):
-        """
-        Variable name.
-
-        Returns:
-            str, variable name declared in init.
-        """
-        return self._variable_name
-
-    @variable_name.setter
-    def variable_name(self, v):
-        """
-        Setter of variable name.
-
-        Args:
-            v (str): Variable name.
-        """
-        self._variable_name = v
-
-    @property
-    def module_name(self):
-        """
-        Module name.
-
-        Returns:
-            str, module name.
-        """
-        if not self._module_name_frozen:
-            module_name = self.tag
-            return module_name
-
-        return self._module_name
-
-    def _froze_module_name(self, m):
-        """
-        Once module_name is set, then it's unchangeable.
-
-        Args:
-            m (str): Module name.
-        """
-        if not self._module_name_frozen:
-            self._module_name = m
-            self._module_name_frozen = True
-
     @property
     def op_name(self):
         """
@@ -154,15 +105,13 @@ class OnnxGraphNode(GraphNode):
         self._ipt_shape = input_shape
         self._opt_shape = output_shape
 
-    def _add_tensor_args_to_code(self, op_name: str, t_identifier: str, declare, args):
+    def _add_tensor_args_to_code(self, op_name: str, settings, declare, args, variable_name):
         """
         Add nn used tensors to args in init and construct blocks.
 
         Args:
             op_name (str): Add the tensor to args if the current node has this
-                           op_name.
-            t_identifier (str): The unique string appeared in the target tensor
-                                name.
+                op_name.
             declare (str): Declare statement generated in to_code().
             args (str): Args statement generated in to_code().
 
@@ -172,103 +121,68 @@ class OnnxGraphNode(GraphNode):
         """
         if not self._op_name == op_name:
             return declare, args
-        declare_list = []
-        tensor = None
-        # find target tensor
-        for t_name, t_value in self._weight.items():
-            if t_identifier in t_name:
-                tensor = t_value
-                break
-        if tensor is None:
+        if not settings or not settings.op_extra_tensor:
             return declare, args
-        declare_list.append(declare)
-        declare_t = f"self.{self._variable_name}_w = Tensor(" \
-            f"np.random.uniform(0, 1, {str(tensor.shape)}), mindspore.float32)"
+        declare_list = [declare]
+        declare_t = f"self.{variable_name}_w = Tensor(" \
+                    f"np.random.uniform(0, 1, {str(settings.op_extra_tensor.shape)}), " \
+                    f"{settings.op_extra_tensor.dtype})"
         declare_list.append(declare_t)
-        args += f", self.{self._variable_name}_w"
+        args += f", self.{variable_name}_w"
         return declare_list, args
 
-    def to_code(self, ipt_args_in_construct: str, output_var: str):
+    def to_code(self, ipt_args_in_construct: str, variable_name: str, output_var: str,
+                code_fragment):
         """
         Generate statements.
 
         Args:
+            variable_name (str): Variable name.
             ipt_args_in_construct (str): Args of input.
             output_var (str): Output variable name in construct.
+            code_fragment (CodeFragment): CodeFragment instance.
 
         Returns:
             Union[str, str], declare in init and call in construct.
         """
-        operator = self.op_in_ms or self.module_name
-        self._opt_var_name = output_var
+        operator = code_fragment.operation
 
         args = self.args_in_code
-        settings = self.settings_in_code
-        if self._node_type == NodeType.OPERATION.value and not self.convert_successful():
+        settings = code_fragment.code_setting
+
+        if self._node_type == NodeType.OPERATION.value and not is_converted(code_fragment.operation):
             args.update({"input_shape": self.input_shape,
                          "output_shape": self.output_shape})
 
         if self._node_type == NodeType.OPERATION.value:
-            expr = ", ".join([f"{k.replace(f'_{self._variable_name}', '')}={v}"
+            expr = ", ".join([f"{k.replace(f'_{variable_name}', '')}={v}"
                               for k, v in args.items()])
-            ipt_args_settings_in_construct = \
-                self._generate_ipt_args_settings_in_construct(
-                    ipt_args_in_construct,
-                    settings)
+            ipt_args_settings_in_construct = self._generate_ipt_args_settings_in_construct(
+                ipt_args_in_construct, settings)
         else:
             # When it's type is module, class or func,
             # it's not necessary to replace var.
-            expr = ", ".join([f"{k.replace(f'_{self._variable_name}', '')}={v}"
+            expr = ", ".join([f"{k.replace(f'_{variable_name}', '')}={v}"
                               for k, v in args.items()])
             ipt_args_settings_in_construct = ipt_args_in_construct
-        declare = f"self.{self._variable_name} = {operator}({expr})"
+
+        if SEPARATOR_IN_ONNX_OP in operator:
+            operator = operator.replace(SEPARATOR_IN_ONNX_OP, ".")
+
+        declare = f"self.{variable_name} = {operator}({expr})"
 
         # Extra Tensor generator for nn.MatMul
         declare, ipt_args_settings_in_construct = self._add_tensor_args_to_code(
-            'onnx::MatMul', 'MatMul', declare, ipt_args_settings_in_construct)
+            'onnx::MatMul', settings, declare, ipt_args_settings_in_construct, variable_name)
 
         # Extra Tensor generator for onnx::Add
         declare, ipt_args_settings_in_construct = self._add_tensor_args_to_code(
-            'onnx::Add', 'BiasAdd', declare, ipt_args_settings_in_construct)
+            'onnx::Add', settings, declare, ipt_args_settings_in_construct, variable_name)
 
-        call = f"{self._opt_var_name} = self.{self._variable_name}({ipt_args_settings_in_construct})"
+        call = f"{output_var} = self.{variable_name}({ipt_args_settings_in_construct})"
 
         return declare, call
 
-    @staticmethod
-    def _generate_ipt_args_settings_in_construct(ipt_args_in_construct, settings):
-        """
-        Generate input with args and settings in construct.
-
-        Args:
-            ipt_args_in_construct(str): Input args in construct.
-            settings(dict): Settings in operator.
-
-        Returns:
-            str, args of each node in generated construct statement.
-        """
-        if settings.get('input_type'):
-            input_type = settings['input_type']
-            if input_type == InputType.TENSOR.value:
-                ipt_args_settings_in_construct = ipt_args_in_construct
-            elif input_type == InputType.LIST.value:
-                ipt_args_settings_in_construct = f"({ipt_args_in_construct})"
-            else:
-                raise NodeInputTypeNotSupport(
-                    f"Input type[{input_type}] is not supported now.")
-        else:
-            ipt_args_settings_in_construct = ipt_args_in_construct
-
-        if settings.get('values'):
-            settings_value = settings['values']
-            if settings_value:
-                settings_in_construct = ', '.join(
-                    [f"{setting_val}" for _, setting_val in settings_value.items()])
-                ipt_args_settings_in_construct = ', '.join(
-                    (ipt_args_settings_in_construct, settings_in_construct))
-
-        return ipt_args_settings_in_construct
-
     def to_ir(self):
         """No need to implement for now."""
         raise NotImplementedError
@@ -284,7 +198,7 @@ class OnnxGraphNode(GraphNode):
         Returns:
             dict, raw params.
         """
-        import onnx
+        onnx = import_module("onnx")
 
         raw_params = dict()
 
@@ -318,62 +232,3 @@ class OnnxGraphNode(GraphNode):
         var = var.replace(LEFT_BUCKET, SEPARATOR_BTW_NAME_AND_ID).replace(
             RIGHT_BUCKET, "")
         return var
-
-    def param_transform(self, mapper: Mapper):
-        """
-        Transform tensorflow params into mindspore.
-
-        Args:
-            mapper (Mapper): Mapper of params.
-
-        """
-        if self._node_type != NodeType.OPERATION.value:
-            args = deepcopy(self._args_in_code)
-            self._args_in_code = dict()
-            for arg, value in args.items():
-                self._args_in_code[self._get_arg_name(arg)] = value
-            return None, None
-
-        if not self.transformed:
-            _, _, _ = super(OnnxGraphNode, self).param_transform(mapper)
-
-            for arg, value in self._params_in_ms.items():
-                self._args_in_code[self._get_arg_name(arg)] = value
-
-            for arg, value in self._settings_in_ms.items():
-                self._settings_in_code[arg] = value
-
-            self.transformed = True
-
-        return self._op_in_ms, self._params_in_ms, self._settings_in_ms
-
-    def froze_node_type_and_module_name(self, node_type, module_name):
-        """
-        Froze node type and module name.
-
-        After node_type is frozen, then the `module_name`
-        will be affected when `node_type` is `class`.
-        Thus, this line must be placed before `nd_inst.data.module_name`.
-
-        Args:
-            module_name: Modified module name.
-            node_type (str): Node type, class of func.
-
-        """
-        if not self._type_frozen:
-            self._node_type = node_type
-            self._type_frozen = True
-
-        if not self._module_name_frozen:
-            self._froze_module_name(module_name)
-
-    def convert_successful(self):
-        """
-        Whether convert successfully.
-
-        Returns:
-            bool, true or false.
-        """
-        if self._op_in_ms and SEPARATOR_IN_ONNX_OP not in self._op_in_ms:
-            return True
-        return False

mindinsight/mindconverter/graph_based_converter/third_party_graph/onnx_utils.py

@@ -87,7 +87,8 @@ def convert_tf_graph_to_onnx(model_path, model_inputs, model_outputs, opset=None
                              inputs_as_nchw=None
                              )
     opt_map = getattr(optimizer.back_to_back_optimizer, '_func_map')
-    opt_map.pop(('Conv', 'BatchNormalization'))
+    if ('Conv', 'BatchNormalization') in opt_map:
+        opt_map.pop(('Conv', 'BatchNormalization'))
     onnx_graph = optimizer.optimize_graph(g)
     model_proto = onnx_graph.make_model("converted from {}".format(model_path))
 
@@ -228,8 +229,7 @@ class OnnxNode(BaseNode):
     """
 
     def __init__(self, raw_node):
-        super(OnnxNode, self).__init__(
-            node_name=raw_node.name, op_type=raw_node.op_type)
+        super(OnnxNode, self).__init__(node_name=raw_node.name, op_type=raw_node.op_type)
         self.raw_node = raw_node
         self.params = ParamsAttribute(raw_node.attribute, raw_node)
         self.scope_name = None

mindinsight/mindconverter/graph_based_converter/third_party_graph/pytorch_graph.py

@@ -99,8 +99,8 @@ class PyTorchGraph(Graph):
 
         for item in input_shape:
             if not isinstance(item, int):
-                err_msg = f"Only support model with one input now, " \
-                          f"and each shape value in `input_shape` should be int."
+                err_msg = "Only support model with one input now, " \
+                          "and each shape value in `input_shape` should be int."
                 log.error(err_msg)
                 raise ValueError(err_msg)
 

mindinsight/mindconverter/graph_based_converter/third_party_graph/pytorch_graph_node.py

@@ -13,14 +13,11 @@
 # limitations under the License.
 # ==============================================================================
 """Define PyTorch graph node."""
-from copy import deepcopy
-
 from .base import GraphNode
+from ..common.utils import is_converted
 
 from ..constant import NodeType, SEPARATOR_IN_SCOPE, SEPARATOR_BTW_NAME_AND_ID, LEFT_BUCKET, RIGHT_BUCKET, \
-    SEPARATOR_IN_ONNX_OP, InputType
-from ..mapper.base import Mapper
-from ...common.exceptions import NodeInputTypeNotSupport
+    SEPARATOR_IN_ONNX_OP
 
 
 class PyTorchGraphNode(GraphNode):
@@ -40,9 +37,6 @@ class PyTorchGraphNode(GraphNode):
         self._op_params = self._get_raw_params(node)
         self._op_name = node.kind() if node else None
         self._scope_name = node.scopeName() if node else None
-        self._opt_var_name = None
-        self._variable_name = self._extract_var_name(self._scope_name)
-        self._module_name = None
         self._weight = weight
 
     def clear_args_of_declaration(self):
@@ -51,7 +45,7 @@ class PyTorchGraphNode(GraphNode):
         """
         self._args_in_code = dict()
 
-    def _get_arg_name(self, arg):
+    def _get_arg_name(self, arg, variable_name):
         """
         Get arg name.
 
@@ -61,7 +55,7 @@ class PyTorchGraphNode(GraphNode):
         Returns:
             str, arg name in function or class declaration.
         """
-        return f"{arg}_{self._variable_name}"
+        return f"{arg}_{variable_name}"
 
     @property
     def hash_key(self):
@@ -88,53 +82,6 @@ class PyTorchGraphNode(GraphNode):
         """
         self._hash_key = h
 
-    @property
-    def variable_name(self):
-        """
-        Variable name.
-
-        Returns:
-            str, variable name declared in init.
-        """
-        return self._variable_name
-
-    @variable_name.setter
-    def variable_name(self, v):
-        """
-        Setter of variable name.
-
-        Args:
-            v (str): Variable name.
-
-        """
-        self._variable_name = v
-
-    @property
-    def module_name(self):
-        """
-        Module name.
-
-        Returns:
-            str, module name.
-        """
-        if not self._module_name_frozen:
-            module_name = self.tag
-            return module_name
-
-        return self._module_name
-
-    def _froze_module_name(self, m):
-        """
-        Once module_name is set, then it's unchangeable.
-
-        Args:
-            m (str): Module name.
-
-        """
-        if not self._module_name_frozen:
-            self._module_name = m
-            self._module_name_frozen = True
-
     @property
     def op_name(self):
         """
@@ -172,72 +119,47 @@ class PyTorchGraphNode(GraphNode):
         self._ipt_shape = input_shape
         self._opt_shape = output_shape
 
-    def to_code(self, ipt_args_in_construct: str, output_var: str):
+    def to_code(self, ipt_args_in_construct: str, variable_name: str, output_var: str, code_fragment):
         """
         Generate statements.
 
         Args:
+            variable_name (str): Variable name.
             ipt_args_in_construct (str): Args of input.
             output_var (str): Output variable name in construct.
+            code_fragment (CodeFragment): CodeFragment instance.
 
         Returns:
             Union[str, str], declare in init and call in construct.
         """
-        operator = self.op_in_ms or self.module_name
-        self._opt_var_name = output_var
+        operator = code_fragment.operation
 
         args = self.args_in_code
-        settings = self.settings_in_code
+        settings = code_fragment.code_setting
 
-        if self._node_type == NodeType.OPERATION.value and not self.convert_successful():
+        if self._node_type == NodeType.OPERATION.value and not is_converted(code_fragment.operation):
             args.update({"input_shape": self.input_shape,
                          "output_shape": self.output_shape})
 
         if self._node_type == NodeType.OPERATION.value:
-            expr = ", ".join([f"{k.replace(f'_{self._variable_name}', '')}={v}"
+            expr = ", ".join([f"{k.replace(f'_{variable_name}', '')}={v}"
                               for k, v in args.items()])
-            ipt_args_settings_in_construct = self._generate_ipt_args_settings_in_construct(ipt_args_in_construct,
-                                                                                           settings)
+            ipt_args_settings_in_construct = self._generate_ipt_args_settings_in_construct(
+                ipt_args_in_construct, settings)
         else:
             # When it's type is module, class or func,
             # it's not necessary to replace var.
-            expr = ", ".join([f"{k.replace(f'_{self._variable_name}', '')}={v}"
+            expr = ", ".join([f"{k.replace(f'_{variable_name}', '')}={v}"
                               for k, v in args.items()])
             ipt_args_settings_in_construct = ipt_args_in_construct
 
-        declare = f"self.{self._variable_name} = {operator}({expr})"
-        call = f"{self._opt_var_name} = self.{self._variable_name}({ipt_args_settings_in_construct})"
-
-        return declare, call
-
-    @staticmethod
-    def _generate_ipt_args_settings_in_construct(ipt_args_in_construct, settings):
-        """
-        Generate input with args and settings in construct.
-
-        Args:
-            ipt_args_in_construct(str): input args in construct.
-            settings(dict): settings in operator.
-
-        """
-        if settings.get('input_type'):
-            input_type = settings['input_type']
-            if input_type == InputType.TENSOR.value:
-                ipt_args_settings_in_construct = ipt_args_in_construct
-            elif input_type == InputType.LIST.value:
-                ipt_args_settings_in_construct = f"({ipt_args_in_construct})"
-            else:
-                raise NodeInputTypeNotSupport(f"Input type[{input_type}] is not supported now.")
-        else:
-            ipt_args_settings_in_construct = ipt_args_in_construct
+        if SEPARATOR_IN_ONNX_OP in operator:
+            operator = operator.replace(SEPARATOR_IN_ONNX_OP, ".")
 
-        if settings.get('values'):
-            settings_value = settings['values']
-            if settings_value:
-                settings_in_construct = ', '.join([f"{setting_val}" for _, setting_val in settings_value.items()])
-                ipt_args_settings_in_construct = ', '.join((ipt_args_settings_in_construct, settings_in_construct))
+        declare = f"self.{variable_name} = {operator}({expr})"
+        call = f"{output_var} = self.{variable_name}({ipt_args_settings_in_construct})"
 
-        return ipt_args_settings_in_construct
+        return declare, call
 
     def to_ir(self):
         """
@@ -288,62 +210,3 @@ class PyTorchGraphNode(GraphNode):
         var = var.replace(LEFT_BUCKET, SEPARATOR_BTW_NAME_AND_ID).replace(
             RIGHT_BUCKET, "")
         return var
-
-    def param_transform(self, mapper: Mapper):
-        """
-        Transform torch params into mindspore.
-
-        Args:
-            mapper (Mapper): Mapper of params.
-
-        """
-        if self._node_type != NodeType.OPERATION.value:
-            args = deepcopy(self._args_in_code)
-            self._args_in_code = dict()
-            for arg, value in args.items():
-                self._args_in_code[self._get_arg_name(arg)] = value
-            return None, None, None
-
-        if not self.transformed:
-            _, _, _ = super(PyTorchGraphNode, self).param_transform(mapper)
-
-            for arg, value in self._params_in_ms.items():
-                self._args_in_code[self._get_arg_name(arg)] = value
-
-            for arg, value in self._settings_in_ms.items():
-                self._settings_in_code[arg] = value
-
-            self.transformed = True
-
-        return self._op_in_ms, self._params_in_ms, self._settings_in_ms
-
-    def froze_node_type_and_module_name(self, node_type, module_name):
-        """
-        Froze node type and module name.
-
-        After node_type is frozen, then the `module_name`
-        will be affected when `node_type` is `class`.
-        Thus, this line must be placed before `nd_inst.data.module_name`.
-
-        Args:
-            module_name: Modified module name.
-            node_type (str): Node type, class of func.
-
-        """
-        if not self._type_frozen:
-            self._node_type = node_type
-            self._type_frozen = True
-
-        if not self._module_name_frozen:
-            self._froze_module_name(module_name)
-
-    def convert_successful(self):
-        """
-        Whether convert successfully.
-
-        Returns:
-            bool, true or false.
-        """
-        if self._op_in_ms and SEPARATOR_IN_ONNX_OP not in self._op_in_ms:
-            return True
-        return False

tests/ut/mindconverter/graph_based_converter/hierarchical_tree/test_hierarchical_tree.py

@@ -42,7 +42,7 @@ class TestHierarchicalTree:
         get_raw_params.return_value = []
         tree = HierarchicalTree()
         pt_node = PyTorchGraphNode()
-        tree.insert(pt_node, 'ResNet', (1, 3, 224, 224), (1, 64, 112, 112))
+        tree.insert(pt_node, 'ResNet')
         assert tree.root == 'ResNet'
 
     def test_remove(self):

tests/ut/mindconverter/graph_based_converter/mapper/test_mapper.py

@@ -17,11 +17,13 @@ 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
 from tests.utils import mindspore
 
 
 class TestMappers:
     """Test Mappers."""
+
     @pytest.mark.parametrize('params', [{
         'input': {'op_name': 'onnx::Conv',
                   'params': {'dilations': [1, 1],
@@ -38,7 +40,7 @@ class TestMappers:
                                                  'pad_mode': '\"pad\"',
                                                  'dilation': (1, 1),
                                                  'group': 1},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Conv',
                   'params': {'dilations': [1, 1],
@@ -55,7 +57,7 @@ class TestMappers:
                                                  'pad_mode': '\"valid\"',
                                                  'dilation': (1, 1),
                                                  'group': 1},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Gemm',
                   'params': dict(),
@@ -65,7 +67,7 @@ class TestMappers:
                             'converted_params': {'in_channels': 3,
                                                  'out_channels': 10,
                                                  'has_bias': True},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::BatchNormalization',
                   'params': {'epsilon': 1e-5,
@@ -76,14 +78,14 @@ class TestMappers:
                             'converted_params': {'num_features': 6,
                                                  'eps': 1e-5,
                                                  'momentum': 0.9},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Relu',
                   'params': dict(),
                   'weights': dict()},
         'expected_output': {'converter_name': 'nn.ReLU',
                             'converted_params': dict(),
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::MaxPool',
                   'params': {'kernel_shape': [3, 3],
@@ -94,7 +96,7 @@ class TestMappers:
                             'converted_params': {'kernel_size': (3, 3),
                                                  'stride': (2, 2),
                                                  'pad_mode': '"same"'},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::AveragePool',
                   'params': {'kernel_shape': [3, 3],
@@ -105,7 +107,7 @@ class TestMappers:
                             'converted_params': {'kernel_size': (3, 3),
                                                  'stride': (2, 2),
                                                  'pad_mode': '"same"'},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::GlobalAveragePool',
                   'params': {'input_shape': (1, 3, 10, 10),
@@ -113,21 +115,21 @@ class TestMappers:
                   'weights': ''},
         'expected_output': {'converter_name': 'nn.AvgPool2d',
                             'converted_params': {'kernel_size': (10, 10)},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Flatten',
                   'params': dict(),
                   'weights': dict()},
         'expected_output': {'converter_name': 'nn.Flatten',
                             'converted_params': dict(),
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Add',
                   'params': dict(),
                   'weights': dict()},
         'expected_output': {'converter_name': 'P.TensorAdd',
                             'converted_params': dict(),
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Pad',
                   'params': {'pads': [0, 1, 2, 3],
@@ -137,7 +139,7 @@ class TestMappers:
         'expected_output': {'converter_name': 'nn.Pad',
                             'converted_params': {'paddings': ((0, 2), (1, 3)),
                                                  'mode': '\"CONSTANT\"'},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Pad',
                   'params': {'pads': [0, 1, 2, 3],
@@ -146,7 +148,7 @@ class TestMappers:
         'expected_output': {'converter_name': 'nn.Pad',
                             'converted_params': {'paddings': ((0, 2), (1, 3)),
                                                  'mode': '\"REFLECT\"'},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Pad',
                   'params': {'pads': [0, 1, 2, 3],
@@ -156,7 +158,7 @@ class TestMappers:
         'expected_output': {'converter_name': 'nn.Pad',
                             'converted_params': {'paddings': ((0, 2), (1, 3)),
                                                  'mode': '{UNSUPPORTED: value is NOT 0}\"CONSTANT\"'},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Pad',
                   'params': {'pads': [0, 1, 2, 3],
@@ -165,7 +167,7 @@ class TestMappers:
         'expected_output': {'converter_name': 'nn.Pad',
                             'converted_params': {'paddings': ((0, 2), (1, 3)),
                                                  'mode': '{UNSUPPORTED: \"edge\"}\"UNKNOWN\"'},
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::ReduceMean',
                   'params': {'keepdims': 0,
@@ -196,14 +198,14 @@ class TestMappers:
                   'weights': dict()},
         'expected_output': {'converter_name': 'nn.ReLU6',
                             'converted_params': dict(),
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Clip',
                   'params': dict(),
                   'weights': dict()},
         'expected_output': {'converter_name': 'nn.ReLU',
                             'converted_params': dict(),
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }, {
         'input': {'op_name': 'onnx::Clip',
                   'params': {'max': 3,
@@ -211,13 +213,13 @@ class TestMappers:
                   'weights': dict()},
         'expected_output': {'converter_name': None,
                             'converted_params': dict(),
-                            'converted_settings': dict()}
+                            'converted_settings': Setting()}
     }])
     def test_mapper(self, params):
         """Test mapper function."""
         mapper = ONNXToMindSporeMapper()
-        converter_name, converted_params, converted_settings = \
+        converter_name, converted_params, converted_settings, _ = \
             mapper.convert(params['input']['op_name'], params['input']['params'], params['input']['weights'])
         assert params['expected_output']['converter_name'] == converter_name
         assert params['expected_output']['converted_params'] == converted_params
-        assert params['expected_output']['converted_settings'] == converted_settings
+        assert isinstance(converted_settings, Setting)