mindspore 2.2.10__cp39-cp39-win_amd64.whl → 2.2.14__cp39-cp39-win_amd64.whl

mindspore/mindrecord/tools/csv_to_mr.py

@@ -22,10 +22,6 @@ from mindspore import log as logger
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread
 
-try:
-    pd = import_module("pandas")
-except ModuleNotFoundError:
-    pd = None
 
 __all__ = ['CsvToMR']
 
@@ -55,8 +51,7 @@ class CsvToMR:
     """
 
     def __init__(self, source, destination, columns_list=None, partition_number=1):
-        if not pd:
-            raise Exception("Module pandas is not found, please use pip install it.")
+        self.pd = import_module("pandas")
         if isinstance(source, str):
             check_filename(source)
             self.source = source
@@ -135,8 +130,8 @@ class CsvToMR:
         if not os.path.exists(self.source):
             raise IOError("Csv file {} do not exist.".format(self.source))
 
-        pd.set_option('display.max_columns', None)
-        df = pd.read_csv(self.source)
+        self.pd.set_option('display.max_columns', None)
+        df = self.pd.read_csv(self.source)
 
         csv_schema = self._get_schema(df)
 

mindspore/mindrecord/tools/mnist_to_mr.py

@@ -25,10 +25,6 @@ from mindspore import log as logger
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread, SUCCESS, FAILED
 
-try:
-    cv_import = import_module("cv2")
-except ModuleNotFoundError:
-    cv_import = None
 
 __all__ = ['MnistToMR']
 
@@ -58,6 +54,8 @@ class MnistToMR:
     """
 
     def __init__(self, source, destination, partition_number=1):
+        self.cv_import = import_module("cv2")
+
         self.image_size = 28
         self.num_channels = 1
 
@@ -89,9 +87,6 @@ class MnistToMR:
 
     # pylint: disable=missing-docstring
     def run(self):
-        if not cv_import:
-            raise ModuleNotFoundError("opencv-python module not found, please use pip install it.")
-
         if self._transform_train() == FAILED:
             return FAILED
         if self._transform_test() == FAILED:
@@ -155,7 +150,7 @@ class MnistToMR:
         train_data = self._extract_images(self.train_data_filename_)
         train_labels = self._extract_labels(self.train_labels_filename_)
         for data, label in zip(train_data, train_labels):
-            _, img = cv_import.imencode(".jpeg", data)
+            _, img = self.cv_import.imencode(".jpeg", data)
             yield {"label": int(label), "data": img.tobytes()}
 
     def _mnist_test_iterator(self):
@@ -168,7 +163,7 @@ class MnistToMR:
         test_data = self._extract_images(self.test_data_filename_)
         test_labels = self._extract_labels(self.test_labels_filename_)
         for data, label in zip(test_data, test_labels):
-            _, img = cv_import.imencode(".jpeg", data)
+            _, img = self.cv_import.imencode(".jpeg", data)
             yield {"label": int(label), "data": img.tobytes()}
 
     def _transform_train(self):

mindspore/mindrecord/tools/tfrecord_to_mr.py

