mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/{_grad → _grad_experimental}/grad_base.py

@@ -24,7 +24,7 @@ from mindspore.ops.operations._inner_ops import DynamicBroadcastTo
 from mindspore.ops import functional as F
 from mindspore.ops.operations import _sequence_ops as seq_op
 import mindspore as ms
-dyn_shape = P.TensorShape()
+shape_op = P.Shape()
 cast = P.Cast()
 
 
@@ -116,27 +116,6 @@ def convert_to_tensor(data):
     return False, data
 
 
-def dyn_rank(tensor):
-    """get the rank of tensor"""
-    out_rank = dyn_shape(dyn_shape(tensor))
-    return P.Reshape()(out_rank, ())
-
-
-def dyn_rank_1d(tensor):
-    """get the rank of tensor and return a 1D tensor"""
-    tensor_shape = dyn_shape(tensor)
-    return dyn_shape(tensor_shape)
-
-
-def dyn_size(tensor, dtype=mstype.int64):
-    """get the size of tensor"""
-    shape = dyn_shape(tensor)
-    shape = cast(shape, mstype.float32)
-    size = P.ReduceProd()(shape)
-    size = cast(size, dtype)
-    return size
-
-
 def create_tensor_by_element(ori_tuple, data_type=mstype.int64):
     """create tensor by element"""
     if isinstance(ori_tuple, (tuple, list)):
@@ -148,17 +127,6 @@ def create_tensor_by_element(ori_tuple, data_type=mstype.int64):
     return ori_tuple
 
 
-def dyn_invert_permutation(perm):
-    """get the invert premutation of tensor"""
-    indices = P.ExpandDims()(perm, -1)
-    end = dyn_size(perm)
-    updates = P.Range()(P.Cast()(0, end.dtype), end, P.Cast()(1, end.dtype))
-    output = P.ZerosLike()(updates)
-    new_perm = P.TensorScatterUpdate()(P.Cast()(output, mstype.float32),
-                                       indices, P.Cast()(updates, mstype.float32))
-    return P.Cast()(new_perm, mstype.int32)
-
-
 def dyn_fill(value_type, shape, value):
     """create a Tensor of the specified shape of tensor and fill it with the specified value."""
     value_tensor = P.Cast()(value, value_type)

mindspore/ops/{_grad → _grad_experimental}/grad_comm_ops.py

@@ -31,7 +31,7 @@ from mindspore.ops.operations.comm_ops import (AllGather, _MiniStepAllGather, _H
                                                ReduceScatter, _HostReduceScatter, _VirtualDiv, _VirtualAdd, _AllSwap,
                                                _VirtualAssignAdd, _VirtualAccuGrad, _MirrorMicroStepOperator,
                                                _MicroStepAllGather)
-from mindspore.ops._grad.grad_base import bprop_getters
+from mindspore.ops._grad_experimental.grad_base import bprop_getters
 from mindspore.ops.operations import _grad_ops as G
 
 
@@ -61,7 +61,7 @@ def get_bprop_all_reduce(self):
     elif self.op == ReduceOp.SUM:
 
         def bprop(x, out, dout):
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 dx = all_reduce_grad(dout)
             else:
                 indices = all_gather(dout.indices)
@@ -71,7 +71,7 @@ def get_bprop_all_reduce(self):
     else:
 
         def bprop(x, out, dout):
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 dx = all_reduce_grad(dout)
                 z = equal(x, out)
                 z = cast(z, dtype(dx))
@@ -98,6 +98,7 @@ def get_bprop_send(self):
     def bprop(x, out, dout):
         dx = send_grad(virtual_input)
         return (dx,)
+
     return bprop
 
 
@@ -117,14 +118,17 @@ def get_bprop_receive(self):
         else:
             dx = depend(cast(out_tensor, F.dtype(x)), send_out)
         return (dx,)
+
     return bprop
 
 
 @bprop_getters.register(_VirtualAdd)
 def get_bprop_virtual_add(self):
     """Generate bprop for _VirtualAdd"""
+
     def bprop(x, grad_accu, out, dout):
         return (dout + grad_accu, zeros_like(grad_accu))
