mindspore 2.3.0rc1__cp37-none-any.whl → 2.3.0rc2__cp37-none-any.whl

mindspore/ops/function/random_func.py

@@ -28,14 +28,17 @@ from mindspore.common.tensor import Tensor
 from mindspore.ops.operations.random_ops import RandomShuffle, RandomChoiceWithMask
 from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import randperm
+from mindspore.nn.generator import default_generator
+from mindspore.ops.auto_generate import UniformExt, NormalExt
 
-
+normal_ext_op = NormalExt()
 cast_ = P.Cast()
 log_ = P.Log()
 real_div_ = P.RealDiv()
 reshape_ = P.Reshape()
 shape_ = P.Shape()
 top_k_ = P.TopK()
+uniform_ = UniformExt()
 
 @constexpr
 def _set_prim_op_user_data(prim, key, value):
@@ -234,6 +237,37 @@ def multinomial_with_replacement(x, seed, offset, numsamples, replacement=False)
     return multinomial_with_replacement_(x, seed, offset)
 
 
+@_function_forbid_reuse
+def uniform_ext(tensor, a, b, generator=None):
+    """
+    Generates random numbers in the half-open interval [a, b).
+
+    Args:
+        tensor (Tensor): The origin input tensor.
+        a (float): The lower bound of the interval.
+        b (float): The upper bound of the interval.
+        generator (Generator, optional): The random seed. Default: None.
+
+    Raises:
+        TypeError: If `a` is larger than `b`.
+
+    Returns:
+        Tensor, with the same shape as tensor.
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import mindspore
+        >>> import numpy as np
+        >>> x = mindspore.ops.ones(4, 2)
+        >>> output = ops.uniform_ext(x, 1., 2.)
+        >>> print(result)
+    """
+    if generator is None:
+        generator = default_generator()
+    seed, offset = generator(1)
+    return uniform_(tensor, a, b, seed, offset)
+
+
 @_function_forbid_reuse
 def uniform(shape, minval, maxval, seed=None, dtype=mstype.float32):
     """
@@ -628,6 +662,41 @@ def is_cpu_backend():
     """Check if the CPU is used"""
     return context.get_context('device_target') == 'CPU'
 
+def normal_ext(mean, std, generator=None):
+    r"""
+    Generates random numbers according to the standard Normal (or Gaussian) random number distribution.
+
+    Args:
+        - **mean** (Union[float, Tensor]) - The mean is a tensor with the mean of each output
+          element's normal distribution.
+        - **std** (Union[float, Tensor]) - The tensor of per-element standard deviations.
+        - **generator** (Generator, optional) - Mindspore generator.
+
+    Returns:
+        - **output** (Tensor) - With the same type and shape as the 'mean'.
+
+    Raises:
+        TypeError: If `mean` or `std` is not Union[float, Tensor].
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
+        >>> mean = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> std = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> output = ops.normal_ext(mean, std)
+        >>> print(output.shape)
+        (3,)
+    """
+    if generator is None:
+        generator = default_generator()
+    seed, offset = generator(1)
+    return normal_ext_op(mean, std, seed, offset)
+
 
 @_function_forbid_reuse
 def normal(shape, mean, stddev, seed=None):
@@ -1329,9 +1398,9 @@ def _check_param(op_name, param_name, param_value):
 
 
 __all__ = [
-    'standard_laplace', 'random_categorical', 'uniform', 'standard_normal', 'random_gamma',
+    'standard_laplace', 'random_categorical', 'uniform', 'uniform_ext', 'standard_normal', 'random_gamma',
     'uniform_candidate_sampler', 'random_poisson', 'log_uniform_candidate_sampler', 'shuffle', 'choice_with_mask',
-    'normal', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like', 'randn', 'randn_like', 'randint',
-    'randint_like', 'multinomial_with_replacement', 'randperm'
+    'normal_ext', 'normal', 'laplace', 'gamma', 'poisson', 'multinomial', 'rand', 'rand_like', 'randn', 'randn_like',
+    'randint', 'randint_like', 'multinomial_with_replacement', 'randperm'
 ]
 __all__.sort()

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/r2.3.q1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
         COOTensor, has the same shape and dtype as the `x`.

mindspore/ops/function/vmap_func.py

@@ -27,7 +27,7 @@ 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/r2.3.q1/vmap/vmap.html>`_ tutorial
+    `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
     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

@@ -20,7 +20,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.math_func import all
+from mindspore.ops.function.math_func import all, argmax
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
 from mindspore.ops.operations._sequence_ops import TensorToTuple
@@ -36,7 +36,7 @@ from mindspore.ops import auto_generate
 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,\
-    scalar_uadd, scalar_usub
+    scalar_uadd, scalar_usub, flash_attention_score
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')

mindspore/ops/op_info_register.py

@@ -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"]:
+            for arc_name in ["ascend910", "ascend910b", "ascend910c", "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)
@@ -1047,11 +1047,6 @@ class CustomRegOp(RegOp):
             TypeError: If `index` is neither int nor None.
             TypeError: If `name` is neither str nor None.
             TypeError: If `param_type` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [index, name, param_type]
         key_list = ["index", "name", "paramType"]
@@ -1087,11 +1082,6 @@ class CustomRegOp(RegOp):
             TypeError: If `index` is neither int nor None.
             TypeError: If `name` is neither str nor None.
             TypeError: If `param_type` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [index, name, param_type]
         key_list = ["index", "name", "paramType"]
@@ -1115,11 +1105,6 @@ class CustomRegOp(RegOp):
 
         Raises:
             ValueError: If the size of `args` not equal to the sum of input tensors and output tensors.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         io_nums = len(self.inputs) + len(self.outputs)
         if len(args) != io_nums:
@@ -1172,11 +1157,6 @@ class CustomRegOp(RegOp):
             TypeError: If `param_type` is neither str nor None.
             TypeError: If `value_type` is neither str nor None.
             TypeError: If `default_value` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [name, param_type, value_type, default_value]
         key_list = ["name", "paramType", "type", "defaultValue"]
@@ -1198,11 +1178,6 @@ class CustomRegOp(RegOp):
 
         Raises:
             TypeError: If `target` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         if target is not None:
             self._is_string(target)
@@ -1213,11 +1188,6 @@ class CustomRegOp(RegOp):
         """
         Return the generated registration information as a dict. This function should be invoked at last on the
         `CustomRegOp` instance as shown in the above example.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.3.q1/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         op_info = {}
         for k, v in self.__dict__.items():

