mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

mindspore/ops/function/other_func.py

@@ -14,7 +14,7 @@
 # ============================================================================
 """Defines other operators with functional form."""
 from mindspore.ops import operations as P
-
+from mindspore.ops.auto_generate import rotary_position_embedding
 
 partial_ = P.Partial()
 depend_ = P.Depend()
@@ -109,6 +109,7 @@ def depend(value, expr):
 
 __all__ = [
     'depend',
-    'partial'
+    'partial',
+    'rotary_position_embedding'
 ]
 __all__.sort()

mindspore/ops/function/random_func.py

@@ -30,7 +30,7 @@ from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import randperm
 from mindspore.common.generator import default_generator
 from mindspore.ops.auto_generate import UniformExt, NormalTensorTensor, \
-    NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt
+    NormalTensorFloat, NormalFloatTensor, NormalFloatFloat, RandExt, RandLikeExt, MultinomialExt
 
 normal_tensor_tensor_op = NormalTensorTensor()
 normal_tensor_float_op = NormalTensorFloat()
@@ -45,6 +45,7 @@ top_k_ = P.TopK()
 uniform_ = UniformExt()
 rand_ext_ = RandExt()
 rand_like_ext_ = RandLikeExt()
+multinomial_ext_ = MultinomialExt()
 generator_step_ = Tensor(10, mstype.int64)
 
 
@@ -116,14 +117,18 @@ def standard_laplace(shape, seed=None):
     .. math::
         \text{f}(x) = \frac{1}{2}\exp(-|x|)
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (Union[tuple, Tensor]): The shape of random tensor to be generated. Only constant value is allowed
           when the input type is tuple. And the operator supports dynamic shape only when the input type is Tensor.
         seed (int, optional): Seed is used as entropy source for Random number engines generating pseudo-random numbers.
-          Default: ``None`` , which will be treated as 0.
+          Default: ``None`` .
 
     Returns:
-        Tensor. The shape that the input 'shape' denotes. The dtype is float32.
+        Tensor. The shape that the input `shape` denotes. The dtype is float32.
 
     Raises:
         TypeError: If shape is neither a tuple nor a Tensor.