+
     return bprop
 
 
@@ -181,7 +185,8 @@ def get_bprop_mirror_micro_step_operator(self):
     scale = 1 / dev_num
 
     all_reduce = AllReduce(group=group)
-
+    if "segment" in self.get_attr_dict():
+        all_reduce.add_prim_attr("segment", self.get_attr_dict()["segment"])
     fusion = self.get_attr_dict()["fusion"]
     all_reduce.add_prim_attr("fusion", fusion)
     if hasattr(self, 'parameter'):
@@ -203,7 +208,7 @@ def get_bprop_mirror_micro_step_operator(self):
         real_grad = z
         assign_out = dout
         if mean_flag:
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 z = F.depend(z, dout)
                 real_grad = all_reduce(z)
                 real_grad = F.tensor_mul(real_grad, scale)
@@ -211,13 +216,14 @@ def get_bprop_mirror_micro_step_operator(self):
                     return (real_grad, cast(out_tensor, dtype(z)))
                 return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(z))), assign(z, real_grad))
         else:
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 z = F.depend(z, dout)
                 real_grad = all_reduce(z)
                 if opt_shard:
                     return (real_grad, cast(out_tensor, dtype(z)))
                 return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(z))), assign(z, real_grad))
         return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(z))), assign_out)
+
     return bprop
 
 
@@ -227,6 +233,7 @@ def get_bprop_broad_cast(self):
 
     def bprop(x, out, dout):
         return (dout,)
+
     return bprop
 
 
@@ -306,6 +313,8 @@ def get_bprop_micro_step_all_gather(self):
     if do_mirror:
         scale = 1.0 / self.rank_size
         all_reduce = AllReduce(ReduceOp.SUM, self.group).add_prim_attr("fusion", fusion)
+        if "segment" in self.get_attr_dict():
+            all_reduce.add_prim_attr("segment", self.get_attr_dict()["segment"])
         rank = get_rank(self.group)
         dev_num = get_group_size(self.group)
         split = P.Split(output_num=dev_num)
@@ -317,7 +326,6 @@ def get_bprop_micro_step_all_gather(self):
     out_tensor = Tensor(1.0, mstype.float16)
     with_mirror_operator = self.get_attr_dict()["with_mirror_operator"]
 
-    # z: accu_grad
     def bprop(x, z, out, dout):
         if with_mirror_operator:
             if not do_mirror:
@@ -486,7 +494,7 @@ def get_bprop_mirror_operator(self):
         if dev_num == 1:
             return (dout,)
         if mean_flag:
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 dx = all_reduce(dout)
                 dx = mul(dx, cast(F.scalar_to_tensor(dev_num_r), F.dtype(dx)))
             else:
@@ -495,7 +503,7 @@ def get_bprop_mirror_operator(self):
                 grad = mul(grad, cast(F.scalar_to_tensor(dev_num_r), F.dtype(grad)))
                 dx = RowTensorInner(indices, grad, dout.dense_shape)
         else:
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 dx = all_reduce(dout)
             else:
                 indices = all_gather(dout.indices)
@@ -503,6 +511,7 @@ def get_bprop_mirror_operator(self):
                 dx = RowTensorInner(indices, grad, dout.dense_shape)
 
         return (dx,)
+
     return bprop
 
 
@@ -534,7 +543,7 @@ def get_bprop_mirror_mini_step_operator(self):
 
     def bprop(x, z, out, dout):
         if mean_flag:
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 if do_mirror:
                     z = F.depend(z, F.assign_add(z, dout))
                     real_grad = all_reduce(z)
@@ -545,7 +554,7 @@ def get_bprop_mirror_mini_step_operator(self):
             else:
                 dx = zeros_like(x)  # The grad accumulation do not support row tensor now
         else:
-            if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor_type):
                 if do_mirror:
                     z = F.depend(z, F.assign_add(z, dout))
                     real_grad = all_reduce(z)
@@ -556,6 +565,7 @@ def get_bprop_mirror_mini_step_operator(self):
                 dx = zeros_like(x)  # The grad accumulation do not support row tensor now
 
         return (dx, zeros_like(z))
