mindspore 2.1.0__cp38-cp38-win_amd64.whl → 2.2.11__cp38-cp38-win_amd64.whl

mindspore/numpy/utils_const.py

@@ -143,8 +143,8 @@ def _infer_out_shape(*shapes):
     shape_out = list()
     max_len = max([len(it) for it in shapes])
     for i in range(max_len):
-        items = [it[i-max_len+len(it)] if i-max_len +
-                 len(it) >= 0 else 1 for it in shapes]
+        items = [
+            it[i - max_len + len(it)] if i - max_len + len(it) >= 0 else 1 for it in shapes]
         max_size = 0 if 0 in items else max(items)
         _check()
         shape_out.append(max_size)
@@ -158,8 +158,8 @@ def _can_broadcast(*shapes):
     """
     max_len = max([len(it) for it in shapes])
     for i in range(max_len):
-        items = [it[i-max_len+len(it)] if i-max_len +
-                 len(it) >= 0 else 1 for it in shapes]
+        items = [
+            it[i - max_len + len(it)] if i - max_len + len(it) >= 0 else 1 for it in shapes]
         max_size = 0 if 0 in items else max(items)
         if any(item not in (1, max_size) for item in items):
             return False
@@ -399,7 +399,7 @@ def _broadcast_tuples(tup1, tup2):
         if not isinstance(tup1, (tuple, list)) or not isinstance(tup2, (tuple, list)):
             raise TypeError("input shift and axis must be tuple or list or int.")
         if len(tup1) == len(tup2) or len(tup1) == 1 or len(tup2) == 1:
-            return None
+            return
         raise ValueError("shape mismatch: objects cannot be broadcast to a single shape")
 
     tup1 = (tup1,) if isinstance(tup1, int) else tup1

mindspore/ops/_grad_experimental/__init__.py

@@ -17,20 +17,15 @@
 from __future__ import absolute_import
 from mindspore.ops._grad_experimental.grad_base import get_bprop_fn, get_taylor_fprop_fn
 from mindspore.ops._grad_experimental import grad_array_ops
-from mindspore.ops._grad_experimental import grad_image_ops
 from mindspore.ops._grad_experimental import grad_inner_ops
 from mindspore.ops._grad_experimental import grad_nn_ops
 from mindspore.ops._grad_experimental import grad_math_ops
-from mindspore.ops._grad_experimental import grad_linalg_ops
 from mindspore.ops._grad_experimental import grad_sparse
 from mindspore.ops._grad_experimental import grad_sparse_ops
-from mindspore.ops._grad_experimental import grad_scalar_ops
 from mindspore.ops._grad_experimental import grad_comm_ops
 from mindspore.ops._grad_experimental import grad_debug_ops
 from mindspore.ops._grad_experimental import grad_implementations
-from mindspore.ops._grad_experimental import grad_other_ops
 from mindspore.ops._grad_experimental import grad_quant_ops
-from mindspore.ops._grad_experimental import grad_sequence_ops
 from mindspore.ops._grad_experimental import taylor_rule
 
 __all__ = ['get_bprop_fn', 'get_taylor_fprop_fn']

mindspore/ops/_grad_experimental/grad_array_ops.py

@@ -203,7 +203,7 @@ def get_bprop_index_put(self):
         if is_ascend:
             indices_ms = [convert_idx_positive(indices_ms[i], x1.shape[i]) for i in range(len(indices_ms))]
         indices_me = stack(indices_ms)
-        indices_grad = F.transpose(indices_me, F.make_range(F.rank(indices_me)-1, -1, -1))
+        indices_grad = F.transpose(indices_me, F.make_range(F.rank(indices_me) - 1, -1, -1))
         values_grad = gather_nd(dout, indices_grad)
         if equal(cast(x2.shape[0], mstype.int32), Tensor(1)):
             values_grad = values_grad.sum().reshape(1)
@@ -398,7 +398,6 @@ def get_bprop_extract_volume_patches(self):
     expend_dims = P.ExpandDims()
     scatter_nd = P.ScatterNd()
     slice_op = P.Slice()
-    fill = P.Fill()
     dtype = P.DType()
     cast = P.Cast()
     matmul = P.MatMul()
@@ -466,7 +465,7 @@ def get_bprop_extract_volume_patches(self):
         idx_tensor = concat((expend_dims(x_idx_patched, -1), expend_dims(out_idx, -1)))
         idx_map = P.Reshape()(idx_tensor, (-1, 2))
         sp_shape = (x_indices_num, out_indices_num)
-        sp_mat_full = scatter_nd(idx_map, fill(dtype(dout), (out_indices_num,), 1), sp_shape)
+        sp_mat_full = scatter_nd(idx_map, F.fill(dtype(dout), (out_indices_num,), 1), sp_shape)
         sp_tensor = slice_op(sp_mat_full, (1, 0), (x_indices_num - 1, out_indices_num))
 
         grad = P.Transpose()(dout, (0, 2, 3, 4, 1))

mindspore/ops/_grad_experimental/grad_comm_ops.py

@@ -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'):
@@ -218,6 +223,7 @@ 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))
         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)
@@ -502,6 +511,7 @@ def get_bprop_mirror_operator(self):
                 dx = RowTensorInner(indices, grad, dout.dense_shape)
 
         return (dx,)
+
     return bprop
 
 
@@ -555,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
 
 
@@ -569,7 +580,7 @@ def get_bprop_virtual_div_operator(self):
     def bprop(x, out, dout):
         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,)
@@ -588,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
 
 
@@ -597,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_experimental/grad_debug_ops.py

@@ -16,48 +16,11 @@
 """Generate bprop for debug ops"""
 
 from mindspore.ops import operations as P
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops._grad_experimental.grad_base import bprop_getters
 
 # Unused parameters are placeholders.
 
 
-@bprop_getters.register(P.ScalarSummary)
-def get_bprop_scalar_summary(self):
-    """Generate bprop for ScalarSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
-@bprop_getters.register(P.TensorSummary)
-def get_bprop_tensor_summary(self):
-    """Generate bprop for TensorSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
-@bprop_getters.register(P.ImageSummary)
-def get_bprop_image_summary(self):
-    """Generate bprop for ImageSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
-@bprop_getters.register(P.HistogramSummary)
-def get_bprop_histogram_summary(self):
-    """Generate bprop for HistogramSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
 @bprop_getters.register(P.InsertGradientOf)
 def get_bprop_insert_gradient_of(self):
     """Generate bprop for InsertGradientOf"""

mindspore/ops/_grad_experimental/grad_implementations.py

@@ -19,7 +19,7 @@ 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_experimental.grad_base import bprops
+from mindspore.ops._grad_experimental.grad_base import bprops, bprop_getters
 from mindspore.common import dtype as mstype
 
 get_dtype = P.DType()
@@ -191,3 +191,13 @@ def bprop_scalar_not(x, out, dout):
 def bprop_tensor_move(x, out, dout):
     """Backpropagator for primitive `TensorMove`."""
     return (dout,)
+
+
+@bprop_getters.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,57 +16,11 @@
 """inner_ops"""
 from __future__ import absolute_import
 
-from mindspore.ops.operations.comm_ops import _VirtualPipelineEnd
 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
-from mindspore.ops.primitive import _primexpr
-from mindspore.ops._grad_experimental.grad_base import bprop_getters, sum_grad_reduce_axis
-import mindspore as ms
-
-reshape = P.Reshape()
-
-
-@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)
-        res = (x_grad, update_grad, zeros_like(begin), zeros_like(end), zeros_like(stride))
-        return res
-
-    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)
-    shape_op = P.Shape()
-
-    def bprop(inputs, size, out, dout):
-        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)
@@ -82,115 +36,6 @@ 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."""
-
-    def bprop(x, out, dout):
-        return (dout,)
-    return bprop
-
-
-def _get_matrix_diag_assist(x_shape, x_dtype):
-    base_eye = P.Eye()(x_shape[-1], x_shape[-1], x_dtype).flatten()
-    tile = P.Tile()(base_eye, x_shape[:-1])
-    assist = P.Reshape()(tile, x_shape + (x_shape[-1],))
-    return assist
-
-
-def _get_matrix_diag_part_assist(x_shape, x_dtype):
-    base_eye = P.Eye()(x_shape[-2], x_shape[-1], x_dtype).flatten()
-    tile = P.Tile()(base_eye, x_shape[:-2])
-    assist = P.Reshape()(tile, x_shape)
-    return assist
-
-
-@_primexpr
-def _get_min(x):
-    return min(x)
-
-
-@bprop_getters.register(inner.MatrixDiag)
-def get_bprop_matrix_diag(self):
-    """Generate bprop for MatrixDiag"""
-    get_dtype = P.DType()
-
-    def bprop(x, y, out, dout):
-        shape = F.shape(dout)
-        dtype = get_dtype(dout)
-        assist = _get_matrix_diag_part_assist(shape, dtype)
-        dx = inner.MatrixDiagPart()(dout, assist)
-        return dx, zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(inner.MatrixDiagPart)
-def get_bprop_matrix_diag_part(self):
-    """Generate bprop for MatrixDiagPart"""
-    get_dtype = P.DType()
-
-    def bprop(x, y, out, dout):
-        x_shape = F.shape(x)[-2:]
-        if x_shape[0] == x_shape[1]:
-            shape = F.shape(dout)
-            dtype = get_dtype(dout)
-            assist = _get_matrix_diag_assist(shape, dtype)
-            return inner.MatrixDiag()(dout, assist), zeros_like(y)
-        shape = F.shape(x)
-        dtype = get_dtype(x)
-        assist = _get_matrix_diag_part_assist(shape, dtype)
-        return inner.MatrixSetDiag()(zeros_like(x), dout, assist), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(inner.MatrixSetDiag)
-def get_bprop_matrix_set_diag(self):
-    """Generate bprop for MatrixSetDiag"""
-    get_dtype = P.DType()
-
-    def bprop(x, y, z, out, dout):
-        input_shape = F.shape(x)
-        batch_shape = input_shape[:-2]
-        matrix_shape = input_shape[-2:]
-        diag_shape = batch_shape + (_get_min(matrix_shape),)
-
-        grad_shape = F.shape(dout)
-        grad_dtype = get_dtype(dout)
-        assist = _get_matrix_diag_part_assist(grad_shape, grad_dtype)
-        dx = inner.MatrixSetDiag()(dout, P.Zeros()(diag_shape, grad_dtype), assist)
-        dy = inner.MatrixDiagPart()(dout, assist)
-        dz = zeros_like(z)
-        return dx, dy, dz
-
-    return bprop
-
-
-@bprop_getters.register(inner.DSDMatmul)
-def get_dsd_matmul_bprop(self):
-    def bprop(w1_gm, w2_gm, v_gm, out, dout):
-        d_w1_gm, d_w2_gm, d_v_gm = inner.DSDGrad()(w1_gm, w2_gm, v_gm, out, dout)
-        return d_w1_gm, d_w2_gm, d_v_gm
-
-    return bprop
-
-
-@bprop_getters.register(inner.MatmulDDS)
-def get_bprop(self):
-    """brop of the matmulDDS operator"""
-
-    def bprop(q, k, local_mask, global_mask, out, d_out):
-        lc, gc = out
-        d_lc, d_gc = d_out
-        dq, dk = inner.MatmulDDSGrad()(q, k, lc, gc, d_lc, d_gc)
-        dk = P.Transpose()(dk, (1, 0, 3, 2))
-        all_d = (dq, dk, zeros_like(local_mask), zeros_like(global_mask))
-        return all_d
-
-    return bprop
-
-
 @bprop_getters.register(inner.PsROIPooling)
 def get_bprop_ps_roi_pooling(self):
     """Grad definition for `PsROIPooling` operation."""
