mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/ops/op_info_register.py

@@ -14,16 +14,16 @@
 # ============================================================================
 
 """Operators info register."""
-
 from __future__ import absolute_import
+from __future__ import division
+
 import inspect
 import json
 import os
 import functools
 
 from mindspore._c_expression import Oplib
-
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 
 # path of built-in op info register.
 BUILT_IN_OPS_REGISTER_PATH = "mindspore/ops/_op_impl"
@@ -42,7 +42,7 @@ def op_info_register(op_info):
         op_info (Union[str, dict]): operator information in json format.
 
     Examples:
-        >>> from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
+        >>> from mindspore.ops import op_info_register, TBERegOp, DataType
         >>> abs_op_info = TBERegOp("Abs") \
         ...    .fusion_type("ELEMWISE") \
         ...    .async_flag(False) \
@@ -105,6 +105,9 @@ def custom_info_register(*reg_info):
     Returns:
         Function, returns a decorator for op info register.
 
+    Raises:
+        TypeError: If `reg_info` is not a tuple.
+
     Examples:
         >>> from mindspore.ops import custom_info_register, CustomRegOp, DataType
         >>> custom_func_ascend_info = CustomRegOp() \
@@ -269,10 +272,12 @@ class RegOp:
             raise ValueError("input size add output size must be equal to dtype format size")
         dtype_format = []
         for arg in args:
-            if not isinstance(arg, tuple) or len(arg) != 2:
-                raise ValueError("dtype and format value must be tuple of two elements")
+            if not isinstance(arg, tuple) or (len(arg) != 2 and len(arg) != 3):
+                raise ValueError("dtype and format value must be tuple of two or three elements")
             self._is_string(arg[0])
             self._is_string(arg[1])
+            if len(arg) == 3:
+                self._is_string(arg[2])
             dtype_format.append(arg)
         self.dtype_format_.append(tuple(dtype_format))
         return self
@@ -288,9 +293,15 @@ class RegOp:
         op_info = {}
         for key, value in self.__dict__.items():
             if isinstance(key, str) and key.endswith('_'):
-                op_info[key.rstrip('_')] = value
-            else:
-                op_info[key] = value
+                key = key.rstrip('_')
+                key_dic = {"dynamic_shape_support": "dynamicShapeSupport",
+                           "dynamic_rank_support": "dynamicRankSupport",
+                           "dynamic_compile_static": "dynamicCompileStatic",
+                           "need_check_support": "needCheckSupport",
+                           "dynamic_format": "dynamicFormat"
+                           }
+                key = key_dic.get(key, key)
+            op_info[key] = value
         return op_info
 
 
@@ -312,7 +323,7 @@ class CpuRegOp(RegOp):
             kwargs (dict): Other information of the input.
         """
         param_list = [index, name, param_type]
-        key_list = ["index", "name", "param_type"]
+        key_list = ["index", "name", "paramType"]
         fn_list = [self._is_int, self._is_string, self._is_string]
         input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.inputs.append(input_dict)
@@ -329,7 +340,7 @@ class CpuRegOp(RegOp):
             kwargs (dict): Other information of the output.
         """
         param_list = [index, name, param_type]
-        key_list = ["index", "name", "param_type"]
+        key_list = ["index", "name", "paramType"]
         fn_list = [self._is_int, self._is_string, self._is_string]
         output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.outputs.append(output_dict)
@@ -372,7 +383,7 @@ class AkgRegOp(RegOp):
             kwargs (dict): Other information of the input.
         """
         param_list = [index, name, param_type]
-        key_list = ["index", "name", "param_type"]
+        key_list = ["index", "name", "paramType"]
         fn_list = [self._is_int, self._is_string, self._is_string]
         input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.inputs.append(input_dict)
@@ -405,7 +416,7 @@ class AkgRegOp(RegOp):
             kwargs (dict): Other information of the attribute.
         """
         param_list = [name, param_type, value_type]
-        key_list = ["name", "param_type", "type"]
+        key_list = ["name", "paramType", "type"]
         fn_list = [self._is_string]
         attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.attr_.append(attr_dict)
@@ -498,16 +509,16 @@ class TBERegOp(RegOp):
         super(TBERegOp, self).__init__(op_name)
         self.imply_type = "TBE"
         self.async_flag_ = False
-        self.binfile_name_ = ''
+        self.binfile_ = ''
         self.compute_cost_ = 10
-        self.kernel_name_ = ''
+        self.kernel_ = ''
         self.partial_flag_ = False
         self.reshape_type_ = ''
         self.dynamic_rank_support_ = False
