mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/_op_impl/tbe/roi_align_grad_ds.py

@@ -0,0 +1,44 @@
+# 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.
+# ============================================================================
+
+"""ROIAlignGrad op"""
+from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
+
+roi_align_grad_op_info = TBERegOp("ROIAlignGrad") \
+    .fusion_type("OPAQUE") \
+    .async_flag(False) \
+    .binfile_name("roi_align_grad.so") \
+    .compute_cost(10) \
+    .kernel_name("roi_align_grad") \
+    .partial_flag(True) \
+    .dynamic_shape(True) \
+    .attr("xdiff_shape", "required", "listInt", "all") \
+    .attr("pooled_width", "required", "int", "all") \
+    .attr("pooled_height", "required", "int", "all") \
+    .attr("spatial_scale", "required", "float", "all") \
+    .attr("sample_num", "optional", "int", "all") \
+    .attr("roi_end_mode", "optional", "int", "0,1,2", "1") \
+    .input(0, "ydiff", False, "required", "all") \
+    .input(1, "rois", False, "required", "all") \
+    .input(2, "rois_n", False, "optional", "all") \
+    .output(0, "xdiff", False, "required", "all") \
+    .dtype_format(DataType.F32_5HD, DataType.F32_Default, DataType.I32_Default, DataType.F32_5HD) \
+    .get_op_info()
+
+
+@op_info_register(roi_align_grad_op_info)
+def _roi_align_grad_ds_tbe():
+    """ROIAlignGrad TBE register"""
+    return

mindspore/ops/_op_impl/tbe/scatter_add.py

@@ -23,6 +23,8 @@ scatter_add_op_info = TBERegOp("ScatterAdd") \
     .compute_cost(10) \
     .kernel_name("scatter_add") \
     .partial_flag(True) \
+    .dynamic_compile_static(True) \
+    .dynamic_shape(True) \
     .attr("use_locking", "optional", "bool", "all") \
     .input(0, "var", False, "required", "all") \
     .input(1, "indices", False, "required", "all") \

mindspore/ops/_op_impl/tbe/scatter_nd_add.py

@@ -22,6 +22,8 @@ scatter_nd_add_op_info = TBERegOp("ScatterNdAdd") \
     .binfile_name("scatter_nd_add.so") \
     .compute_cost(10) \
     .kernel_name("scatter_nd_add") \
+    .dynamic_shape(True) \
+    .dynamic_compile_static(True) \
     .partial_flag(True) \
     .attr("use_locking", "optional", "bool", "all", "false") \
     .input(0, "var", False, "required", "all") \
@@ -30,8 +32,6 @@ scatter_nd_add_op_info = TBERegOp("ScatterNdAdd") \
     .output(0, "var", False, "required", "all") \
     .dtype_format(DataType.F16_Default, DataType.I32_Default, DataType.F16_Default, DataType.F16_Default) \
     .dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default, DataType.I8_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default, DataType.U8_Default) \
     .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
     .get_op_info()
 

mindspore/ops/_op_impl/tbe/slice.py

@@ -19,25 +19,36 @@ from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 slice_op_info = TBERegOp("Slice") \
     .fusion_type("OPAQUE") \
     .async_flag(False) \
-    .binfile_name("slice_d.so") \
+    .binfile_name("slice.so") \
     .compute_cost(10) \
-    .kernel_name("slice_d") \
+    .kernel_name("slice") \
     .partial_flag(True) \
-    .is_dynamic_format(True) \
-    .attr("begin", "required", "listInt", "all") \
-    .attr("size", "required", "listInt", "all") \
+    .dynamic_compile_static(True) \
+    .dynamic_shape(True) \
     .input(0, "x", False, "required", "all") \
+    .input(1, "begin", False, "required", "all", "optional") \
+    .input(2, "size", False, "required", "all", "optional") \
     .output(0, "y", False, "required", "all") \
