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

mindspore/ops/operations/other_ops.py

@@ -22,47 +22,8 @@ from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import Primitive, PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register
 from mindspore.ops.operations._pyfunc_registry import add_pyfunc
 from mindspore._c_expression import typing
-from mindspore.ops.operations.array_ops import Identity
 from mindspore.ops._primitive_cache import _get_cache_prim
-
-
-class Assign(Primitive):
-    """
-    Assigns `Parameter` with a value.
-
-    Refer to :func:`mindspore.ops.assign` for more details.
-
-    Inputs:
-        - **variable** (Parameter) - The `Parameter`. :math:`(N,*)` where :math:`*` means,
-          any number of additional dimensions, its rank should be less than 8.
-        - **value** (Tensor) - The value to be assigned, has the same shape with `variable`.
-
-    Outputs:
-        Tensor, has the same data type and shape as original `variable`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> value = Tensor([2.0], mindspore.float32)
-        >>> variable = mindspore.Parameter(Tensor([1.0], mindspore.float32), name="variable")
-        >>> assign = ops.Assign()
-        >>> x = assign(variable, value)
-        >>> print(variable.asnumpy())
-        [2.]
-    """
-    __mindspore_signature__ = (
-        sig.make_sig('variable', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
-        sig.make_sig('value', dtype=sig.sig_dtype.T)
-    )
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Assign."""
-        self.init_prim_io_names(inputs=['ref', 'value'], outputs=['output'])
-        self.add_prim_attr('side_effect_mem', True)
+from ..auto_generate import Assign, Identity
 
 
 class Load(PrimitiveWithCheck):
@@ -209,8 +170,8 @@ class BoundingBoxDecode(Primitive):
         ...                                          max_shape=(768, 1280), wh_ratio_clip=0.016)
         >>> output = boundingbox_decode(anchor_box, deltas)
         >>> print(output)
-        [[ 4.1953125  0.         0.         5.1953125]
-         [ 2.140625   0.         3.859375  60.59375  ]]
+        [[ 4.194528  0.         0.         5.194528]
+         [ 2.1408591   0.         3.8591409  60.598152  ]]
 
     """
 
@@ -339,10 +300,10 @@ class SampleDistortedBoundingBoxV2(Primitive):
 
     @prim_attr_register
     def __init__(self, seed=0, seed2=0, \
-                  aspect_ratio_range=(0.75, 1.33), \
-                  area_range=(0.05, 1.0), \
-                  max_attempts=100, \
-                  use_image_if_no_bounding_boxes=False):
+                 aspect_ratio_range=(0.75, 1.33), \
+                 area_range=(0.05, 1.0), \
+                 max_attempts=100, \
+                 use_image_if_no_bounding_boxes=False):
         validator.check_is_int(seed, "seed", self.name)
         validator.check_is_int(seed2, "seed2", self.name)
         validator.check_value_type("aspect_ratio_range", aspect_ratio_range, [list, tuple], self.name)
@@ -469,7 +430,7 @@ class Partial(Primitive):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> def show_input(x, y, z):
         ...     return x, y, z
         >>> partial = ops.Partial()
@@ -526,7 +487,7 @@ class Depend(Primitive):
         >>> import numpy as np
         >>> import mindspore
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> class Net(nn.Cell):
         ...     def __init__(self):