@@ -153,6 +158,10 @@ def random_categorical(logits, num_sample, seed=0, dtype=mstype.int64):
     r"""
     Generates random samples from a given categorical distribution tensor.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         logits (Tensor): The input tensor. 2-D Tensor with shape :math:`(batch\_size, num\_classes)`.
         num_sample (int):  Number of sample to be drawn. Only constant values is allowed.
@@ -374,6 +383,10 @@ def standard_normal(shape, seed=None):
     .. math::
         f(x)=\frac{1}{\sqrt{2 \pi}} e^{\left(-\frac{x^{2}}{2}\right)}
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (Union[tuple, Tensor]): The shape of random tensor to be generated. Only constant value is allowed
           when the input type is tuple. And the operator supports dynamic shape only when the input type is Tensor.
@@ -419,8 +432,14 @@ def uniform_candidate_sampler(true_classes,
     This function samples a set of classes(sampled_candidates) from [0, range_max-1] based on uniform distribution.
     If unique=True, candidates are drawn without replacement, else unique=False with replacement.
 
+    .. warning::
+        - The Ascend backend does not support the reproducibility of random numbers, so
+          the `seed` parameter has no effect.
+        - The Ascend backend does not support dynamic shape scenarios currently.
+
     Args:
         true_classes (Tensor): A Tensor. The target classes with a Tensor shape of :math:`(batch\_size, num\_true)` .
+            The value range of the elements must be :math:`[0, range\_max)`.
         num_true (int): The number of target classes in each training example.
         num_sampled (int): The number of classes to randomly sample. The sampled_candidates will have a shape
             of num_sampled. If unique=True, num_sampled must be less than or equal to range_max.
@@ -483,11 +502,15 @@ def random_poisson(shape, rate, seed=None, dtype=mstype.float32):
 
         \text{P}(i|μ) = \frac{\exp(-μ)μ^{i}}{i!}
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (Tensor): The shape of random tensor to be sampled from each poisson distribution, 1-D `Tensor` whose
             dtype is mstype.int32 or mstype.int64.
         rate (Tensor): The :math:`μ` parameter the distribution is constructed with.
-            It represents the mean of the distribution
+            It represents the mean of poisson distribution
             and also the variance of the distribution. It should be a `Tensor` whose dtype is mstype.int64,
             mstype.int32, mstype.float64, mstype.float32 or mstype.float16.
         seed (int, optional): Seed is used as entropy source for the random number engines to generate pseudo-random
@@ -582,6 +605,10 @@ def log_uniform_candidate_sampler(true_classes, num_true=1, num_sampled=5, uniqu
 
     Randomly samples a tensor of sampled classes from the range of integers [0, range_max).
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         true_classes (Tensor): The target classes. With data type of int64 and
           shape :math:`(batch\_size, num\_true)` .
@@ -640,12 +667,16 @@ def choice_with_mask(input_x, count=256, seed=None):
     The returned index tensor denotes the index of the nonzero
     sample, the mask tensor denotes which elements in the index tensor are valid.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input_x (Tensor[bool]): The input tensor.
             The input tensor rank must be greater than or equal to 1 and less than or equal to 5.
         count (int, optional): Number of items expected to get and the number must be greater than 0. Default: ``256`` .
         seed (int, optional): Seed is used as entropy source for Random number engines generating pseudo-random numbers.
-            Default: ``None`` , which will be treated as 0.
+            Default: ``None`` .
 
     Returns:
         Two tensors, the first one is the index tensor and the other one is the mask tensor.
@@ -743,6 +774,10 @@ def normal(shape, mean, stddev, seed=None):
     """
     Generates random numbers according to the Normal (or Gaussian) random number distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (tuple): The shape of random tensor to be generated.
           The format is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
@@ -809,6 +844,10 @@ def laplace(shape, mean, lambda_param, seed=None):
     .. math::
         \text{f}(x;μ,λ) = \frac{1}{2λ}\exp(-\frac{|x-μ|}{λ}),
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (tuple): The shape of random tensor to be generated.
           The format is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
@@ -856,12 +895,16 @@ def gamma(shape, alpha, beta, seed=None):
     r"""
     Generates random numbers according to the Gamma random number distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         shape (tuple): The shape of random tensor to be generated.
         alpha (Tensor): The :math:`\alpha` distribution parameter. It should be greater than 0 with float32 data type.
         beta (Tensor): The :math:`\beta` distribution parameter. It should be greater than 0 with float32 data type.
         seed (int, optional): Seed is used as entropy source for the random number engines to generate
-            pseudo-random numbers, must be non-negative. Default: ``None`` , which will be treated as ``0`` .
+            pseudo-random numbers, must be non-negative. Default: ``None`` .
 
     Returns:
         Tensor. The shape should be equal to the broadcasted shape between the input `shape` and shapes
@@ -959,6 +1002,10 @@ def rand(*size, dtype=None, seed=None):
     Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
     based on the given shape and dtype.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)` or :math:`2`.
 
@@ -1003,6 +1050,10 @@ def rand_like(input, seed=None, *, dtype=None):
     Returns a new tensor that fills numbers from the uniform distribution over an interval :math:`[0, 1)`
     based on the given shape and dtype.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and ``0`` will be used.
@@ -1072,7 +1123,7 @@ def rand_ext(*size, generator=None, dtype=None):
         ``Ascend``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> print(ops.function.random_func.rand_ext(2, 3).shape)
         (2, 3)
     """
@@ -1122,6 +1173,10 @@ def randn(*size, dtype=None, seed=None):
     Returns a new Tensor with given shape and dtype, filled with a sample (or samples)
     from the standard normal distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g., :math:`(2, 3)` or :math:`2`.
 