-    .dtype_format(DataType.I8_Default, DataType.I8_Default) \
-    .dtype_format(DataType.U8_Default, DataType.U8_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I16_Default) \
-    .dtype_format(DataType.U16_Default, DataType.U16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U32_Default, DataType.U32_Default) \
-    .dtype_format(DataType.U64_Default, DataType.U64_Default) \
-    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I32_Default, DataType.I8_Default) \
+    .dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.I32_Default, DataType.U8_Default) \
+    .dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I32_Default, DataType.I16_Default) \
+    .dtype_format(DataType.U16_Default, DataType.I32_Default, DataType.I32_Default, DataType.U16_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
+    .dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I32_Default, DataType.I64_Default) \
+    .dtype_format(DataType.U32_Default, DataType.I32_Default, DataType.I32_Default, DataType.U32_Default) \
+    .dtype_format(DataType.U64_Default, DataType.I32_Default, DataType.I32_Default, DataType.U64_Default) \
+    .dtype_format(DataType.F16_Default, DataType.I32_Default, DataType.I32_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.I32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.I8_Default, DataType.I64_Default, DataType.I64_Default, DataType.I8_Default) \
+    .dtype_format(DataType.U8_Default, DataType.I64_Default, DataType.I64_Default, DataType.U8_Default) \
+    .dtype_format(DataType.I16_Default, DataType.I64_Default, DataType.I64_Default, DataType.I16_Default) \
+    .dtype_format(DataType.U16_Default, DataType.I64_Default, DataType.I64_Default, DataType.U16_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I64_Default, DataType.I64_Default, DataType.I32_Default) \
+    .dtype_format(DataType.I64_Default, DataType.I64_Default, DataType.I64_Default, DataType.I64_Default) \
+    .dtype_format(DataType.U32_Default, DataType.I64_Default, DataType.I64_Default, DataType.U32_Default) \
+    .dtype_format(DataType.U64_Default, DataType.I64_Default, DataType.I64_Default, DataType.U64_Default) \
+    .dtype_format(DataType.F16_Default, DataType.I64_Default, DataType.I64_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.I64_Default, DataType.I64_Default, DataType.F32_Default) \
     .get_op_info()
 
 

mindspore/ops/_op_impl/tbe/space_to_batch.py

@@ -16,7 +16,7 @@
 """SpaceToBatch op"""
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
-space_to_batch_op_info = TBERegOp("SpaceToBatch") \
+space_to_batch_op_info = TBERegOp("SpaceToBatchD") \
     .fusion_type("OPAQUE") \
     .async_flag(False) \
     .binfile_name("space_to_batch_d.so") \

mindspore/ops/_op_impl/tbe/space_to_batch_nd.py

@@ -16,7 +16,7 @@
 """SpaceToBatchND op"""
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
-space_to_batch_nd_op_info = TBERegOp("SpaceToBatchND") \
+space_to_batch_nd_op_info = TBERegOp("SpaceToBatchNDD") \
     .fusion_type("OPAQUE") \
     .async_flag(False) \
     .binfile_name("space_to_batch_nd_d.so") \

mindspore/ops/_op_impl/tbe/strided_slice_grad_d.py

@@ -24,6 +24,7 @@ strided_slice_grad_d_op_info = TBERegOp("StridedSliceGrad") \
     .kernel_name("strided_slice_grad") \
     .partial_flag(True) \
     .dynamic_compile_static(True) \
+    .need_check_supported(True) \
     .attr("begin_mask", "optional", "int", "all", "0") \
     .attr("end_mask", "optional", "int", "all", "0") \
     .attr("ellipsis_mask", "optional", "int", "all", "0") \

mindspore/ops/_op_impl/tbe/trans_data_ds.py

@@ -59,10 +59,6 @@ trans_data_op_info = TBERegOp("TransData") \
     .dtype_format(DataType.F32_Default, DataType.F32_FracNZ) \
     .dtype_format(DataType.F16_FracNZ, DataType.F16_Default) \
     .dtype_format(DataType.F32_FracNZ, DataType.F32_Default) \
-    .dtype_format(DataType.BOOL_NHWC, DataType.BOOL_5HD) \
-    .dtype_format(DataType.BOOL_Default, DataType.BOOL_5HD) \
-    .dtype_format(DataType.BOOL_5HD, DataType.BOOL_NHWC) \
-    .dtype_format(DataType.BOOL_5HD, DataType.BOOL_Default) \
     .dtype_format(DataType.F16_Default, DataType.F16_NHWC) \
     .dtype_format(DataType.F16_Default, DataType.F16_HWCN) \
     .dtype_format(DataType.F16_NHWC, DataType.F16_Default) \
@@ -83,6 +79,10 @@ trans_data_op_info = TBERegOp("TransData") \
     .dtype_format(DataType.I8_NHWC, DataType.I8_HWCN) \
     .dtype_format(DataType.I8_HWCN, DataType.I8_Default) \
     .dtype_format(DataType.I8_HWCN, DataType.I8_NHWC) \