@@ -600,7 +561,7 @@ class StopGradient(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
         >>> def net(x, y):
@@ -623,6 +584,9 @@ class StopGradient(Primitive):
         pass
 
 
+stop_gradient_ = StopGradient()
+
+
 class ConfusionMatrix(PrimitiveWithInfer):
     r"""
     Calculates the confusion matrix from labels and predictions.
@@ -861,3 +825,50 @@ class PyFunc(PrimitiveWithInfer):
         logger.warning("The function output are empty tuple. Add a placeholder instead. "
                        "Do not use it as it could be any uninitialized data.")
         return (typing.TensorType(mstype.int32),)
+
+
+class Reusing(Primitive):
+    r"""
+    Make the function graph to be labeled as no inline.
+
+    Refer to :func:`mindspore.ops.Reusing` for more details.
+
+    Inputs:
+        - **input_x** (function) - the function will be labeled as no inline.
+
+    Outputs:
+         function, the function that has been labeled as no inline.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, jit
+        >>> from mindspore.common import dtype as mstype
+        >>> from mindspore import ops
+        >>> def for_body_fun(i,val):
+                x = i *3
+                x = x * val * val
+                return x
+        >>> def fori_loop(lower, upper, body_fun, init_val):
+                body_fun = ops.reusing(body_fun)
+                val = init_val
+                for i in range(lower, upper):
+                    val = body_fun(i, val)
+                return val
+        >>> @jit
+        >>> def call_fori_loop(x):
+                x = fori_loop(1,10,for_body_fun,x)
+                return x
+        >>> x = Tensor([1], mstype.int32)
+        >>> x = call_fori_loop(x)
+        >>> print(x)
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Reusing"""
+
+    def __call__(self, x):
+        return x

mindspore/ops/operations/random_ops.py

@@ -20,6 +20,7 @@ from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import PrimitiveWithInfer, prim_attr_register, Primitive
 from mindspore.ops._utils import get_broadcast_shape
+from ..auto_generate import RandpermV2, UniformExt
 
 
 class NonDeterministicInts(Primitive):
@@ -88,6 +89,10 @@ class TruncatedNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -152,6 +157,10 @@ class StandardNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -203,6 +212,10 @@ class StandardLaplace(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -210,7 +223,8 @@ class StandardLaplace(Primitive):
             random seed to determine the final generated random number, must be non-negative. Default: ``0`` .
 
     Inputs:
-        - **shape** (Union[tuple, Tensor]) - The shape of random tensor to be generated. Only constant value is allowed
+        - **shape** (Union[tuple[int], Tensor[int]]) - 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.
 
     Outputs:
@@ -365,6 +379,10 @@ class Gamma(PrimitiveWithInfer):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -448,6 +466,10 @@ class ParameterizedTruncatedNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -670,6 +692,10 @@ class UniformInt(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -735,6 +761,10 @@ class UniformReal(Primitive):
           - GPU: int32, int64.
           - CPU: int16, int32, int64.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -811,7 +841,7 @@ class RandomChoiceWithMask(Primitive):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> rnd_choice_mask = ops.RandomChoiceWithMask()
-        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool))
+        >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool_))
         >>> output_y, output_mask = rnd_choice_mask(input_x)
         >>> result = output_y.shape
         >>> print(result)
@@ -835,6 +865,10 @@ class RandomCategorical(PrimitiveWithInfer):
     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:
         dtype (mindspore.dtype): The type of output. Its value must be one of mstype.int16,
             mstype.int32 and mstype.int64. Default: ``mstype.int64`` .
@@ -901,6 +935,10 @@ class Multinomial(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -1010,6 +1048,11 @@ class UniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.uniform_candidate_sampler` for more details.
 
+    .. 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:
         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
@@ -1024,7 +1067,7 @@ class UniformCandidateSampler(Primitive):
 
     Inputs:
         - **true_classes** (Tensor) - A Tensor. The target classes with a Tensor shape of
-          :math:`(batch\_size, num\_true)`.
+          :math:`(batch\_size, num\_true)`. The value range of the elements must be :math:`[0, range\_max)`.
 
     Outputs:
         - **sampled_candidates** (Tensor) - The sampled_candidates is independent of the true classes.
@@ -1084,6 +1127,10 @@ class LogUniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.log_uniform_candidate_sampler` for more details.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         num_true (int, optional): The number of target classes per training example. Default: ``1`` .
         num_sampled (int, optional): The number of classes to randomly sample. Default: ``5`` .
@@ -1239,54 +1286,3 @@ class Uniform(Primitive):
         Validator.check_non_negative_float(minval, "minval", self.name)
         Validator.check_non_negative_float(maxval, "maxval", self.name)
         self.add_prim_attr("side_effect_hidden", True)
-
-
-class RandpermV2(Primitive):
-    r"""
-    Generates random permutation of integers from 0 to n-1 without repeating.
-
-    Refer to :func:`mindspore.ops.randperm` for more details.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        dtype (mindspore.dtype, optional): The type of output.
-            Its value must be one of the following types: int32, int16, int8,
-            uint8, int64, float64, float32, float16. Default: mstype.int64.
-
-    Inputs:
-        - **n** (Union[Tensor, int]) - The input n Tensor with shape :math:`()` or :math:`(1,)`
-          and with data type of int64.
-        - **seed** (int, optional) - Random seed. Default: ``0`` . When `seed` is ``-1`` (only negative value),
-          `offset` is ``0``, it's determined by time.
-        - **offset** (int, optional) - Offset to generate random numbers. Priority is higher than random seed.
-          Default: ``0`` . It must be non-negative.
-
-    Outputs:
-        Tensor. Its shape is specified by the required args `n`. Its type is specified by `dtype`.
-        Otherwise is default.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> n = Tensor([4], mstype.int64)
-        >>> seed = 0
-        >>> offset = 0
-        >>> randperm = ops.RandpermV2(dtype=mstype.int64)
-        >>> output = randperm(n, seed, offset)
-        >>> print(output)
-        [1 0 2 3]
-    """
-
-    @prim_attr_register
-    def __init__(self, dtype=mstype.int64):
-        """Initialize RandpermV2"""
-        self.dtype = dtype
-        valid_values = (mstype.int32, mstype.int64, mstype.int16, mstype.int8, mstype.uint8, mstype.float64
-                        , mstype.float32, mstype.float16)
-        Validator.check_type_name("dtype", dtype, valid_values, self.name)
-        self.add_prim_attr("side_effect_hidden", True)

mindspore/ops/operations/reshard_ops.py

@@ -0,0 +1,53 @@
+# Copyright 2020-2022 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Operators for reshard."""
+from mindspore.ops.primitive import Primitive, prim_attr_register
+
+
+class Reshard(Primitive):
+    r"""
+    Reshard the tensor by the given in_layout and out_layout, which can precisely
+    define how the dimension of the tensor and the device clusters be sharded in
+    parallel procedure.
+
+    Note:
+        - The in and out layout should be the type mindspore.Layout.
+        - The in and out layout should be the same value of layout when invoke
+          ops.Reshard(layout, layout, in_strategy).
+        - The in_strategy should be the strategy derived from the layout.
+        - This primitive is not recommended to use directly. We recommend to use mindspore.reshard.
+
+    Inputs:
+        - **tensor** (Tensor) - The tensor to be resharded.
+
+    Outputs:
+        Tensor. The mathematically equivalent of the input tensor.
+
+    Examples:
+        >>> from mindspore.parallel.shard import Layout
+        >>> _layout = Layout((4, 2), ("dp", "mp"))
+        >>> layout = (_layout("dp", "mp"),)
+        >>> reshard = ops.Reshard(layout, layout, in_strategy)
+        >>> reshard(tensor)
+    """
+
+    @prim_attr_register
+    def __init__(self, in_layout, out_layout, in_strategy):
+        super().__init__(name="Reshard")
+        self.shard(in_layout, out_layout)
+        self.in_strategy = in_strategy
+
+    def __call__(self, tensor):
+        return tensor

mindspore/ops/operations/sparse_ops.py

@@ -60,7 +60,7 @@ class SparseDenseCwiseAdd(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore.common.tensor import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.common import dtype as ms
         >>> from mindspore.ops.operations import sparse_ops as ops
         >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
@@ -115,7 +115,7 @@ class SparseDenseCwiseMul(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore.common.tensor import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.common import dtype as ms
         >>> from mindspore.ops.operations import sparse_ops as ops
         >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
@@ -170,7 +170,7 @@ class SparseDenseCwiseDiv(Primitive):
         ``Ascend`` ``GPU``
 
     Examples:
-      >>> from mindspore.common.tensor import Tensor
+      >>> from mindspore import Tensor
       >>> from mindspore.common import dtype as ms
       >>> from mindspore.ops.operations import sparse_ops as ops
       >>> x1_indices = Tensor([[0, 0], [2, 2]], dtype=ms.int64)
@@ -584,7 +584,7 @@ class SparseTensorDenseAdd(Primitive):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import dtype as mstype
         >>> x1_indices = Tensor([[0, 0], [0, 1]], dtype=mstype.int64)
         >>> x1_values = Tensor([1, 1], dtype=mstype.float32)