mindspore/ops/operations/__init__.py

@@ -22,13 +22,13 @@ A collection of operators to build neural networks or to compute functions.
 from ._embedding_cache_ops import (CacheSwapTable, UpdateCache, MapCacheIdx, SubAndFilter,
                                    MapUniform, DynamicAssign, PadAndShift)
 from ._inner_ops import (MatmulDDS, DSDMatmul, Cummin, ExtractImagePatches, SelectView, CopyWithSlice)
+from ._ms_kernel import (ms_kernel, kernel)
 from ._quant_ops import *
 from ._thor_ops import (CusBatchMatMul, CusCholeskyTrsm, CusFusedAbsMax1, CusImg2Col, CusMatMulCubeDenseLeft,
                         CusMatMulCubeFraczRightMul, CusMatMulCube, CusMatrixCombine, CusTranspose02314,
                         CusMatMulCubeDenseRight, CusMatMulCubeFraczLeftCast, NewIm2Col,
                         LoadIm2Col, UpdateThorGradient, CholeskyTrsm,
                         DetTriangle, ProdForceSeA)
-from ._ms_kernel import (ms_kernel, kernel)
 from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchToSpace,
                         BatchToSpaceNDV2, BroadcastTo, Cast, Coalesce, Concat, Cummax, DType, DepthToSpace, Diag,
                         DiagPart, EditDistance, EmbeddingLookup, ExpandDims, ExtractVolumePatches,
@@ -118,7 +118,7 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      FractionalMaxPool, FractionalMaxPool3DWithFixedKsize, FractionalMaxPoolWithFixedKsize,
                      GridSampler2D, TripletMarginLoss, UpsampleNearest3D, UpsampleTrilinear3D, PadV3, ChannelShuffle,
                      GLU, MaxUnpool3D, Pdist, RmsNorm, PagedAttention, PagedAttentionMask, ReshapeAndCache,
-                     ApplyRotaryPosEmb, MatmulQkv)
+                     ApplyRotaryPosEmb)
 from .other_ops import (Assign, IOU, BoundingBoxDecode, BoundingBoxEncode,
                         ConfusionMatrix, UpdateState, Load, StopGradient, Reusing,
                         CheckValid, Partial, Depend, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
@@ -695,7 +695,6 @@ __all__ = [
     "ReshapeAndCache",
     "ApplyRotaryPosEmb",
     "RmsNorm",
-    "MatmulQkv"
 ]
 
 __custom__ = [

mindspore/ops/operations/_grad_ops.py

@@ -34,7 +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)
+                             HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad,
+                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad)
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -1534,40 +1535,6 @@ class RandomGammaGrad(Primitive):
         self.add_prim_attr("side_effect_hidden", True)
 
 