+    .dtype_format(DataType.I8_Default, DataType.I8_NC1HWC0) \
+    .dtype_format(DataType.I8_HWCN, DataType.I8_C1HWNCoC0) \
+    .dtype_format(DataType.I8_NCDHW, DataType.I8_NDC1HWC0) \
+    .dtype_format(DataType.I8_NDC1HWC0, DataType.I8_NCDHW) \
     .dtype_format(DataType.I16_Default, DataType.I16_NHWC) \
     .dtype_format(DataType.I16_Default, DataType.I16_HWCN) \
     .dtype_format(DataType.I16_NHWC, DataType.I16_Default) \
@@ -95,6 +95,8 @@ trans_data_op_info = TBERegOp("TransData") \
     .dtype_format(DataType.I32_NHWC, DataType.I32_HWCN) \
     .dtype_format(DataType.I32_HWCN, DataType.I32_Default) \
     .dtype_format(DataType.I32_HWCN, DataType.I32_NHWC) \
+    .dtype_format(DataType.I32_NDC1HWC0, DataType.I32_NCDHW) \
+    .dtype_format(DataType.I32_NCDHW, DataType.I32_NDC1HWC0) \
     .dtype_format(DataType.I64_Default, DataType.I64_NHWC) \
     .dtype_format(DataType.I64_Default, DataType.I64_HWCN) \
     .dtype_format(DataType.I64_NHWC, DataType.I64_Default) \
@@ -107,6 +109,9 @@ trans_data_op_info = TBERegOp("TransData") \
     .dtype_format(DataType.U8_NHWC, DataType.U8_HWCN) \
     .dtype_format(DataType.U8_HWCN, DataType.U8_Default) \
     .dtype_format(DataType.U8_HWCN, DataType.U8_NHWC) \
+    .dtype_format(DataType.U8_Default, DataType.U8_NC1HWC0) \
+    .dtype_format(DataType.U8_NCDHW, DataType.U8_NDC1HWC0) \
+    .dtype_format(DataType.U8_NDC1HWC0, DataType.U8_NCDHW) \
     .dtype_format(DataType.U16_Default, DataType.U16_NHWC) \
     .dtype_format(DataType.U16_Default, DataType.U16_HWCN) \
     .dtype_format(DataType.U16_NHWC, DataType.U16_Default) \
@@ -128,7 +133,6 @@ trans_data_op_info = TBERegOp("TransData") \
     .dtype_format(DataType.I32_FracNZ, DataType.I32_Default) \
     .dtype_format(DataType.F16_NDHWC, DataType.F16_5HD) \
     .dtype_format(DataType.F16_5HD, DataType.F16_NDHWC) \
-    .dtype_format(DataType.I8_HWCN, DataType.I8_C1HWNCoC0) \
     .dtype_format(DataType.F16_HWCN, DataType.F16_FracZ) \
     .dtype_format(DataType.F16_FracZ, DataType.F16_HWCN) \
     .dtype_format(DataType.F16_HWCN, DataType.F16_FracNZ) \
@@ -159,6 +163,12 @@ trans_data_op_info = TBERegOp("TransData") \
     .dtype_format(DataType.F32_NCDHW, DataType.F32_NDC1HWC0) \
     .dtype_format(DataType.F32_NDC1HWC0, DataType.F32_NCDHW) \
     .dtype_format(DataType.F32_NCDHW, DataType.F32_NDC1HWC0) \
+    .dtype_format(DataType.I8_Default, DataType.I8_5HD) \
+    .dtype_format(DataType.I8_5HD, DataType.I8_Default) \
+    .dtype_format(DataType.U8_Default, DataType.U8_5HD) \
+    .dtype_format(DataType.U8_5HD, DataType.U8_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_5HD) \
+    .dtype_format(DataType.I32_5HD, DataType.I32_Default) \
     .get_op_info()
 
 

mindspore/ops/_op_impl/tbe/unsorted_segment_sum.py

@@ -16,7 +16,7 @@
 """UnsortedSegmentSum op"""
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
-unsorted_segment_sum_op_info = TBERegOp("UnsortedSegmentSum") \
+unsorted_segment_sum_op_info = TBERegOp("UnsortedSegmentSumD") \
     .fusion_type("OPAQUE") \
     .async_flag(False) \
     .binfile_name("unsorted_segment_sum_d.so") \

mindspore/ops/_op_impl/tbe/unsorted_segment_sum_ds.py