@@ -97,10 +97,7 @@ class TFRecordToMR:
     """
 
     def __init__(self, source, destination, feature_dict, bytes_fields=None):
-        try:
-            self.tf = import_module("tensorflow")  # just used to convert tfrecord to mindrecord
-        except ModuleNotFoundError:
-            raise Exception("Module tensorflow is not found, please use pip install it.")
+        self.tf = import_module("tensorflow")  # just used to convert tfrecord to mindrecord
 
         if self.tf.__version__ < SupportedTensorFlowVersion:
             raise Exception("Module tensorflow version must be greater or equal {}.".format(SupportedTensorFlowVersion))

mindspore/nn/layer/activation.py

@@ -782,7 +782,7 @@ class Tanhshrink(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
+        >>> import mindspore as ms
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> x = Tensor(np.array([1, 2, 3, 2, 1]), ms.float16)

mindspore/nn/layer/embedding.py

@@ -522,12 +522,12 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
           this interface. Type is Int32, Int64.
         - **input_values** (Tensor) - The shape of tensor is :math:`(batch\_size, seq\_length)`.
           Specifies the weights of elements of the input_indices. The lookout vector will multiply with
-          the input_values. Type is Float32.
+          the input_values. Type is float32.
         - **field_ids** (Tensor)  - The shape of tensor is :math:`(batch\_size, seq\_length)`.
           Specifies the field id of elements of the input_indices. Type is Int32.
 
     Outputs:
-        Tensor, the shape of tensor is :math:`(batch\_size, field\_size, embedding\_size)`. Type is Float32.
+        Tensor, the shape of tensor is :math:`(batch\_size, field\_size, embedding\_size)`. Type is float32.
 
     Raises:
         TypeError: If `vocab_size` or `embedding_size` or `field_size` is not an int.

mindspore/nn/layer/flash_attention.py

@@ -21,9 +21,7 @@ import mindspore.common.dtype as mstype
 from mindspore.common.tensor import Tensor
 from mindspore import ops
 from mindspore.nn.cell import Cell
-from mindspore.ops._op_impl._custom_op.flash_attention.flash_attention_impl import get_flash_attention
 from mindspore.ops.operations.nn_ops import FlashAttentionScore
-from mindspore._c_expression import MSContext
 
 __all__ = ['FlashAttention']
 
@@ -46,18 +44,17 @@ class FlashAttention(Cell):
             Default 65536.
         next_block_num(int): A integer to define the number of blocks to look behind for local block sparse attention.
             Default 65536.
-        tiling_stgy_name(str): A str to define tiling strategy of flash attention.
         dp(int): data parallel.
             Default 1.
         mp(int): model parallel.
             Default 1.
-        high_precision(bool): This mode has higher precision but some performance loss.
+        high_precision(bool): This mode has higher precision but some performance loss. Only take effect on Ascend910A.
             Default False.
         have_attention_mask_batch(bool): indicates whether attention_mask contains the batch dimension.
             Default True
         alibi(bool): This parameter indicates whether the flashattention supports the Alibi.
             Default: False
-        use_mqa(bool): Using MHA if True, only take effect under 910B. Default: False.
+        use_mqa(bool): Using MQA if True, only take effect under 910B. Default: False.
 
 
     Inputs:
@@ -98,7 +95,6 @@ class FlashAttention(Cell):
                  dropout_rate=0.0,
                  prev_block_num=65536,
                  next_block_num=65536,
-                 tiling_stgy_name="sparse",
                  dp=1,
                  mp=1,
                  high_precision=False,
@@ -112,52 +108,36 @@ class FlashAttention(Cell):
         if scaling_constant == 0:
             raise ValueError("the scaling constant must not be 0.")
         self.dropout_rate = dropout_rate
-        self.is_910A = MSContext.get_instance().get_ascend_soc_version() == "ascend910"
-        if self.is_910A:
-            self.scale_factor = Tensor([1. / math.sqrt(scaling_constant)], dtype=mstype.float16)
-            self.scale_mul = ops.Mul().shard(((dp, mp, 1, 1), (1,)))
-            self.ones = ops.Ones()
-            self.dim_mask = Tensor([1 for _ in range(head_dim)], dtype=mstype.int8)
-            self.have_attention_mask_batch = have_attention_mask_batch
-            self.alibi = alibi
-            self.flash_attention = get_flash_attention(
-                prev_block_num=prev_block_num,
-                next_block_num=next_block_num,
-                tiling_stgy_name=tiling_stgy_name,
-                high_precision=high_precision
-            )
-            self.flash_attention.add_prim_attr("primitive_target", "Ascend")
+        self.alibi = alibi
+        self.have_attention_mask_batch = have_attention_mask_batch
+
+        self.transpose_4d_pre = ops.Transpose().shard(((dp, mp, 1, 1),))
+        self.transpose_4d_post = ops.Transpose().shard(((dp, 1, mp, 1),))
+        self.reshape = ops.Reshape()
+        self.zeros_like = ops.ZerosLike().shard(((dp, mp, 1, 1),))
+        self.zeros = ops.Zeros()
+        self.attn_cast = ops.Cast()
+        if use_mqa:
+            fa_strategies = ((dp, mp, 1, 1),
+                             (dp, 1, 1, 1),
+                             (dp, 1, 1, 1))
+        else:
             fa_strategies = ((dp, mp, 1, 1),
                              (dp, mp, 1, 1),
                              (dp, mp, 1, 1))
-            self.shard(fa_strategies)
-        else:
-            if alibi:
-                raise ValueError(f"When soc_version is not Ascend910A, alibi must be False")
-            self.transpose_4d_pre = ops.Transpose().shard(((dp, mp, 1, 1),))
-            self.transpose_4d_post = ops.Transpose().shard(((dp, 1, mp, 1),))
-            self.reshape = ops.Reshape()
-            self.zeros_like = ops.ZerosLike().shard(((dp, mp, 1, 1),))
-            self.zeros = ops.Zeros()
-            self.attn_cast = ops.Cast()
-            if use_mqa:
-                fa_strategies = ((dp, mp, 1, 1),
-                                 (dp, 1, 1, 1),
-                                 (dp, 1, 1, 1),
-                                 (dp, 1, 1, 1))
-            else:
-                fa_strategies = ((dp, mp, 1, 1),
-                                 (dp, mp, 1, 1),
-                                 (dp, mp, 1, 1),
-                                 (dp, 1, 1, 1))
-            if dropout_rate > 1e-5:
-                fa_strategies += ((dp, mp, 1, 1),)
-            self.flash_attention = FlashAttentionScore(head_num=head_num, pre_tokens=prev_block_num,
-                                                       next_tokens=next_block_num,
-                                                       keep_prob=1 - dropout_rate,
-                                                       scale_value=1. / scaling_constant,
-                                                       inner_precise=0 if high_precision else 1,
-                                                       input_layout="BNSD").shard(fa_strategies)
+        if self.alibi:
+            self.alibi_rescale_mul = ops.Mul().shard(((dp, mp, 1, 1), (1,)))
+            self.alibi_rescale_factor = Tensor([scaling_constant], dtype=mstype.float16)
+            fa_strategies += ((dp, mp, 1, 1),)
+        if dropout_rate > 1e-5:
+            fa_strategies += ((dp, mp, 1, 1),)
+        fa_strategies += ((dp, 1, 1, 1),)
+        self.flash_attention = FlashAttentionScore(head_num=head_num, pre_tokens=prev_block_num,
+                                                   next_tokens=next_block_num,
+                                                   keep_prob=1 - dropout_rate,
+                                                   scale_value=1. / scaling_constant,
+                                                   inner_precise=0,
+                                                   input_layout="BNSD").shard(fa_strategies)
 
         self.dropout_rate = dropout_rate
         if self.dropout_rate > 1e-5:
@@ -175,49 +155,7 @@ class FlashAttention(Cell):
                                   such as MatMul. Default: None.
         :return:
         """