-        self.dynamic_shape_ = False
+        self.dynamic_shape_support_ = False
         self.dynamic_compile_static_ = False
-        self.need_check_supported_ = False
-        self.is_dynamic_format_ = False
+        self.need_check_support_ = False
+        self.dynamic_format_ = False
         self.op_pattern_ = ""
         self.real_input_index_ = []
         self.input_to_attr_index_ = []
@@ -520,7 +531,6 @@ class TBERegOp(RegOp):
         Args:
             unknown_shape_formats (list): Description data arrangement of operator input / output tensor in dynamic
                                           shape scene.
-                                          Default: (), means dynamic shape is not supported.
         """
         RegOp._is_list(unknown_shape_formats)
         self.unknown_shape_formats_.append(unknown_shape_formats)
@@ -582,7 +592,7 @@ class TBERegOp(RegOp):
             binfile_name (str): The binary file name of the operator.
         """
         self._is_string(binfile_name)
-        self.binfile_name_ = binfile_name
+        self.binfile_ = binfile_name
         return self
 
     def compute_cost(self, compute_cost=10):
@@ -605,7 +615,7 @@ class TBERegOp(RegOp):
             kernel_name (str): Name of operator kernel.
         """
         self._is_string(kernel_name)
-        self.kernel_name_ = kernel_name
+        self.kernel_ = kernel_name
         return self
 
     def partial_flag(self, partial_flag=True):
@@ -624,8 +634,9 @@ class TBERegOp(RegOp):
         Reshape type of operator.
 
         Args:
-            reshape_type (str): Value of reshape type. For example, if the input shape is (2,3) and `reshape_type`
-                is set to "CH", then the new shape is (1,2,3,1). "CH" means the C and H dimensions are kept and
+            reshape_type (str): Value of reshape type. For example, if the input shape is :math:`(2, 3)`
+                and `reshape_type` is set to "CH", then the new shape is :math:`(1, 2, 3, 1)`.
+                "CH" means the C and H dimensions are kept and
                 new dimensions are added for N and W dimension.
         """
         self._is_string(reshape_type)
@@ -640,7 +651,7 @@ class TBERegOp(RegOp):
             dynamic_shape (bool): Value of dynamic shape. Default: false.
         """
         self._is_bool(dynamic_shape)
-        self.dynamic_shape_ = dynamic_shape
+        self.dynamic_shape_support_ = dynamic_shape
         return self
 
     def dynamic_compile_static(self, dynamic_compile_static=False):
@@ -662,7 +673,7 @@ class TBERegOp(RegOp):
             need_check_supported (bool): Value of need_check_supported. Default: false.
         """
         self._is_bool(need_check_supported)
-        self.need_check_supported_ = need_check_supported
+        self.need_check_support_ = need_check_supported
         return self
 
     def is_dynamic_format(self, is_dynamic_format=False):
@@ -673,7 +684,7 @@ class TBERegOp(RegOp):
             is_dynamic_format (bool): Value of is_dynamic_format. Default: false.
         """
         self._is_bool(is_dynamic_format)
-        self.is_dynamic_format_ = is_dynamic_format
+        self.dynamic_format_ = is_dynamic_format
         return self
 
     def op_pattern(self, pattern=None):
@@ -700,7 +711,7 @@ class TBERegOp(RegOp):
             kwargs (dict): Other information of the attribute.
         """
         param_list = [name, param_type, value_type, value, default_value]
-        key_list = ["name", "param_type", "type", "value", "default_value"]
+        key_list = ["name", "paramType", "type", "value", "defaultValue"]
         fn_list = [self._is_string]
         attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.attr_.append(attr_dict)
@@ -720,7 +731,7 @@ class TBERegOp(RegOp):
             kwargs (dict): Other information of the input.
         """
         param_list = [index, name, need_compile, param_type, shape, value_depend]
-        key_list = ["index", "name", "need_compile", "param_type", "shape", "value_depend"]
+        key_list = ["index", "name", "needCompile", "paramType", "shape", "valueDepend"]
         fn_list = [self._is_int, self._is_string, self._is_bool, self._is_string, self._is_string, self._is_string]
         input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         value_depend_values = ("ignored", "optional", "required")
@@ -743,7 +754,7 @@ class TBERegOp(RegOp):
             kwargs (dict): Other information of the output.
         """
         param_list = [index, name, need_compile, param_type, shape]