+
     return bprop
 
 
@@ -568,9 +578,9 @@ def get_bprop_virtual_div_operator(self):
     dtype = P.DType()
 
     def bprop(x, out, dout):
-        if issubclass_(F.typeof(dout), mstype.tensor):
+        if issubclass_(F.typeof(dout), mstype.tensor_type):
             if issubclass_(F.dtype(dout), mstype.bool_) or issubclass_(F.dtype(dout), mstype.int32) \
-                                     or issubclass_(F.dtype(dout), mstype.int16):
+                    or issubclass_(F.dtype(dout), mstype.int16):
                 return (dout,)
             dx = op(dout, cast(F.scalar_to_tensor(divisor), dtype(dout)))
             return (dx,)
@@ -589,6 +599,7 @@ def get_bprop_virtual_div_operator(self):
             ele_grad = op(dout[i], cast(F.scalar_to_tensor(divisor), dtype(dout[i])))
             dx.append(ele_grad)
         return (dx,)
+
     return bprop
 
 
@@ -598,4 +609,5 @@ def get_bprop_get_tensor_slice_operator(self):
 
     def bprop(x, dev_mat, tensor_map, out, dout):
         return (zeros_like(x),)
+
     return bprop

mindspore/ops/{_grad/__init__.py → _grad_experimental/grad_debug_ops.py}

@@ -13,11 +13,19 @@
 # limitations under the License.
 # ============================================================================
 
-"""grad impl."""
-from __future__ import absolute_import
-from mindspore.ops._grad.grad_base import get_bprop_fn, get_taylor_fprop_fn
-from . import grad_array_ops, grad_comm_ops, grad_debug_ops, grad_implementations, grad_clip_ops, \
-              grad_math_ops, grad_nn_ops, grad_other_ops, grad_quant_ops, grad_sparse,            \
-              grad_inner_ops, taylor_rule, grad_sequence_ops
+"""Generate bprop for debug ops"""
 
-__all__ = ['get_bprop_fn', 'get_taylor_fprop_fn']
+from mindspore.ops import operations as P
+from mindspore.ops._grad_experimental.grad_base import bprop_getters
+
+# Unused parameters are placeholders.
+
+
+@bprop_getters.register(P.InsertGradientOf)
+def get_bprop_insert_gradient_of(self):
+    """Generate bprop for InsertGradientOf"""
+    f = self.f
+
+    def bprop(x, out, dout):
+        return (f(dout),)
+    return bprop

mindspore/ops/{_grad → _grad_experimental}/grad_implementations.py

@@ -19,23 +19,13 @@ from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore.ops.composite import multitype_ops as C
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops._grad.grad_base import bprops
+from mindspore.ops._grad_experimental.grad_base import bprops
 from mindspore.common import dtype as mstype
 
 get_dtype = P.DType()
 # Unused parameters are placeholders.
 
 
-@bprops.register("MaximumGrad")
-@bprops.register("MinimumGrad")
-def bprop_max_and_minimum_grad_grad(x, y, z, out, dout):
-    """Backpropagator for primitive `MaximumGrad` and `MinimumGrad`."""
-    out0 = F.cast(out[0] != 0, get_dtype(dout[0]))
-    out1 = F.cast(out[1] != 0, get_dtype(dout[1]))
-    dz = out0 * dout[0] + out1 * dout[1]
-    return F.zeros_like(x), F.zeros_like(y), dz
-
-
 @bprops.register(_constants.kScalarPow)
 def bprop_scalar_pow(x, y, out, dout):
     """Backpropagator for primitive `scalar_pow`."""
@@ -60,6 +50,12 @@ def bprop_scalar_usub(x, out, dout):
     return (-dout,)
 
 
+@bprops.register("ScalarLog")
+def bprop_scalar_log(x, out, dout):
+    """Backpropagator for primitive `scalar_usub`."""
+    return (dout * (1 / x),)
+
+
 @bprops.register("scalar_cast")
 def bprop_scalar_cast(x, t, out, dout):
     """Backpropagator for primitive `scalar_cast`."""