-        if self.is_910A:
-            if in_strategy is None:
-                # default: dp=1, mp=1, construct inputs only contain query, key, value
-                in_strategy = (
-                    (1, 1, 1, 1),
-                    (1, 1, 1, 1),
-                    (1, 1, 1, 1),
-                )
-            self.flash_attention.shard(in_strategy)
-            dp = in_strategy[0][0]
-            mp = in_strategy[0][1]
-            self.flash_attention.add_prim_attr("dev_matrix_shape", [dp, mp, 1, 1])
-            inputs_tensor_map = [
-                [3, 2, 1, 0],
-                [3, 2, 1, 0],
-                [3, 2, 1, 0],
-            ]
-            if self.have_attention_mask_batch:
-                inputs_tensor_map.append([3, 1, 0])
-            else:
-                inputs_tensor_map.append([-1, 1, 0])
-
-            input_empty_args_num = 2
-            # dropout_mask
-            if self.dropout_rate > 1e-5:
-                input_empty_args_num -= 1
-                inputs_tensor_map.append([3, 2, 1, 0])
-
-            if self.alibi:
-                input_empty_args_num -= 1
-                inputs_tensor_map.append([3, 2, 1, 0])
-
-            self.flash_attention.add_prim_attr("inputs_tensor_map", inputs_tensor_map)
-
-            self.flash_attention.add_prim_attr("outputs_tensor_map", [
-                [3, 2, 1, 0],  # O
-                [3, 2, 1],  # L
-                [3, 2, 1]  # M
-            ])
-            self.flash_attention.add_prim_attr("as_loss_divisor", 0)
-            self.flash_attention.add_prim_attr("empty_mirror_ops", input_empty_args_num)
-        else:
-            self.flash_attention.shard(in_strategy)
+        self.flash_attention.shard(in_strategy)
 
     def construct(self, query, key, value, attn_mask=None, alibi_mask=None):
         """FlashAttention forward
@@ -228,49 +166,24 @@ class FlashAttention(Cell):
         :param alibi_mask: [bsz, head_num, 1, seq_len], if not None
         :return: output          [bsz, head_num, seq_len, head_dim]
         """
