mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/operations/__init__.py

@@ -50,12 +50,12 @@ from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchT
                         ScatterNdMul, SegmentMean, SegmentProd, SegmentSum, SegmentMax, SegmentMin, Tril, Triu,
                         UniqueConsecutive, UnravelIndex, FillV2, CountNonZero, TensorScatterElements, IndexPut,
                         MaskedScatter)
-from .comm_ops import (AllGather, AllReduce, Reduce, NeighborExchange, NeighborExchangeV2, AlltoAll, _AllSwap,
-                       Broadcast, CollectiveGather, CollectiveScatter, Barrier, Send, Receive, BatchISendIRecv,
+from .comm_ops import (AllGather, AllReduce, NeighborExchange, NeighborExchangeV2, AlltoAll, _AllSwap, ReduceScatter,
+                       Broadcast,
                        _MirrorOperator, _MirrorMiniStepOperator, _MiniStepAllGather, ReduceOp, _VirtualDataset,
                        _VirtualOutput, _VirtualDiv, _GetTensorSlice, _VirtualAdd, _VirtualAssignAdd, _VirtualAccuGrad,
                        _HostAllGather, _HostReduceScatter, _MirrorMicroStepOperator, _MicroStepAllGather,
-                       _VirtualPipelineEnd, AlltoAllV, ReduceScatter)
+                       _VirtualPipelineEnd)
 from .control_ops import GeSwitch, Merge
 from .custom_ops import (Custom)
 from .debug_ops import (ImageSummary, InsertGradientOf, HookBackward, ScalarSummary,
@@ -136,7 +136,6 @@ from ..deprecated import (identity, DropoutDoMask, MaxPoolWithArgmax, DropoutGen
                           TensorAdd, InplaceUpdate, ScatterNonAliasingAdd,
                           BatchToSpaceND, Unpack, GatherV2, DynamicShape, ScalarToArray, Pack)
 from .manually_defined._inner import ScalarCast
-from .reshard_ops import (Reshard)
 
 __all__ = [
     'HSVToRGB',
@@ -392,11 +391,9 @@ __all__ = [
     'UnsortedSegmentProd',
     "AllGather",
     "AllReduce",
-    "Reduce",
     "_AllSwap",
     "ReduceScatter",
     "Broadcast",
-    "BatchISendIRecv",
     "ReduceOp",
     'ScalarCast',
     'GetNext',
@@ -531,12 +528,6 @@ __all__ = [
     "NeighborExchangeV2",
     "NeighborExchange",
     "AlltoAll",
-    "AlltoAllV",
-    "CollectiveGather",
-    "CollectiveScatter",
-    "Barrier",
-    "Send",
-    "Receive",
     "Custom",
     "LuSolve",
     "CholeskyInverse",
@@ -704,7 +695,6 @@ __all__ = [
     "ReshapeAndCache",
     "ApplyRotaryPosEmb",
     "RmsNorm",
-    "Reshard",
 ]
 
 __custom__ = [

mindspore/ops/operations/_grad_ops.py

@@ -34,9 +34,8 @@ from ..auto_generate import (AbsGrad, ACosGrad, LogitGrad, AcoshGrad, AsinGrad,
                              GatherDGradV2, ResizeBilinearGrad, ResizeLinear1DGrad, ResizeNearestNeighborV2Grad,
                              SigmoidGrad, HSwishGrad, NLLLossGrad, AtanGrad, GridSampler3DGrad, GridSampler2DGrad,
                              ResizeBicubicGrad, HSigmoidGrad, CholeskyGrad, ResizeNearestNeighborGrad, LayerNormGrad,
-                             HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad, RmsNormGrad,
-                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad,
-                             BinaryCrossEntropyGrad)
+                             HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad,
+                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad)
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -98,6 +97,14 @@ class KLDivLossGrad(Primitive):
         self.reduction = validator.check_string(reduction, support_mode, 'reduction', self.name)
 
 
+class BinaryCrossEntropyGrad(Primitive):
+    """Computes gradients for `BinaryCrossEntropy` operation."""
+
+    @prim_attr_register
+    def __init__(self, reduction='mean'):
+        self.reduction = validator.check_string(reduction, ['none', 'mean', 'sum'], 'reduction', self.name)
+
+
 class LuUnpackGrad(Primitive):
     """Computes gradients for `LuUnpack` operation."""
 
@@ -3050,3 +3057,20 @@ class WKVGrad(Primitive):
         """Initialize WKVGrad."""
         self.init_prim_io_names(inputs=["time_first", "time_decay", "key", "value", "gy"],
                                 outputs=["gw", "gu", "gk", "gv"])
+
+
+class RmsNormGrad(Primitive):
+    r"""
+    Calculates the gradient of RmsNorm operation.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize RmsNormGrad."""
+        self.init_prim_io_names(inputs=["dy", "x", "rstd", "gamma"],
+                                outputs=["dx", "dgamma"])

mindspore/ops/operations/_inner_ops.py

@@ -14,6 +14,7 @@
 # ============================================================================
 
 """Inner operators."""
+# pylint: disable=unused-import
 from types import FunctionType, MethodType
 from collections.abc import Iterable
 import os
@@ -24,6 +25,7 @@ from mindspore.common._stub_tensor import StubTensor
 from mindspore.ops import composite as C
 from mindspore.ops.operations.array_ops import Cast
 from mindspore.ops.operations._scalar_ops import bit_or, bit_and
+from mindspore.ops.operations.comm_ops import ReduceOp
 from mindspore.ops import signature as sig
 from mindspore.ops.operations.math_ops import _infer_shape_reduce
 from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register, Primitive, \
@@ -37,8 +39,8 @@ from mindspore.communication.management import GlobalComm, get_rank, _get_group,
 from mindspore.common.api import _pynative_executor
 from mindspore.common._register_for_adapter import ms_adapter_registry
 from mindspore import ops
-from ..auto_generate import TensorCopySlices, SiLU, Cummin, TopKRouter, ExtractImagePatches, DecoderKVCache, \
-    PromptKVCache, ApplyCamePart1, ApplyCamePart2, ApplyCamePart3, ApplyCamePart4
+from ..auto_generate import TensorCopySlices, SiLU, Cummin, ExtractImagePatches, DecoderKVCache, PromptKVCache, \
+    ApplyCamePart1, ApplyCamePart2, ApplyCamePart3, ApplyCamePart4
 
 # Bit operation
 bit_and = bit_and()
@@ -57,30 +59,6 @@ string_mul = Primitive("string_mul")
 string_getitem = Primitive("string_getitem")
 
 
-class Generator(Primitive):
-    r"""
-    Manage the state of random number generation.
-
-    Inputs:
-        - **cmd** (int) : operation to be executed.
-        - **inputs** (tuple[tensor]) : inputs for the operation.
-
-    Outputs:
-        - **seed** (Tensor): Seed for the random number generation algorithm.
-        - **offset** (Tensor): Offset of the random number sequence.
-        - **state** (Tensor): State tensor, can be used to restore current state.
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        self.add_prim_attr("side_effect_mem", True)
-
-    def __call__(self, cmd, inputs):
-        if cmd == 0:  # step cmd
-            return inputs[0], inputs[1]
-        return super().__call__(cmd, inputs)
-
-
 class Quant(PrimitiveWithInfer):
     r"""
     Returns the quantized value of input_x.
@@ -389,6 +367,229 @@ class MatrixDiagPart(PrimitiveWithInfer):
         return out_shape
 
 
+class Send(PrimitiveWithInfer):
+    """
+    Send tensors from src_rank to the specified dest_rank.
+
+    Note:
+        Send and Receive must be used in combination and have same sr_tag.
+        Send must be used between servers.
+
+    Args:
+        sr_tag (int): A required integer identifying the send/recv message tag. The message will
+                      will be received by the Receive op with the same "sr_tag".
+        dest_rank (int): A required integer identifying the destination rank.
+        group (str): The communication group to work on. Default: "hccl_world_group/nccl_world_group".
+
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Examples:
+        >>> import mindspore.ops as ops
+        >>> import mindspore.nn as nn
+        >>> from mindspore.communication import init
+        >>> from mindspore import Tensor
+        >>> import numpy as np
+        >>>
+        >>> init()
+        >>> class Net(nn.Cell):
+        >>>     def __init__(self):
+        >>>         super(Net, self).__init__()
+        >>>         self.depend = ops.Depend()
+        >>>         self.send = ops.Send(st_tag=0, dest_rank=8, group="hccl_world_group")
+        >>>
+        >>>     def construct(self, x):
+        >>>         out = self.depend(x, self.send(x))
+        >>>         return out
+        >>>
+        >>> input_ = Tensor(np.ones([2, 8]).astype(np.float32))
+        >>> net = Net()
+        >>> output = net(input_)
+    """
+
+    @prim_attr_register
+    def __init__(self, sr_tag, dest_rank, group=GlobalComm.WORLD_COMM_GROUP, group_back=GlobalComm.WORLD_COMM_GROUP):
+        self.rank = dest_rank
+        self.sr_tag = sr_tag
+        self.group = group
+        self.add_prim_attr("no_eliminate", True)
+
+    def infer_shape(self, x_shape):
+        self.add_prim_attr("shape", x_shape)
+        return x_shape
+
+    def infer_dtype(self, x_dtype):
+        return x_dtype
+
+
+class Receive(PrimitiveWithInfer):
+    """
+    Receive tensors from src_rank.
+
+    Note:
+        Send and Receive must be used in combination and have same sr_tag.
+        Receive must be used between servers.
+
+    Args:
+        sr_tag (int): A required integer identifying the send/recv message tag. The message will
+                      will be send by the Send op with the same "sr_tag".
+        src_rank (int): A required integer identifying the source rank.
+        shape (list[int]): A required list identifying the shape of the tensor to be received.
+        dtype (Type): A required Type identifying the type of the tensor to be received. The supported types:
+                       int8, int16, int32, float16, float32.
+        group (str, optional): The communication group to work on.
+            Default: "hccl_world_group" on Ascend, "nccl_world_group" on GPU.
+
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Examples:
+        >>> import mindspore.ops as ops
+        >>> import mindspore.nn as nn
+        >>> from mindspore.communication import init
+        >>> from mindspore import Tensor
+        >>> import numpy as np
+        >>>
+        >>> init()
+        >>> class Net(nn.Cell):
+        >>>     def __init__(self):
+        >>>         super(Net, self).__init__()
+        >>>         self.recv = ops.Receive(st_tag=0, src_rank=0, shape=[2, 8], dtype=np.float32,
+        >>>                               group="hccl_world_group")
+        >>>
+        >>>     def construct(self):
+        >>>         out = self.recv()
+        >>>         return out
+        >>>
+        >>> net = Net()
+        >>> output = net()
+    """
+
+    @prim_attr_register
+    def __init__(self, sr_tag, src_rank, shape, dtype, group=GlobalComm.WORLD_COMM_GROUP,
+                 group_back=GlobalComm.WORLD_COMM_GROUP):
+        self.rank = src_rank
+        self.tag = sr_tag
+        self.shape = shape
+        self.dtype = dtype
+        self.group = group
+        self.add_prim_attr("no_eliminate", True)
+        valid_type = [mstype.float16, mstype.float32, mstype.float64, mstype.bfloat16,
+                      mstype.int8, mstype.int16, mstype.int32, mstype.int64,
+                      mstype.uint8, mstype.uint16, mstype.uint32, mstype.uint64]
+        args = {"dtype": dtype}
+        validator.check_scalar_or_tensor_types_same(args, valid_type, self.name)
+
+    def infer_shape(self, x_shape=None):
+        return self.get_attr_dict()['shape']
+
+    def infer_dtype(self, x_dtype=None):
+        return self.get_attr_dict()['dtype']
+
+
+class Reduce(PrimitiveWithInfer):
+    """
+    Reduces tensor across the processes in the specified communication group.
+
+    Note:
+        Only process with destination rank receives the reduced output.
+        Other processes only get a tensor with shape [1], which has no mathematical meaning.
+
+    Args:
+        dest_rank (int): Specifies the rank of the process that receives the reduced output.
+        op (str, optional): Specifies an operation used for element-wise reductions, like sum, prod, max, and min.
+                On the CPU, only 'sum' is supported. Default: ``ReduceOp.SUM`` .
+        group (str, optional): The communication group to work on.
+            Default: "hccl_world_group" on Ascend, "nccl_world_group" on GPU.
+
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Examples:
+        >>> import mindspore.ops as ops
+        >>> import mindspore.nn as nn
+        >>> from mindspore.communication import init
+        >>> from mindspore import Tensor
+        >>> import numpy as np
+        >>> # Launch 4 processes.
+        >>> init()
+        >>> class ReduceNet(nn.Cell):
+        >>>     def __init__(self):
+        >>>         super(Net, self).__init__()
+        >>>         self.reduce = ops.Reduce(dest_rank=1)
+        >>>
+        >>>     def construct(self, x):
+        >>>         out = self.reduce(x)
+        >>>         return out
+        >>> input = Tensor(np.ones([2, 8]).astype(np.float32))
+        >>> net = ReduceNet()
+        >>> output = net(input)
+        >>> print(output)
+        Process with rank 1: [[4. 4. 4. 4. 4. 4. 4. 4.]
+                             [4. 4. 4. 4. 4. 4. 4. 4.]],
+        Other proesses: [0.].
+    """
+
+    @prim_attr_register
+    def __init__(self, dest_rank, op=ReduceOp.SUM, group=GlobalComm.WORLD_COMM_GROUP):
+        self.dest_rank = dest_rank
+        self.op = op
+        self.group = group
+
+    def infer_shape(self, x_shape):
+        # The process with dest_rank returns the reduced output.
+        # Other processes only gets a tensor with shape [1], which has no mathematical meaning.
+        if self.dest_rank == get_rank():
+            return x_shape
+        return [1]
+
+    def infer_dtype(self, x_dtype):
+        return x_dtype
+
+
+class Barrier(PrimitiveWithInfer):
+    """
+    Synchronizes all processes in the specified group.
+
+    Note:
+        After calling this collective operator,
+        this process will be blocked until all other processes in the group call this operator.
+
+    Args:
+        group (str, optional): The communication group to work on.
+            Default: "hccl_world_group" on Ascend, "nccl_world_group" on GPU.
+
+    Examples:
+        >>> import mindspore.ops as ops
+        >>> import mindspore.nn as nn
+        >>> from mindspore.communication import init
+        >>> from mindspore import Tensor
+        >>> import numpy as np
+        >>> # Launch 4 processes.
+        >>> init()
+        >>> class BarrierNet(nn.Cell):
+        >>>     def __init__(self):
+        >>>         super(Net, self).__init__()
+        >>>         self.barrier = ops.Barrier()
+        >>>
+        >>>     def construct(self):
+        >>>         self.barrier()
+        >>> net = BarrierNet()
+        >>> net()
+    """
+
+    @prim_attr_register
+    def __init__(self, group=GlobalComm.WORLD_COMM_GROUP):
+        self.group = group
+        self.add_prim_attr("side_effect_mem", True)
+
+    def infer_shape(self):
+        return [1]
+
+    def infer_dtype(self):
+        return mstype.float32
+
+
 class MatrixSetDiag(PrimitiveWithInfer):
     r"""
     Modifies the batched diagonal part of a batched tensor.
@@ -2469,15 +2670,67 @@ class FFN(Primitive):
     def __init__(self, activation, inner_precise):
         """Initialize FFN."""
         self.init_prim_io_names(inputs=["x", "weight1", "weight2", "expert_tokens", "bias1",
-                                        "bias2", "scale", "offset", "deq_scale1", "deq_scale2",
-                                        "antiquant_scale1", "antiquant_scale2",
-                                        "antiquant_offset1", "antiquant_offset2"],
+                                        "bias2", "scale", "offset", "deq_scale1", "deq_scale2"],
                                 outputs=["y"])
         cls_name = self.name
         validator.check_value_type("activation", activation, [str], cls_name)
         validator.check_value_type("inner_precise", inner_precise, [int], cls_name)
 
 
+class CollectiveScatter(Primitive):
+    """
+    Scatter tensor across the processes in the specified communication group.
+
+    Note:
+        Collect communication domain scatter operation interface.
+        Distribute the tensors of the specified rank evenly to each rank.
+
+    Args:
+        src_rank (int): Specifies the rank of the process that send the tensor.
+        group (str, optional): The communication group to work on.
+            Default: "hccl_world_group" on Ascend, "nccl_world_group" on GPU.
+
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore.nn as nn
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore.communication.management import init, get_rank
+        >>> from mindspore.ops.operations import _inner_ops as inner_p
+        >>> # Launch 4 processes.
+        >>> init()
+        >>> class CollectiveScatterNet(nn.Cell):
+        >>>     def __init__(self):
+        >>>         super(self).__init__()
+        >>>         self.collective_scatter = inner_p.CollectiveScatter(src_rank=0)
+        >>>
+        >>>     def construct(self, x):
+        >>>         out = self.collective_scatter(x)
+        >>>         return out
+        >>> input = Tensor(np.ones([8, 8]).astype(np.float32))
+        >>> net = CollectiveScatterNet()
+        >>> output = net(input)
+        >>> print(output)
+        Process with all rank : [[1. 1. 1. 1. 1. 1. 1. 1.]
+                                [1. 1. 1. 1. 1. 1. 1. 1.]],
+    """
+
+    @prim_attr_register
+    def __init__(self, src_rank=0, group=GlobalComm.WORLD_COMM_GROUP):
+        validator.check_value_type('group', _get_group(group), (str,), self.name)
+        self.rank_size = get_group_size(_get_group(group))
+        self.src_rank = src_rank
+
+        self.add_prim_attr('src_rank', self.src_rank)
+        self.add_prim_attr('rank_size', self.rank_size)
+        self.add_prim_attr('group', _get_group(group))
+
+
 class _MirrorSilentCheck(PrimitiveWithInfer):
     """
     The operator _MirrorSilentCheck implements accuracy-sensitive detection on the tensor input in backpropagator.
@@ -2532,36 +2785,86 @@ class _MirrorSilentCheck(PrimitiveWithInfer):
         return x_dtype
 
 
-class _VirtualConverterEnd(PrimitiveWithInfer):
-    """
-    Auto parallel virtual operator.
+class CollectiveGather(Primitive):
     """
+    Gathers tensors from the specified communication group.
 
-    @prim_attr_register
-    def __init__(self, input_nums):
-        """Initialize _VirtualConverterEnd."""
-        self.input_nums = input_nums
+    Note:
+        Implement the gatherer operation interface.
+        Combine all tensors of the rank in order of rank, and then send the results to the target rank.
 
-    def infer_shape(self, *args):
-        return (args[0][0] * self.input_nums,) + tuple(args[0][1:])
+    Args:
+        group (str): The communication group to work on. Default: ``GlobalComm.WORLD_COMM_GROUP`` , which
+            means ``"hccl_world_group"`` in Ascend, and ``"nccl_world_group"`` in GPU.
 
-    def infer_dtype(self, *args):
-        return args[0]
+    Inputs:
+        - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
+    Outputs:
+        Tensor. If the number of devices in the group is N,
+        then the shape of output is :math:`(N, x_1, x_2, ..., x_R)`.
 
-class _VirtualConverterBegin(PrimitiveWithInfer):
-    """
-    Auto parallel virtual operator.
-    """
+    Raises:
+        TypeError: If `group` is not a str.
+        ValueError: If the local rank id of the calling process in the group
+                    is larger than the group's rank size.
 
-    @prim_attr_register
-    def __init__(self, output_nums):
-        """Initialize _VirtualConverterBegin."""
-        self.output_nums = output_nums
+    Supported Platforms:
+        ``Ascend``
 
-    def infer_shape(self, arg):
-        new_arg = (arg[0] / self.output_nums,) + tuple(arg[1:])
-        return (new_arg,) * self.output_nums
+    Examples:
+        .. note::
+            Before running the following examples, you need to configure the communication environment variables.
+
+            For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/rank_table.html>`_
+            for more details.
+
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/master/parallel/dynamic_cluster.html>`_ .
+
+            This example should be run with 4 devices.
 
-    def infer_dtype(self, arg):
-        return (arg,) * self.output_nums
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> import mindspore.nn as nn
+        >>> from mindspore.communication import init
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.operations import _inner_ops as inner_p
+        >>>
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> init()
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.collective_gather = inner_p.CollectiveGather(dest_rank=0)
+        ...
+        ...     def construct(self, x):
+        ...         return self.collective_gather(x)
+        ...
+        >>> input_x = Tensor(np.ones([1, 8]).astype(np.float32))
+        >>> net = Net()
+        >>> output = net(input_x)
+        >>> print(output)
+        [[1. 1. 1. 1. 1. 1. 1. 1.]
+         [1. 1. 1. 1. 1. 1. 1. 1.]
+         [1. 1. 1. 1. 1. 1. 1. 1.]
+         [1. 1. 1. 1. 1. 1. 1. 1.]]
+    """
+
+    @prim_attr_register
+    def __init__(self, dest_rank, group=GlobalComm.WORLD_COMM_GROUP):
+        """Initialize Gather."""
+        validator.check_value_type('group', _get_group(group), (str,), self.name)
+        self.rank_id = get_rank(_get_group(group))
+        self.dest_rank = dest_rank
+        self.rank_size = get_group_size(_get_group(group))
+        validator.check('rank', self.rank_id, 'rank_size', self.rank_size, validator.LT, self.name)
+        self.add_prim_attr('rank_size', self.rank_size)
+        self.add_prim_attr('group', _get_group(group))
+        self.add_prim_attr('dest_rank', self.dest_rank)
+        self.add_prim_attr('rank_id', self.rank_id)

mindspore/ops/operations/_rl_inner_ops.py

@@ -1132,7 +1132,7 @@ class MuxSend(PrimitiveWithInfer):
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor
@@ -1190,7 +1190,7 @@ class MuxReceive(PrimitiveWithInfer):
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor

mindspore/ops/operations/_tensor_array.py

@@ -46,7 +46,7 @@ class TensorArray(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> print(handle)
@@ -90,7 +90,7 @@ class TensorArrayWrite(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> write_op = ops.TensorArrayWrite()
@@ -133,7 +133,7 @@ class TensorArrayRead(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> write_op = ops.TensorArrayWrite()
@@ -179,7 +179,7 @@ class TensorArrayClose(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> close_op = ops.TensorArrayClose()
@@ -215,7 +215,7 @@ class TensorArrayClear(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> clear_op = ops.TensorArrayClear()
@@ -255,7 +255,7 @@ class TensorArrayStack(Primitive):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> write_op = ops.TensorArrayWrite()
@@ -295,7 +295,7 @@ class TensorArraySize(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> size_op = ops.TensorArraySize()
@@ -333,7 +333,7 @@ class TensorArrayGather(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import numpy as mnp
         >>> create_op = ops.TensorArray(mindspore.float32, dynamic_size=False, element_shape=(8,))
         >>> handle = create_op()