@@ -224,62 +69,3 @@ def get_bprop_ps_roi_pooling(self):
         return dx, zeros_like(rois)
 
     return bprop
-
-
-@bprop_getters.register(inner.DynamicBroadcastTo)
-def get_bprop_dynamic_broadcast_to(self):
-    """Generate bprop for DynamicBroadcastTo"""
-    shape_op = P.Shape()
-
-    def bprop(x, shp, out, dout):
-        x_shape = shape_op(x)
-        broadcast_shape = shape_op(out)
-
-        _, reduction_axes = inner.DynamicBroadcastGradientArgs()(broadcast_shape, x_shape)
-        out_type = dout.dtype
-        if out_type in (ms.int16, ms.int32, ms.int64):
-            dout = P.Cast()(dout, ms.float32)
-            reduced_grad = sum_grad_reduce_axis(dout, reduction_axes, keep_dims=True)
-            reduced_grad = P.Cast()(reduced_grad, out_type)
-        else:
-            reduced_grad = sum_grad_reduce_axis(dout, reduction_axes, keep_dims=True)
-        dx = reshape(reduced_grad, x_shape)
-        return dx, zeros_like(shp)
-
-    return bprop
-
-
-@bprop_getters.register(inner.ConvertToAdapterTensor)
-def get_bprop_convert_to_adapter_tensor(self):
-    """Generate bprop for ConvertToAdapterTensor"""
-
-    def bprop(x, out, dout):
-        return (dout,)
-
-    return bprop
-
-
-@bprop_getters.register(inner.ConvertToMsTensor)
-def get_bprop_convert_to_ms_tensor(self):
-    """Generate bprop for ConvertToMsTensor"""
-
-    def bprop(x, out, dout):
-        return (dout,)
-
-    return bprop
-
-
-@bprop_getters.register(inner.SiLU)
-def get_bprop_silu(self):
-    """Generate bprop for SiLU"""
-    sigmoid_grad = G.SigmoidGrad()
-    mul_func = P.Mul()
-
-    def bprop(x, out, dout):
-        sigmoid_input = P.Sigmoid()(x)
-        bc_dx = mul_func(x, dout)
-        bc_dy = mul_func(sigmoid_input, dout)
-        dx = sigmoid_grad(sigmoid_input, bc_dx)
-        return (dx+bc_dy,)
-
-    return bprop