-        key_list = ["index", "name", "need_compile", "param_type", "shape"]
+        key_list = ["index", "name", "need_compile", "paramType", "shape"]
         fn_list = [self._is_int, self._is_string, self._is_bool, self._is_string, self._is_string]
         output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.outputs.append(output_dict)
@@ -757,8 +768,9 @@ class CustomRegOp(RegOp):
     attributes and target of `func`.
 
     Args:
-        op_name (str): kernel name. No need to set this value because `Custom` operator will generate a unique name
-            automatically. Default: "Custom".
+        op_name (str): kernel name. The name will be record in the reg_op_name attr of the kernel node.
+            Besides, the operator will generate a unique name automatically to identify the reg info.
+            Default: "Custom".
 
     Examples:
         >>> from mindspore.ops import CustomRegOp, DataType
@@ -804,7 +816,7 @@ class CustomRegOp(RegOp):
             TypeError: If `param_type` is neither str nor None.
         """
         param_list = [index, name, param_type]
-        key_list = ["index", "name", "param_type"]
+        key_list = ["index", "name", "paramType"]
         fn_list = [self._is_int, self._is_string, self._is_string]
         input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.inputs.append(input_dict)
@@ -839,7 +851,7 @@ class CustomRegOp(RegOp):
             TypeError: If `param_type` is neither str nor None.
         """
         param_list = [index, name, param_type]
-        key_list = ["index", "name", "param_type"]
+        key_list = ["index", "name", "paramType"]
         fn_list = [self._is_int, self._is_string, self._is_string]
         output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.outputs.append(output_dict)