@@ -24,6 +24,8 @@ unsorted_segment_sum_ds_op_info = TBERegOp("UnsortedSegmentSum") \
     .kernel_name("unsorted_segment_sum") \
     .partial_flag(True) \
     .dynamic_shape(True) \
+    .dynamic_compile_static(True) \
+    .need_check_supported(True) \
     .input(0, "x", False, "required", "all", reshape_type="NC") \
     .input(1, "segment_ids", False, "required", "all", "optional") \
     .input(2, "num_segments", False, "required", "all", "optional") \

mindspore/ops/_primitive_cache.py

@@ -14,9 +14,10 @@
 # ============================================================================
 
 """Cache for Primitive."""
+from __future__ import absolute_import
 
-from .primitive import constexpr
-from . import Primitive
+from mindspore.ops.primitive import constexpr
+from mindspore.ops import Primitive
 
 _PRIM_CACHE = {}
 

mindspore/ops/_register_for_op.py

@@ -60,3 +60,14 @@ class PyFuncRegistry(UserDict):
         if key not in self:
             raise ValueError(f"Python function with key{key} not registered.")
         return self[key]
+
+
+class OpaquePredicateRegistry(PyFuncRegistry):
+    """Registry opaque predicate functions used for dynamic obfuscation"""
+    def __init__(self):
+        super(OpaquePredicateRegistry, self).__init__()
+        self.func_names = []
+
+    def register(self, key, value):
+        self[key] = value
+        self.func_names.append(key)

mindspore/ops/_utils/__init__.py

@@ -15,6 +15,6 @@
 
 """ops utils."""
 from __future__ import absolute_import
-from .utils import get_broadcast_shape, get_concat_offset, is_shape_unknown
+from mindspore.ops._utils.utils import get_broadcast_shape, get_concat_offset
 
 __all__ = ['get_broadcast_shape', 'get_concat_offset']

mindspore/ops/_utils/utils.py