-        bsz, head_num, seq_len, head_dim = query.shape
-        if self.is_910A:
-            _, k_head_num, k_seq_len, _ = key.shape
-            _, v_head_num, v_seq_len, _ = value.shape
-            if head_num != k_head_num or head_num != v_head_num:
-                raise ValueError(
-                    "the head_num of query, key and value must be the same, "
-                    "If different head_num are used, users need to change themselves to be same by tile.")
-            if seq_len % 16 != 0 or k_seq_len % 16 != 0 or k_seq_len != v_seq_len:
-                raise ValueError(
-                    "query, key, value seq_len must be a multiple of 16, "
-                    "and the seq_len between key and value must be equal.")
-            # 910A -- FlashAttentionPrimtive
-            if head_dim > 304:
-                raise ValueError(
-                    "the head_dim must be less than 304, otherwise the ub would be OOM.")
-            if self.dropout_rate > 1e-5:
-                drop_mask_bits = self.drop_gen_mask((bsz, head_num, seq_len, seq_len), self.keep_prob)
-                tensor_shape = Tensor((bsz, head_num, seq_len, seq_len), mstype.int32)
-                ones = self.fill_v2(tensor_shape, self.tensor_one)
-                ones = self.depend(ones, query)
-                drop_mask = self.do_dropout(ones, drop_mask_bits, self.keep_prob)
-            else:
-                drop_mask = None
-            query = self.scale_mul(query, self.scale_factor)
-            key = self.scale_mul(key, self.scale_factor)
-            attn_mask = self.cast(attn_mask, mstype.float16)
-            output, _, _ = self.flash_attention(query, key, value, attn_mask, drop_mask, alibi_mask)
+        bsz, head_num, seq_len, _ = query.shape
+        # 910B -- FlashAttentionScore
+        if self.dropout_rate > 1e-5:
+            drop_mask_bits = self.reshape(self.drop_gen_mask((bsz, head_num, seq_len, seq_len), self.keep_prob),
+                                          (bsz, head_num, seq_len, seq_len // 8))
         else:
-            # 910B -- FlashAttentionScore
-            if self.dropout_rate > 1e-5:
-                drop_mask_bits = self.reshape(self.drop_gen_mask((bsz, head_num, seq_len, seq_len), self.keep_prob),
-                                              (bsz, head_num, seq_len, seq_len // 8))
-            else:
-                drop_mask_bits = None
-            # (B, S, S) -> (B, 1, S, S)
+            drop_mask_bits = None
+        if self.alibi:
+            alibi_mask = self.alibi_rescale_mul(alibi_mask, self.cast(self.alibi_rescale_factor, alibi_mask.dtype))
+        # (B, S, S) -> (B, 1, S, S)
+        if self.have_attention_mask_batch:
             attn_mask = self.cast(self.reshape(attn_mask, (bsz, 1, seq_len, seq_len)), mstype.uint8)
-            output, _, _ = self.flash_attention(query,
-                                                key,
-                                                value,
-                                                attn_mask,
-                                                drop_mask_bits,
-                                                None,
-                                                None,
-                                                None)
+        _, _, _, output = self.flash_attention(query,
+                                               key,
+                                               value,
+                                               alibi_mask,
+                                               drop_mask_bits,
+                                               None,
+                                               attn_mask,
+                                               None)
         return output

mindspore/nn/loss/loss.py

@@ -1996,7 +1996,7 @@ class FocalLoss(LossBase):
         >>> import mindspore.nn as nn
         >>> logits = ms.Tensor([[0.8, 1.4], [0.5, 0.9], [1.2, 0.9]], ms.float32)
         >>> labels = ms.Tensor([[1], [1], [0]], ms.int32)
-        >>> focalloss = nn.FocalLoss(weight=Tensor([1, 2]), gamma=2.0, reduction='mean')
+        >>> focalloss = nn.FocalLoss(weight=ms.Tensor([1, 2]), gamma=2.0, reduction='mean')
         >>> output = focalloss(logits, labels)
         >>> print(output)
         0.12516622

mindspore/nn/optim/ada_grad.py

@@ -162,7 +162,7 @@ class Adagrad(Optimizer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
+        >>> from mindspore import train
         >>> import mindspore.nn as nn
         >>>
         >>> # Define the network structure of LeNet5. Refer to
@@ -185,7 +185,7 @@ class Adagrad(Optimizer):
         >>> # The final parameters order in which the optimizer will be followed is the value of 'order_params'.
         >>>
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = train.Model(net, loss_fn=loss, optimizer=optim)
     """
 
     @opt_init_args_register

mindspore/nn/optim/sgd.py

@@ -193,9 +193,9 @@ class SGD(Optimizer):
                             "or 'weight_decay' set in grouped 'params' must be float or int type.")
 
         if hasattr(self, "group_weight_decay") and self.group_weight_decay:
-            self.opt = tuple(P.SGD(dampening, wd, nesterov) for wd in self.group_weight_decay)
+            self.opt = tuple(P.SGD(dampening, 0.0, nesterov) for _ in self.group_weight_decay)
         else:
-            self.opt = tuple([P.SGD(dampening, float(weight_decay), nesterov)] * len(self._parameters))
+            self.opt = tuple([P.SGD(dampening, 0.0, nesterov)] * len(self._parameters))
 
         self.momentum = Parameter(Tensor(momentum, mstype.float32), name="momentum")
 
@@ -220,6 +220,7 @@ class SGD(Optimizer):
         params = self._parameters
         accum = self.accum
         stat = self.stat
+        gradients = self.decay_weight(gradients)
         gradients = self.flatten_gradients(gradients)
         gradients = self.gradients_centralization(gradients)
         gradients = self.scale_grad(gradients)

mindspore/nn/wrap/__init__.py

@@ -20,7 +20,8 @@ Use the Wrapper to combine the loss or build the training steps.
 from __future__ import absolute_import
 
 from mindspore.nn.wrap.cell_wrapper import ForwardValueAndGrad, TrainOneStepCell, WithLossCell, WithGradCell, \
-    WithEvalCell, ParameterUpdate, GetNextSingleOp, VirtualDatasetCellTriple, MicroBatchInterleaved, PipelineCell
+    WithEvalCell, ParameterUpdate, GetNextSingleOp, VirtualDatasetCellTriple, MicroBatchInterleaved, PipelineCell, \
+    GradAccumulationCell
 from mindspore.nn.wrap.loss_scale import TrainOneStepWithLossScaleCell,\
     DynamicLossScaleUpdateCell, FixedLossScaleUpdateCell
 from mindspore.nn.wrap.grad_reducer import DistributedGradReducer
@@ -42,5 +43,6 @@ __all__ = [
     "ParameterUpdate",
     "DynamicLossScaleUpdateCell",
     "FixedLossScaleUpdateCell",
-    "VirtualDatasetCellTriple"
+    "VirtualDatasetCellTriple",
+    "GradAccumulationCell"
     ]

mindspore/nn/wrap/cell_wrapper.py

@@ -673,7 +673,7 @@ class PipelineCell(Cell):
 
 class GradAccumulationCell(Cell):
     """
-    Wrap the network with Micro Batch.
+    Wrap the network with Micro Batch to enable the grad accumulation in semi_auto_parallel/auto_parallel mode.
 
     Args:
         network (Cell): The target network to wrap.
@@ -683,8 +683,11 @@ class GradAccumulationCell(Cell):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> net = Net()
-        >>> net = GradAccumulationCell(net, 4)
+        >>> import mindspore.nn as nn
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
+        >>> net = nn.GradAccumulationCell(net, 4)
     """
     def __init__(self, network, micro_size):
         super(GradAccumulationCell, self).__init__(auto_prefix=False)

mindspore/numpy/math_ops.py

@@ -4285,7 +4285,7 @@ def argmin(a, axis=None):
 
     Examples:
         >>> import mindspore.numpy as np
-        >>> a = np.arange(10, 16).reshape(2, 3)
+        >>> a = np.arange(10, 16).reshape(2, 3).astype(np.float32)
         >>> print(np.argmin(a))
         0
         >>> print(np.argmin(a, axis=0))

mindspore/ops/__init__.py

@@ -34,6 +34,7 @@ from mindspore.ops.composite import *
 from mindspore.ops.operations import *
 from mindspore.ops.function import *
 from mindspore.ops.functional import *
+from mindspore.ops.silent_check import _silent_check
 
 __primitive__ = [
     "prim_attr_register", "Primitive", "PrimitiveWithInfer", "PrimitiveWithCheck", "signature"
@@ -48,3 +49,5 @@ __all__.extend(composite.__all__)
 __all__.extend(operations.__all__)
 __all__.extend(functional.__all__)
 __all__.extend(function.__all__)
+
+_silent_check()

mindspore/ops/_grad_experimental/grad_array_ops.py

@@ -36,8 +36,6 @@ from mindspore.ops.operations.array_ops import ScatterAddWithAxis
 from mindspore.ops.operations.array_ops import Expand
 from mindspore.ops.operations.array_ops import SegmentMean
 from mindspore.ops.operations.array_ops import AffineGrid
-from mindspore.ops.operations.array_ops import Im2Col
-from mindspore.ops.operations.array_ops import Col2Im
 from mindspore.ops.operations.array_ops import MaskedScatter
 from mindspore.ops.operations.array_ops import MaskedSelect
 from mindspore.ops.operations.array_ops import CountNonZero
@@ -360,35 +358,6 @@ def get_bprop_resize_nearest_neighbor_v2(self):
     return bprop
 
 
-@bprop_getters.register(Im2Col)
-def get_bprop_im2col(self):
-    """
-    Generate bprop for Im2Col
-
-    Im2Col, corresponding to torch's UnFold operator.
-    The Unfold operator has no `padding_mode` attribute,
-    and it's implementation corresponds to the mindspore
-    implementation with `padding_mode=CALCULATED` .
-    So, currently the bprop function of Im2Col only supports
-    the CALCULATED mode.
-    """
-    kernel_size = self.ksizes
-    dilation = self.dilations
-    stride = self.strides
-    padding = (self.pads[0], self.pads[-1])
-    col2im = Col2Im(kernel_size=kernel_size,
-                    dilation=dilation,
-                    stride=stride,
-                    padding=padding)
-
-    def bprop(x, out, dout):
-        x_shape = P.TensorShape()(x)[2:]
-        dx = col2im(dout, x_shape)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(P.ExtractVolumePatches)
 def get_bprop_extract_volume_patches(self):
     """Generate bprop for ExtractVolumePatches"""

mindspore/ops/_grad_experimental/grad_comm_ops.py

@@ -92,7 +92,8 @@ def get_bprop_send(self):
     """Generate bprop for Send."""
     shape = self.get_attr_dict()["shape"]
     dtype = self.get_attr_dict()["dtype"]
-    send_grad = Receive(self.sr_tag, self.rank, shape, dtype, self.group_back)
+    tag = self.get_attr_dict()["sr_tag"]
+    send_grad = Receive(tag, self.rank, shape, dtype, self.group_back)
     virtual_input = Tensor(0.0, dtype)
 
     def bprop(x, out, dout):
@@ -105,7 +106,8 @@ def get_bprop_send(self):
 @bprop_getters.register(Receive)
 def get_bprop_receive(self):
     """Generate bprop for Receive."""
-    receive_grad = Send(self.tag, self.rank, self.group_back)
+    tag = self.get_attr_dict()["sr_tag"]
+    receive_grad = Send(tag, self.rank, self.group_back)
     depend = P.Depend()
     cast = P.Cast()
     out_tensor = Tensor(0.0, mstype.float16)

mindspore/ops/_grad_experimental/grad_inner_ops.py

@@ -36,6 +36,14 @@ def get_bprop_parallel_resize_bilinear(self):
     return bprop
 
 
+@bprop_getters.register(P.inner_ops.GenerateEodMask)
+def get_bprop_generate_eod_mask(self):
+
+    def bprop(x, out, dout):
+        return dout, dout
+    return bprop
+
+
 @bprop_getters.register(inner.PsROIPooling)
 def get_bprop_ps_roi_pooling(self):
     """Grad definition for `PsROIPooling` operation."""