@@ -195,3 +191,13 @@ def bprop_scalar_not(x, out, dout):
 def bprop_tensor_move(x, out, dout):
     """Backpropagator for primitive `TensorMove`."""
     return (dout,)
+
+
+@bprops.register("DictInplaceSetItem")
+def get_bprop_dict_inplace_setitem(self):
+    """Generate bprop for dict inplace pop"""
+
+    def bprop(x, key, target, out, dout):
+        return (zeros_like(x), zeros_like(key), zeros_like(target))
+
+    return bprop

mindspore/ops/_grad_experimental/grad_inner_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2023 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.
@@ -16,56 +16,11 @@
 """inner_ops"""
 from __future__ import absolute_import
 
-from mindspore.ops.operations.comm_ops import _VirtualPipelineEnd
-from mindspore.ops._grad.grad_base import bprop_getters
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.operations import _grad_ops as G
-from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-
-
-@bprop_getters.register(inner.TensorCopySlices)
-def get_bprop_tensor_copy_slices(self):
-    """Generate bprop for TensorCopySlices"""
-    tensor_copy_slices = inner.TensorCopySlices()
-
-    def bprop(x, update, begin, end, stride, out, dout):
-        x_grad = tensor_copy_slices(dout, zeros_like(update), begin, end, stride)
-        update_grad = F.strided_slice(dout, begin, end, stride)
-        return x_grad, update_grad, zeros_like(begin), zeros_like(end), zeros_like(stride)
-
-    return bprop
-
-
-@bprop_getters.register(_VirtualPipelineEnd)
-def get_bprop_virtual_pipeline_end(self):
-    """Backpropagator for _VirtualPipelineEnd."""
-    grad = _VirtualPipelineEnd()
-
-    def bprop(x, out, dout):
-        dx = grad(dout)
-        return (dx,)
-    return bprop
-
-
-@bprop_getters.register(inner.DynamicResizeNearestNeighbor)
-def get_bprop_dynamic_resize_nearest_neighbor(self):
-    """Generate bprop for DynamicResizeNearestNeighbor"""
-    op = G.ResizeNearestNeighborGrad(self.align_corners)
-    tensor_shape = P.TensorShape()
-    shape_op = P.Shape()
-
-    def bprop(inputs, size, out, dout):
-        if F.is_sequence_value_unknown(shape_op(inputs)):
-            shp = tensor_shape(inputs)
-        else:
-            shp = shape_op(inputs)
-        # 2 and 3 represent the height and width
-        shp = (shp[2:])
-        return (op(dout, shp), zeros_like(size))
-
-    return bprop
+from mindspore.ops._grad_experimental.grad_base import bprop_getters
 
 
 @bprop_getters.register(inner.ParallelResizeBilinear)
@@ -81,10 +36,36 @@ def get_bprop_parallel_resize_bilinear(self):
     return bprop
 
 
-@bprop_getters.register(inner.ConvertToDynamic)
-def get_bprop_gpu_convert_to_dynamic_rank(self):
-    """Get backprop for ConvertToDynamic."""
+@bprop_getters.register(inner.PsROIPooling)
+def get_bprop_ps_roi_pooling(self):
+    """Grad definition for `PsROIPooling` operation."""
+    shape_op = P.Shape()
+    pooled_height = self.pooled_height
+    pooled_width = self.pooled_width
+    spatial_scale = self.spatial_scale
+    out_dim = self.out_dim
+    num_rois = self.num_rois
+
+    def bprop(inputs, rois, out, dout):
+        mapping_channel = out[1]
+        inputs_shape = shape_op(inputs)
+        batch_size = inputs_shape[0]
+        channels = inputs_shape[1]
+        height = inputs_shape[2]
+        width = inputs_shape[3]
+
+        dx = G.PsROIPoolingGrad(
+            batch_size,
+            channels,
+            height,
+            width,
+            num_rois,
+            pooled_height,
+            pooled_width,
+            spatial_scale,
+            out_dim
+        )(dout[0], rois, mapping_channel)
+
+        return dx, zeros_like(rois)
 
-    def bprop(x, out, dout):
-        return (dout,)
     return bprop