@@ -17,13 +17,13 @@
 from __future__ import absolute_import
 
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import _primexpr
+from mindspore.common._utils import is_dim_unknown
 
 
-def get_broadcast_shape(x_shape, y_shape, prim_name, shape_type="", arg_name1="x", arg_name2="y"):
+def get_broadcast_shape(x_shape, y_shape, prim_name, arg_name1="x", arg_name2="y"):
     """
     Doing broadcast between tensor x and tensor y.
 
@@ -31,7 +31,6 @@ def get_broadcast_shape(x_shape, y_shape, prim_name, shape_type="", arg_name1="x
         x_shape (list): The shape of tensor x.
         y_shape (list): The shape of tensor y.
         prim_name (str): Primitive name.
-        shape_type (str): The type of shape, optional values are "", "min_shape" and "max_shape".
         arg_name1 (str): The arg name of x_shape.
         arg_name2 (str): The arg name of y_shape.
 
@@ -68,16 +67,11 @@ def get_broadcast_shape(x_shape, y_shape, prim_name, shape_type="", arg_name1="x
         elif x_shape[i] == -1 or y_shape[i] == -1:
             broadcast_shape_back.append(-1)
         else:
-            if shape_type == "min_shape":
-                broadcast_shape_back.append(max(x_shape[i], y_shape[i]))
-            elif shape_type == "max_shape":
-                broadcast_shape_back.append(min(x_shape[i], y_shape[i]))
-            else:
-                raise ValueError(f"For '{prim_name}', {arg_name1}.shape and {arg_name2}.shape need to "
-                                 f"broadcast. The value of {arg_name1}.shape[{i}] or {arg_name2}.shape[{i}]"
-                                 f" must be 1 or -1 when they are not the same, "
-                                 f"but got {arg_name1}.shape = {x_shape} "
-                                 f"and {arg_name2}.shape = {y_shape}.")
+            raise ValueError(f"For '{prim_name}', {arg_name1}.shape and {arg_name2}.shape need to "
+                             f"broadcast. The value of {arg_name1}.shape[{i}] or {arg_name2}.shape[{i}]"
+                             f" must be 1 or -1 when they are not the same, "
+                             f"but got {arg_name1}.shape = {x_shape} "
+                             f"and {arg_name2}.shape = {y_shape}.")
 
     broadcast_shape_front = y_shape[0: y_len - length] if length == x_len else x_shape[0: x_len - length]
     broadcast_shape = list(broadcast_shape_front) + broadcast_shape_back
@@ -92,10 +86,11 @@ def get_concat_offset(x_shp, x_type, axis, prim_name):
     validator.check_positive_int(len(x_shp[0]), "len of x_shp[0]", prim_name)
     rank_base = len(x_shp[0])
     for i in range(1, len(x_shp)):
-        validator.check('len of x_shp[%d]' % i, len(x_shp[i]), 'len of x_shp[0]', len(x_shp[0]), Rel.EQ, prim_name)
-        validator.check('x_type[%d]' % i, x_type[i], 'x_type[0]', x_type[0], Rel.EQ, prim_name)
+        validator.check('len of x_shp[%d]' % i, len(x_shp[i]), 'len of x_shp[0]',
+                        len(x_shp[0]), validator.EQ, prim_name)
+        validator.check('x_type[%d]' % i, x_type[i], 'x_type[0]', x_type[0], validator.EQ, prim_name)
 
-    validator.check_int_range(axis, -rank_base, rank_base - 1, Rel.INC_BOTH, 'axis', prim_name)
+    validator.check_int_range(axis, -rank_base, rank_base - 1, validator.INC_BOTH, 'axis', prim_name)
     if axis < 0:
         axis = axis + rank_base
     all_shp = x_shp[0][axis]
@@ -103,7 +98,7 @@ def get_concat_offset(x_shp, x_type, axis, prim_name):
     for i in range(1, len(x_shp)):
         v = x_shp[i]
         for j in range(rank_base):
-            if j != axis and v[j] != x_shp[0][j]:
+            if j != axis and v[j] != x_shp[0][j] and v[j] >= 0 and x_shp[0][j] >= 0:
                 raise ValueError(f"The shape of the two input elements of the Concat operator do not match:"
                                  f"shape[0] = {x_shp[0]} and shape[{i}] = {x_shp[i]}.")
         offset.append(all_shp)
@@ -114,14 +109,14 @@ def get_concat_offset(x_shp, x_type, axis, prim_name):
     return offset, all_shp, axis
 
 
-@constexpr
+@_primexpr
 def range_op(start, limit, delta, dtype):
     """helper function to get tensor in specified range."""
     output_tensor = Tensor(list(range(start, limit, delta)), dtype)
     return output_tensor
 
 
-@constexpr
+@_primexpr
 def get_1d_shape(in_shape):
     """helper function to get 1d shape."""
     out_shape = 1
@@ -130,29 +125,13 @@ def get_1d_shape(in_shape):
     return (out_shape,)
 
 
-@constexpr
-def generate_shape_index(out_shape, indices_shape, axis):
+@_primexpr
+def generate_shape_index(out_shape, indices_shape, axis, batch_dims=0):
     out_rank = len(out_shape)
     ind_rank = len(indices_shape)
     if axis < 0:
         axis += out_rank - ind_rank + 1
-    perm_part1 = tuple(range(axis, axis + ind_rank))
+    perm_part1 = tuple(range(axis, axis + ind_rank - batch_dims))
     index = tuple(range(out_rank))
-    perm = perm_part1 + index[:axis] + index[axis + ind_rank:]
+    perm = index[:batch_dims] + perm_part1 + index[batch_dims:axis] + index[axis + ind_rank - batch_dims:]
     return perm
-
-
-@constexpr
-def is_shape_unknown(shape):
-    for i in shape:
-        if i < 0:
-            return True
-    return False
-
-
-@constexpr
-def is_dim_unknown(shape):
-    for i in shape:
-        if i == -2:
-            return True
-    return False

mindspore/ops/_vmap/__init__.py

@@ -19,7 +19,7 @@ from __future__ import absolute_import
 from . import vmap_base, vmap_array_ops, vmap_grad_nn_ops, vmap_debug_ops, vmap_math_ops, vmap_nn_ops,\
     vmap_image_ops, vmap_other_ops, vmap_sparse_ops, vmap_random_ops, vmap_convolution_ops, vmap_grad_math_ops
 from .vmap_base import get_vmap_rule, vmap_monad_rule, _broadcast_by_axis, vmap_bind_all_none,\
-    vmap_unstack, vmap_general_output_process
+    vmap_unstack, vmap_stack, vmap_general_output_process
 
 __all__ = ['get_vmap_rule', 'vmap_monad_rule', '_broadcast_by_axis', 'vmap_bind_all_none',
-           'vmap_unstack', 'vmap_general_output_process']
+           'vmap_unstack', 'vmap_stack', 'vmap_general_output_process']