@@ -1167,6 +1222,10 @@ def randn_like(input, seed=None, *, dtype=None):
     Returns a new Tensor with given shape and dtype, filled with a sample (or samples) from the standard normal
     distribution.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         seed (int, optional): Random seed, must be greater or equal to 0. Default: ``None`` , and 0 will be used.
@@ -1215,6 +1274,10 @@ def randint(low, high, size, seed=None, *, dtype=None):
     r"""
     Returns a Tensor whose elements are random integers in the range of [ `low` , `high` ) .
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         low (int): Start value of interval.
         high (int): End value of interval.
@@ -1274,6 +1337,10 @@ def randint_like(input, low, high, seed=None, *, dtype=None):
     Returns a tensor with the same shape as Tensor `input` whose elements are random integers in the range
     of [ `low` , `high` ) .
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): Input Tensor to specify the output shape and its default dtype.
         low(int): Start value of interval.
@@ -1418,6 +1485,10 @@ def multinomial(input, num_samples, replacement=True, seed=None):
         but must be non-negative, finite and have a non-zero sum. When using values as weights, it can be understood as
         normalizing the input along the last dimension.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         input (Tensor): The input tensor containing probabilities, must be 1 or 2 dimensions, with
           float32 data type.
@@ -1428,7 +1499,7 @@ def multinomial(input, num_samples, replacement=True, seed=None):
 
     Returns:
         Tensor, has the same rows with input. The number of sampled indices of each row is `num_samples`.
-        The dtype is float32.
+        The dtype is int32.
 
     Raises:
         TypeError: If `input` is not a Tensor whose dtype is not float32.
@@ -1506,6 +1577,111 @@ def multinomial(input, num_samples, replacement=True, seed=None):
     return random_nomial(input, num_samples)
 
 
+@_function_forbid_reuse
+def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
+    r"""
+    Returns a tensor sampled from the multinomial probability distribution located in the corresponding
+    row of the input tensor.
+
+    The polynomial distribution is a probability distribution that generalizes the binomial distribution formula to
+    multiple states. In the polynomial distribution, each event has a fixed probability, and the sum of these
+    probabilities is 1. The purpose of the `mindspore.mint.multinomial` interface is to perform `num_samples` sampling
+    on the input `input`, and the output tensor is the index of the input tensor for each sampling.
+    The values in `input` represent the probability of selecting the corresponding index for each sampling.
+
+    Here is an extreme example for better understanding. Suppose we have an input probability tensor with
+    values `Tensor([90 / 100, 10 / 100, 0], mindspore.float32)`, which means we can sample three indices,
+    namely index 0, index 1, and index 2, with probabilities of 90%, 10%, and 0%, respectively. We perform n samplings,
+    and the resulting sequence is the calculation result of the polynomial distribution, with a length equal to the
+    number of samplings.
+
+    In case 1 of the sample code, we perform two non-replacement samplings (`replacement` is `False`).
+    The calculation result is most likely `[0, 1]`, and less likely `[1, 0]`. Since the probability of selecting
+    index 0 is 90% for each sampling, the first result is most likely to be index 0. Since the probability of selecting
+    index 2 is 0, index 2 cannot appear in the sampling result. Therefore, the second result must be index 1,
+    and the resulting sequence is `[0, 1]`.
+
+    In case 2 of the sample code, we perform 10 replacement samplings (`replacement` is `True`).
+    As expected, about 90% of the sampling results are index 0.
+
+    In case 3 of the sample code, we extend the input to 2 dimensions, and the sampling results
+    in each dimension also match our sampling expectations.
+
+    Note:
+        The rows of input do not need to sum to one (in which case we use the values as weights),
+        but must be non-negative, finite and have a non-zero sum.
+        When using values as weights, it can be understood as normalizing the input along the last dimension.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor containing probabilities, must be 1 or 2 dimensions, with float32 data type.
+        num_samples (int): Number of samples to draw.
+        replacement (bool, optional): Whether to draw with replacement or not. Default: ``False`` .
+
+    Keyword Args:
+        generator (generator, optional): MindSpore generator. Default: ``None``.
+
+    Returns:
+        Tensor, dtype is Int64.
+        If `input` is a vector, out is a vector of size `num_samples`.
+        If `input` is a matrix with m rows, out is an matrix of shape(m * num_samples).
+
+    Raises:
+        TypeError: If `input` is not a Tensor whose dtype is not in float16, float32, float64 or bfloat16.
+        , 或是shape为(1, 1)的Tensor
+        TypeError: If `num_samples` is not an int, a Scalar of int
+            or a Tensor with shape[1,] and only one int element.
+        RuntimeError: If :math:`\text{num_samples} <= 0`.
+        RuntimeError: If `replacement` is False, :math:`\text{num_samples} > shape` of the last dimension of `input`.
+        RuntimeError: If shape of the last dimension of `input` exceeds ``2^24``.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> # case 1: The output is random, and the length of the output is the same as num_sample.
+        >>> # replacement is False.
+        >>> input1 = Tensor([90 / 100, 10 / 100, 0], mindspore.float32)
+        >>> input2 = Tensor([90, 10, 0], mindspore.float32)
+        >>> # input1 and input2 have the same meaning.
+        >>> output1 = ops.multinomial_ext(input1, 2)
+        >>> output2 = ops.multinomial_ext(input2, 2)
+        >>> # print(output1)
+        >>> # [0 1]
+        >>> # print(output2)
+        >>> # [0 1]
+        >>> print(len(output1))
+        2
+        >>> print(len(output2))
+        2
+        >>> # case 2: The output is random, and the length of the output is the same as num_sample.
+        >>> # replacement is True.
+        >>> output3 = ops.multinomial_ext(input1, 10, replacement=True)
+        >>> # print(output3)
+        >>> # [0 0 1 0 0 0 0 0 0 0]
+        >>> print(len(output3))
+        10
+        >>> # case 3: The output is random, and the length of the output is the same as num_sample.
+        >>> # replacement is True.
+        >>> # rank is 2
+        >>> input4 = Tensor([[90, 10, 0], [10, 90, 0]], mstype.float32)
+        >>> output4 = ops.multinomial_ext(input4, 10, replacement=True)
+        >>> # print(output4)
+        >>> # [[0 0 0 0 0 0 0 0 1 0]
+        >>> #  [1 1 1 1 1 0 1 1 1 1]]
+    """
+
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return multinomial_ext_(input, num_samples, replacement, seed, offset)
+
+
 def _check_shape(input_shape):
     """Check 'shape' value."""
     if not isinstance(input_shape, tuple):

mindspore/ops/function/reshard_func.py

@@ -35,6 +35,8 @@ def reshard(tensor, layout):
           "sharding_propagation".
         - In the semi-auto parallel mode, the parallel mode will automatically switch to auto
           parallel mode with the search mode be set to "sharding_propagation".
+        - Currently, configuring multi-dimension and multi-copy reshard strategy in
+          mindspore.Layout is not supported.
 
     Args:
         tensor (Tensor): The tensor to be set the sharding strategy.
@@ -55,18 +57,18 @@ def reshard(tensor, layout):
         >>> from mindspore import ops, nn, Tensor, context, Layout
         >>> context.set_context(mode=ms.GRAPH_MODE)
         >>> context.set_auto_parallel_context(parallel_mode=ms.ParallelMode.AUTO_PARALLEL,
-        >>>                                   search_mode="sharding_propagation")
+        ...                                   search_mode="sharding_propagation")
         >>> class Network(nn.Cell):
-        >>>     def __init__(self):
-        >>>         super().__init__()
-        >>>         self.matmul = ops.MatMul()
-        >>>         self.relu = ops.ReLU()
-        >>>     def construct(self, x, layout):
-        >>>         x = self.relu(x)
-        >>>         x_reshard = ops.reshard(x, self.layout)
-        >>>         y = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
-        >>>         x = self.matmul(x_reshard, y)
-        >>>         return x
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.matmul = ops.MatMul()
+        ...         self.relu = ops.ReLU()
+        ...     def construct(self, x, layout):
+        ...         x = self.relu(x)
+        ...         x_reshard = ops.reshard(x, layout)
+        ...         y = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
+        ...         x = self.matmul(x_reshard, y)
+        ...         return x
         >>>
         >>> layout = Layout((4, 2), ("dp", "mp"))
         >>> input_layout = layout("dp", "mp")

mindspore/ops/function/sparse_unary_func.py

@@ -375,7 +375,7 @@ def coo_relu(x: COOTensor) -> COOTensor:
     Args:
         x (COOTensor): Input COOTensor with shape :math:`(N, *)`, where :math:`*`
             means any number of additional dimensions. Its dtype is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         COOTensor, has the same shape and dtype as the `x`.

mindspore/ops/function/vmap_func.py

@@ -27,8 +27,9 @@ def vmap(fn, in_axes=0, out_axes=0):
     Vmap is pioneered by Jax and it removes the restriction of batch dimension on the operator, and provides a
     more convenient and unified operator expression. Moreover, it allows users to composite with other functional
     modules such as :func:`mindspore.grad`, to improve the development efficiency, please refer to the
-    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/tutorials/experts/en/master/vmap/vmap.html>`_ tutorial
-    for more detail. In addition, the vectorizing map does not execute loops outside the function, but sinks loops
+    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/docs/en/master/model_train/train_process/optimize/vmap.html>`_
+    tutorial for more detail.
+    In addition, the vectorizing map does not execute loops outside the function, but sinks loops
     into the primitive operations of the function for better performance. When combined with `Graph Kernel Fusion`,
     operational efficiency would be further improved.
 

mindspore/ops/functional.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-2024 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.
@@ -19,7 +19,7 @@
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
-from mindspore.ops.function.array_func import narrow, flatten
+from mindspore.ops.function.array_func import chunk_ext, zero_
 from mindspore.ops.function.math_func import all, argmax_ext
 from mindspore.ops.function.random_func import uniform_ext
 from mindspore.ops import operations as P
@@ -34,14 +34,15 @@ from mindspore.ops.operations.math_ops import Roll
 from mindspore.ops.composite.math_ops import mm
 from mindspore.ops.function.math_func import dot
 from mindspore.ops import auto_generate
+from mindspore.ops.auto_generate import cast
 from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum
-from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul,\
-    scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow,\
+from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul, \
+    scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow, \
     scalar_uadd, scalar_usub, flash_attention_score
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')
-cast = P.Cast()
+_cast = P.Cast()
 dtype = P.DType()
 isconstant = _inner_ops.IsConstant()
 isconstant.set_const_prim(True)
@@ -116,7 +117,8 @@ reduced_shape = Primitive("reduced_shape")
 # shape_mul:input must be shape multiply elements in tuple(shape)
 shape_mul = _sequence_ops.shape_mul()
 
-setattr(tensor_operator_registry, 'tuple_to_tensor', _sequence_ops.TupleToTensor)
+setattr(tensor_operator_registry, 'tuple_to_tensor',
+        _sequence_ops.TupleToTensor)
 setattr(tensor_operator_registry, 'add', add)
 setattr(tensor_operator_registry, 'softmax', softmax)
 setattr(tensor_operator_registry, 'addr', addr)
@@ -136,6 +138,7 @@ setattr(tensor_operator_registry, 'rsqrt', rsqrt)
 setattr(tensor_operator_registry, 'bincount', bincount)
 setattr(tensor_operator_registry, 'slogdet', slogdet)
 setattr(tensor_operator_registry, 'trace', trace)
+setattr(tensor_operator_registry, 'tracev2', auto_generate.trace_v2_op)
 setattr(tensor_operator_registry, 'tril', tril)
 setattr(tensor_operator_registry, 'chunk', chunk)
 setattr(tensor_operator_registry, 'count_nonzero', count_nonzero)
@@ -210,7 +213,8 @@ setattr(tensor_operator_registry, 'dot', dot)
 setattr(tensor_operator_registry, 'outer', outer)
 setattr(tensor_operator_registry, 'log1p', log1p)
 setattr(tensor_operator_registry, 'logdet', logdet)
-setattr(tensor_operator_registry, 'log_matrix_determinant', log_matrix_determinant)
+setattr(tensor_operator_registry,
+        'log_matrix_determinant', log_matrix_determinant)
 setattr(tensor_operator_registry, 'matrix_determinant', matrix_determinant)
 setattr(tensor_operator_registry, 'ceil', ceil)
 setattr(tensor_operator_registry, 'fillv2', P.FillV2)
@@ -223,6 +227,7 @@ setattr(tensor_operator_registry, 'vsplit', vsplit)
 setattr(tensor_operator_registry, 'hsplit', hsplit)
 setattr(tensor_operator_registry, 'dsplit', dsplit)
 setattr(tensor_operator_registry, 'zeros_like', zeros_like)
+setattr(tensor_operator_registry, 'zero_', zero_)
 setattr(tensor_operator_registry, 'scalar_to_tensor', scalar_to_tensor)
 setattr(tensor_operator_registry, 'stop_gradient', stop_gradient)
 setattr(tensor_operator_registry, 'masked_fill', masked_fill)
@@ -264,6 +269,7 @@ setattr(tensor_operator_registry, 'tanh', tanh)
 setattr(tensor_operator_registry, 'exp', exp)
 setattr(tensor_operator_registry, 'addbmm', addbmm)
 setattr(tensor_operator_registry, 'addmm', addmm)
+setattr(tensor_operator_registry, 'addmm_', auto_generate.inplace_addmm_op)
 setattr(tensor_operator_registry, 'addmv', addmv)
 setattr(tensor_operator_registry, 'adjoint', adjoint)
 setattr(tensor_operator_registry, 'asinh', asinh)
@@ -314,7 +320,7 @@ setattr(tensor_operator_registry, 'unsqueeze', unsqueeze)
 setattr(tensor_operator_registry, 'expand_dims', expand_dims)
 setattr(tensor_operator_registry, 'contiguous', auto_generate.contiguous)
 # support GE backend for no compare operators
-setattr(tensor_operator_registry, 'cast', cast)
+setattr(tensor_operator_registry, 'cast', _cast)
 setattr(tensor_operator_registry, 'shape_mul', shape_mul)
 setattr(tensor_operator_registry, 'concatenate', concat)
 setattr(tensor_operator_registry, 'fill', fill)
@@ -392,12 +398,13 @@ setattr(tensor_operator_registry, 'argwhere', argwhere)
 setattr(tensor_operator_registry, 'coo_add', coo_add)
 setattr(tensor_operator_registry, 'topk', topk)
 setattr(tensor_operator_registry, 'isfinite', isfinite)
-setattr(tensor_operator_registry, 'to', cast)
-setattr(tensor_operator_registry, 'bool', cast)
-setattr(tensor_operator_registry, 'float', cast)
-setattr(tensor_operator_registry, 'half', cast)
-setattr(tensor_operator_registry, 'int', cast)
-setattr(tensor_operator_registry, 'long', cast)
+setattr(tensor_operator_registry, 'to', _cast)
+setattr(tensor_operator_registry, 'bool', _cast)
+setattr(tensor_operator_registry, 'float', _cast)
+setattr(tensor_operator_registry, 'half', _cast)
+setattr(tensor_operator_registry, 'int', _cast)
+setattr(tensor_operator_registry, 'long', _cast)
+setattr(tensor_operator_registry, 'byte', _cast)
 setattr(tensor_operator_registry, 'cholesky', cholesky)
 setattr(tensor_operator_registry, 'cholesky_inverse', cholesky_inverse)
 setattr(tensor_operator_registry, 'cholesky_solve', cholesky_solve)
@@ -440,6 +447,9 @@ setattr(tensor_operator_registry, 'imag', imag)
 setattr(tensor_operator_registry, 'repeat_interleave', repeat_interleave)
 setattr(tensor_operator_registry, 'rad2deg', rad2deg)
 setattr(tensor_operator_registry, 'deg2rad', deg2rad)
+setattr(tensor_operator_registry, 'copy_', auto_generate.copy_ext)
+setattr(tensor_operator_registry, 'add_', auto_generate.inplace_add_ext)
+setattr(tensor_operator_registry, 'adds_', auto_generate.inplace_adds_ext)
 setattr(tensor_operator_registry, 'copysign', copysign)
 setattr(tensor_operator_registry, 'roll', Roll)
 setattr(tensor_operator_registry, 'rot90', rot90)

mindspore/ops/op_info_register.py

@@ -82,7 +82,7 @@ class _CustomInstaller:
         for dir_name in dir_names:
             if not os.path.isdir(dir_name):
                 try:
-                    os.makedirs(dir_name, exist_ok=True)
+                    os.makedirs(dir_name, mode=0o700, exist_ok=True)
                 except OSError as err:
                     if err.errno == 17:  # File exists
                         pass
@@ -121,7 +121,7 @@ class _CustomInstaller:
 
     def _find_ai_cpu_so_path(self, so_file):
         """find the absolute path of so"""
-        current_path = os.path.dirname(os.path.abspath(__file__))
+        current_path = os.path.dirname(os.path.realpath(__file__))
         search_paths = [current_path + "/../lib", current_path + "/../lib/plugin/ascend"]
         for path in search_paths:
             so_path = os.path.join(path, so_file)
@@ -235,7 +235,7 @@ class _CustomInstaller:
             # generate and copy reg info file
             op_info = self._gen_ai_core_reg_info(imply_path, self.func.__name__)
             self._copy_file(imply_path, self.ai_core_impl_dir)
-            for arc_name in ["ascend910", "ascend910b", "ascend910c", "ascend310p"]:
+            for arc_name in ["ascend910", "ascend910b", "ascend910_93", "ascend310p"]:
                 arc_dir = os.path.join(self.ai_core_config_dir, arc_name)
                 _CustomInstaller._create_dir(arc_dir)
                 self._save_op_info(arc_dir, "aic-{}-ops-info.json".format(arc_name), op_info)

mindspore/ops/operations/__init__.py

@@ -96,7 +96,7 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      InstanceNorm,
                      GeLU, FastGeLU, Elu, CeLU,
                      GetNext, L2Normalize, LayerNorm, L2Loss, CTCLoss, CTCLossV2, CTCLossV2Grad, CTCGreedyDecoder,
-                     LogSoftmax, MaxPool3D, AvgPool3D,
+                     LogSoftmax, LogSoftmaxExt, MaxPool3D, AvgPool3D,
                      MaxPool, DataFormatDimMap,
                      AvgPool, Conv2DBackpropInput, ComputeAccidentalHits,
                      MaxPoolWithArgmaxV2, OneHot, Pad, MirrorPad, Mish, PReLU, ReLU, ReLU6,
@@ -136,6 +136,7 @@ from ..deprecated import (identity, DropoutDoMask, MaxPoolWithArgmax, DropoutGen
                           TensorAdd, InplaceUpdate, ScatterNonAliasingAdd,
                           BatchToSpaceND, Unpack, GatherV2, DynamicShape, ScalarToArray, Pack)
 from .manually_defined._inner import ScalarCast
+from .manually_defined import WhileLoop, Scan, ForiLoop
 from .reshard_ops import (Reshard)
 
 __all__ = [
@@ -203,6 +204,7 @@ __all__ = [
     'Softmax',
     'Softsign',
     'LogSoftmax',
+    'LogSoftmaxExt',
     'SoftmaxCrossEntropyWithLogits',
     'BCEWithLogitsLoss',
     'ROIAlign',
@@ -337,6 +339,9 @@ __all__ = [
     'TupleToArray',
     'GeSwitch',
     'Merge',
+    'WhileLoop',
+    'Scan',
+    'ForiLoop',
     'CheckValid',
     'BartlettWindow',
     'BlackmanWindow',