@@ -914,7 +926,7 @@ class CustomRegOp(RegOp):
             TypeError: If `default_value` is neither str nor None.
         """
         param_list = [name, param_type, value_type, default_value]
-        key_list = ["name", "param_type", "type", "default_value"]
+        key_list = ["name", "paramType", "type", "defaultValue"]
         fn_list = [self._is_string]
         attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
         self.attr_.append(attr_dict)
@@ -1127,6 +1139,7 @@ class DataType:
 
     None_None = ("", "")
     None_Default = ("", "DefaultFormat")
+
     BOOL_None = ("bool", "")
     BOOL_Default = ("bool", "DefaultFormat")
     BOOL_5HD = ("bool", "NC1HWC0")
@@ -1138,6 +1151,8 @@ class DataType:
     BOOL_HWCN = ("bool", "HWCN")
     BOOL_NDHWC = ("bool", "NDHWC")
     BOOL_ChannelLast = ("bool", "ChannelLast")
+    BOOL_Default_Tuple = ("bool", "DefaultFormat", "tuple")
+    BOOL_Default_List = ("bool", "DefaultFormat", "list")
 
     I8_None = ("int8", "")
     I8_Default = ("int8", "DefaultFormat")
@@ -1149,8 +1164,12 @@ class DataType:
     I8_NHWC = ("int8", "NHWC")
     I8_HWCN = ("int8", "HWCN")
     I8_NDHWC = ("int8", "NDHWC")
+    I8_NCDHW = ("int8", "NCDHW")
     I8_ChannelLast = ("int8", "ChannelLast")
     I8_NDC1HWC0 = ("int8", "NDC1HWC0")
+    I8_NC1HWC0 = ("int8", "NC1HWC0")
+    I8_Default_Tuple = ("int8", "DefaultFormat", "tuple")
+    I8_Default_List = ("int8", "DefaultFormat", "list")
 
     U8_None = ("uint8", "")
     U8_Default = ("uint8", "DefaultFormat")
@@ -1162,8 +1181,12 @@ class DataType:
     U8_NHWC = ("uint8", "NHWC")
     U8_HWCN = ("uint8", "HWCN")
     U8_NDHWC = ("uint8", "NDHWC")
+    U8_NCDHW = ("uint8", "NCDHW")
     U8_ChannelLast = ("uint8", "ChannelLast")
     U8_NDC1HWC0 = ("uint8", "NDC1HWC0")
+    U8_NC1HWC0 = ("uint8", "NC1HWC0")
+    U8_Default_Tuple = ("uint8", "DefaultFormat", "tuple")
+    U8_Default_List = ("uint8", "DefaultFormat", "list")
 
     I16_None = ("int16", "")
     I16_Default = ("int16", "DefaultFormat")
@@ -1176,6 +1199,8 @@ class DataType:
     I16_HWCN = ("int16", "HWCN")
     I16_NDHWC = ("int16", "NDHWC")
     I16_ChannelLast = ("int16", "ChannelLast")
+    I16_Default_Tuple = ("int16", "DefaultFormat", "tuple")
+    I16_Default_List = ("int16", "DefaultFormat", "list")
 
     U16_None = ("uint16", "")
     U16_Default = ("uint16", "DefaultFormat")
@@ -1188,6 +1213,8 @@ class DataType:
     U16_HWCN = ("uint16", "HWCN")
     U16_NDHWC = ("uint16", "NDHWC")
     U16_ChannelLast = ("uint16", "ChannelLast")
+    U16_Default_Tuple = ("uint16", "DefaultFormat", "tuple")
+    U16_Default_List = ("uint16", "DefaultFormat", "list")
 
     I32_None = ("int32", "")
     I32_Default = ("int32", "DefaultFormat")
@@ -1199,7 +1226,11 @@ class DataType:
     I32_NHWC = ("int32", "NHWC")
     I32_HWCN = ("int32", "HWCN")
     I32_NDHWC = ("int32", "NDHWC")
+    I32_NDC1HWC0 = ("int32", "NDC1HWC0")
+    I32_NCDHW = ("int32", "NCDHW")
     I32_ChannelLast = ("int32", "ChannelLast")
+    I32_Default_Tuple = ("int32", "DefaultFormat", "tuple")
+    I32_Default_List = ("int32", "DefaultFormat", "list")
 
     U32_None = ("uint32", "")
     U32_Default = ("uint32", "DefaultFormat")
@@ -1212,6 +1243,8 @@ class DataType:
     U32_HWCN = ("uint32", "HWCN")
     U32_NDHWC = ("uint32", "NDHWC")
     U32_ChannelLast = ("uint32", "ChannelLast")
+    U32_Default_Tuple = ("uint32", "DefaultFormat", "tuple")
+    U32_Default_List = ("uint32", "DefaultFormat", "list")
 
     I64_None = ("int64", "")
     I64_Default = ("int64", "DefaultFormat")
@@ -1224,6 +1257,8 @@ class DataType:
     I64_HWCN = ("int64", "HWCN")
     I64_NDHWC = ("int64", "NDHWC")
     I64_ChannelLast = ("int64", "ChannelLast")
+    I64_Default_Tuple = ("int64", "DefaultFormat", "tuple")
+    I64_Default_List = ("int64", "DefaultFormat", "list")
 
     U64_None = ("uint64", "")
     U64_Default = ("uint64", "DefaultFormat")
@@ -1236,6 +1271,8 @@ class DataType:
     U64_HWCN = ("uint64", "HWCN")
     U64_NDHWC = ("uint64", "NDHWC")
     U64_ChannelLast = ("uint64", "ChannelLast")
+    U64_Default_Tuple = ("uint64", "DefaultFormat", "tuple")
+    U64_Default_List = ("uint64", "DefaultFormat", "list")
 
     F16_None = ("float16", "")
     F16_Default = ("float16", "DefaultFormat")
@@ -1255,6 +1292,8 @@ class DataType:
     F16_FracZNRNN = ("float16", "FRACTAL_ZN_RNN")
     F16_ND_RNNBIAS = ("float16", "ND_RNN_BIAS")
     F16_ChannelLast = ("float16", "ChannelLast")
+    F16_Default_Tuple = ("float16", "DefaultFormat", "tuple")
+    F16_Default_List = ("float16", "DefaultFormat", "list")
 
     F32_None = ("float32", "")
     F32_Default = ("float32", "DefaultFormat")
@@ -1274,6 +1313,8 @@ class DataType:
     F32_FracZNRNN = ("float32", "FRACTAL_ZN_RNN")
     F32_ND_RNNBIAS = ("float32", "ND_RNN_BIAS")
     F32_ChannelLast = ("float32", "ChannelLast")
+    F32_Default_Tuple = ("float32", "DefaultFormat", "tuple")
+    F32_Default_List = ("float32", "DefaultFormat", "list")
 
     F64_None = ("float64", "")
     F64_Default = ("float64", "DefaultFormat")
@@ -1286,6 +1327,10 @@ class DataType:
     F64_HWCN = ("float64", "HWCN")
     F64_NDHWC = ("float64", "NDHWC")
     F64_ChannelLast = ("float64", "ChannelLast")
+    F64_Default_Tuple = ("float64", "DefaultFormat", "tuple")
+    F64_Default_List = ("float64", "DefaultFormat", "list")
 
     C64_Default = ("complex64", "DefaultFormat")
     C128_Default = ("complex128", "DefaultFormat")
+    C64_Default_Tuple = ("complex64", "DefaultFormat", "tuple")
+    C128_Default_Tuple = ("complex128", "DefaultFormat", "tuple")