-class UpsampleNearest3DGrad(Primitive):
-    """
-    Upsample the 3-D gradient data  with the nearest neighbor interpolation algorithm.
-
-    Note:
-        Only one of 'scales' and 'output_size' can be specified, and it is an error if both are specified.
-
-    Inputs:
-        - **dy** (Tensor) - Tensor of shape [N, C, D, H, W], Must be one of the following types:
-            float16, float32, float64.
-        - **input_size** (listInt): An required listInt, which contain 5 elements:
-            [min_batch, channels, depth, height, width].
-            Must: input_size[0] == dy_tensor_size[0], input_size[1] == dy_tensor_size[1].
-        - **output_size** (listInt): An optional listInt. Default: ``None``.
-            It contains 3 elements: depth, height, width, whose elements should be the same as `dy`.
-            Must:
-            dy_tensor_size[2] == floor(input_size[2] * scales[0]) == output_size[0],
-            dy_tensor_size[3] == floor(input_size[3] * scales[1]) == output_size[1],
-            dy_tensor_size[4] == floor(input_size[4] * scales[2]) == output_size[2].
-        - **scales** (listFloat): An optional listFloat. Default: ``None``.
-            The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width.
-            The number of elements of 'scales' should be the same as the rank of `dy`.
-
-    Outputs:
-        - **dx**- (Tensor) - A 5-D tensor. Has the same type as `dy`, shape depends on `input_size`.
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize UpsampleNearest3DGrad."""
-        self.init_prim_io_names(
-            inputs=['dy', 'input_size', 'output_size', 'scales'],
-            outputs=['dx'])
-
-
 class ROIAlignGrad(Primitive):
     """
     ROIAlignGrad operator.
@@ -2499,45 +2466,6 @@ class MultiMarginLossGrad(Primitive):
         return super().__call__(y_grad, x, target, weight)
 
 
-class UpsampleTrilinear3DGrad(Primitive):
-    r"""
-    Upsample the 3-D gradient data with trilinear interpolation algorithm.
-
-    Note:
-        One of 'scales' and 'output_size' must be specified. And it is an error if both are specified.
-
-    Args:
-        align_corners (bool): An optional bool. Default: ``False``.
-
-    Inputs:
-        - **dy** (Tensor) - Tensor of shape [N, C, D, H, W]. Must be one of the following types:
-          float16, float32, float64.
-        - **input_size** (Union[tuple[int], list[int]]): An required listInt which contains 5 elements:
-          [batch, channels, depth, height, width]. Must:
-          input_size[0] == dy_tensor_size[0]
-          input_size[1] == dy_tensor_size[1].
-        - **output_size** (Union[tuple[int], list[int]]): An optional listInt. Default: ``None``.
-          It contains 3 elements: depth, height, width, whose elements should be the same as `dy`. Must:
-          dy_tensor_size[2] == floor(input_size[2] * scales[0]) == output_size[0]
-          dy_tensor_size[3] == floor(input_size[3] * scales[1]) == output_size[1]
-          dy_tensor_size[4] == floor(input_size[4] * scales[2]) == output_size[2].
-        - **scales** (Union[tuple[float], list[float]]): An optional listFloat. Default: ``None``.
-          The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width.
-          The number of elements of 'scales' should be the same as the rank of input `dy`.
-
-    Outputs:
-        - **dx** (Tensor) - A Tensor with shape depending on intput_size, and its' dtype is the same as `dy`.
-    """
-    @prim_attr_register
-    def __init__(self, align_corners=False):
-        """Initialize UpsampleTrilinear3DGrad."""
-        self.init_prim_io_names(
-            inputs=['dy', 'input_size', 'output_size', 'scales'],
-            outputs=['dx'])
-        self.align_corners = align_corners
-        self.add_prim_attr('align_corners', self.align_corners)
-
-
 class SparseSegmentMeanGrad(Primitive):
     """
     Compute gradients for SparseSegmentMeanGrad operation.
@@ -3131,39 +3059,6 @@ class WKVGrad(Primitive):
                                 outputs=["gw", "gu", "gk", "gv"])
 
 
-class FlashAttentionScoreGrad(Primitive):
-    r"""
-    Calculates the gradient of FlashAttentionScore operation.
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Supported Platforms:
-        ``Ascend``
-    """
-    @prim_attr_register
-    def __init__(self, head_num, keep_prob=1.0, scale_value=1.0, pre_tokens=65536, next_tokens=65536, inner_precise=1,
-                 input_layout='BSH', sparse_mode=0):
-        """Initialize FlashAttentionScoreGrad."""
-        validator.check_value_type('head_num', head_num, [int], self.name)
-        validator.check_value_type('keep_prob', keep_prob, [int, float], self.name)
-        validator.check_float(keep_prob, 0.0, validator.GE, "keep_prob", self.name)
-        validator.check_float(keep_prob, 1.0, validator.LE, "keep_prob", self.name)
-        validator.check_value_type('scale_value', scale_value, [float], self.name)
-        validator.check_value_type('pre_tokens', pre_tokens, [int], self.name)
-        validator.check_value_type('next_tokens', next_tokens, [int], self.name)
-        validator.check_value_type('inner_precise', inner_precise, [int], self.name)
-        validator.check_value_type('sparse_mode', sparse_mode, [int], self.name)
-        if inner_precise not in [0, 1]:
-            raise ValueError(f"Attribute 'inner_precise' must be either 0 or 1, but got {inner_precise}")
-        validator.check_value_type('input_layout', input_layout, [str], self.name)
-        if input_layout not in ["BSH", "BNSD"]:
-            raise ValueError(f"Attribute 'input_layout' must be either 'BSH' or 'BNSD', but got {input_layout}")
-        self.init_prim_io_names(inputs=['query', 'key', 'value', 'dy', 'pse_shift', 'drop_mask', "padding_mask",
-                                        'attn_mask', 'softmax_max', 'softmax_sum', 'softmax_out', 'attention_in',
-                                        'prefix'],
-                                outputs=['dq', 'dk', 'dv', 'dpse'])
-
-
 class RmsNormGrad(Primitive):
     r"""
     Calculates the gradient of RmsNorm operation.

mindspore/ops/operations/_inner_ops.py

@@ -2655,10 +2655,10 @@ class FFN(Primitive):
         >>> h = 1024
         >>> h_f = 4 * h
         >>> e = 16
-        >>> x = Tensor(np.random.randn(b * s, h).astype(np.float16))
+        >>> x = Tensor(np.random.randn(s, h).astype(np.float16))
         >>> w1 = Tensor(np.random.randn(e, h, h_f).astype(np.float16))
         >>> w2 = Tensor(np.random.randn(e, h_f, h).astype(np.float16))
-        >>> expert_tokens = Tensor(np.random.randn(e).astype(np.int64))
+        >>> expert_tokens = Tensor(np.full(e, 8))
         >>> bias1 = Tensor(np.random.randn(e, h_f).astype(np.float16))
         >>> bias2 = Tensor(np.random.randn(e, h).astype(np.float16))
         >>> ffn = _inner_ops.FFN("fastgelu", 1)
@@ -2818,14 +2818,14 @@ class CollectiveGather(Primitive):
 
             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/r2.3.q1/parallel/rank_table.html>`_
+            <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/r2.3.q1/parallel/mpirun.html>`_ .
+            <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/r2.3.q1/parallel/dynamic_cluster.html>`_ .
+            Startup <https://www.mindspore.cn/tutorials/experts/en/master/parallel/dynamic_cluster.html>`_ .
 
             This example should be run with 4 devices.
 

mindspore/ops/operations/_sequence_ops.py

@@ -440,7 +440,7 @@ class TensorToTuple(PrimitiveWithCheck):
     def infer_value(self, x):
         """Infer_value TensorToTuple"""
         value = None
-        if x is not None and isinstance(x, (Tensor, Tensor_)):
+        if x is not None and isinstance(x, (Tensor, Tensor_)) and len(x.asnumpy().shape) <= 1:
             value = tuple(x.asnumpy().tolist())
         return value
 
@@ -477,7 +477,7 @@ class TensorToList(PrimitiveWithCheck):
     def infer_value(self, x):
         """infer_value TensorToList"""
         value = None
-        if x is not None and isinstance(x, (Tensor, Tensor_)):
+        if x is not None and isinstance(x, (Tensor, Tensor_)) and len(x.asnumpy().shape) <= 1:
             value = x.asnumpy().tolist()
         return value