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

mindspore/ops/function/reshard_func.py

@@ -0,0 +1,102 @@
+# Copyright 2023 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.
+# ============================================================================
+"""Defines parameter operators with functional form."""
+from mindspore.ops import operations as P
+from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.parallel.shard import Layout
+from mindspore.common.tensor import Tensor
+
+
+def reshard(tensor, layout):
+    r"""
+    Specify the tensor by the given layout. The given layout must be type mindspore.Layout,
+    can check :class:`mindspore.Layout` for reference.
+
+    - In the Graph mode, this function can set the sharding propagation strategy of a tensor.
+      For those tensor do not manually be set, their strategies are decided by the sharding
+      strategy propagation algorithm automatically.
+    - In the PyNative mode, this function can set a tensor sharding strategy in a Cell that
+      runs in the Graph mode (i.e. inside the Cell processed by Cell.shard/F.shard).
+
+    Note:
+        - In the auto parallel mode, an exception will throw if the search mode is not
+          "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".
+
+    Args:
+        tensor (Tensor): The tensor to be set the sharding strategy.
+        layout (Layout): The layout to shard the tensor precisely, including the device
+                         arrangement (device_matrix) and the alias for the device matrix
+                         (alias_name).
+
+    Returns:
+        Tensor. The mathematically equivalent of the input tensor.
+
+    Raises:
+        TypeError: Reshard takes in Tensor type as the first input param, but got: `type(tensor)`.
+        TypeError: Reshard only support type mindspore.Layout but got: `type(layout)`.
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> 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")
+        >>> 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
+        >>>
+        >>> layout = Layout((4, 2), ("dp", "mp"))
+        >>> input_layout = layout("dp", "mp")
+        >>> net = Network()
+        >>> tensor = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
+        >>> out = net(tensor, input_layout)
+    """
+    if not isinstance(tensor, Tensor):
+        raise TypeError(f"Reshard takes in Tensor type as the first input param, but got: {type(tensor)}.")
+    if not isinstance(layout, Layout):
+        raise TypeError(f"Reshard only support type mindspore.Layout, but got: {type(layout)}.")
+
+    def layout_to_tuple(layout):
+        layout_dict = layout.to_dict()
+        tensor_map = layout_dict["tensor_map"]
+        device_matrix_rev = layout_dict["device_matrix"][::-1]
+        axis_stgy = ()
+        for ind in tensor_map:
+            if ind == -1:
+                axis_stgy += (1,)
+            else:
+                axis_stgy += (device_matrix_rev[ind],)
+        return axis_stgy
+
+    in_strategy = layout_to_tuple(layout)
+    _reshard = _get_cache_prim(P.Reshard)(in_layout=(layout,), out_layout=(layout,), in_strategy=(in_strategy,))
+    return _reshard(tensor)
+
+__all__ = [
+    'reshard'
+]
+
+__all__.sort()

mindspore/ops/function/sparse_func.py

@@ -140,7 +140,7 @@ def coalesce(x_indices: Tensor, x_values: Tensor, x_shape: Tensor) -> Tuple[Tens
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> x_indices = Tensor([[0, 0, 1], [1, 1, 2]], dtype=ms.int64)
         >>> x_values = Tensor([1, 5, 4], dtype=ms.float32)
@@ -271,7 +271,7 @@ def csr_mm(a: CSRTensor, b: CSRTensor, trans_a: bool = False, trans_b: bool = Fa
     Examples:
         >>> from mindspore import Tensor, CSRTensor
         >>> from mindspore import dtype as mstype
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> a_shape = (4, 5)
         >>> a_indptr = Tensor([0, 1, 1, 3, 4], dtype=mstype.int32)
         >>> a_indices = Tensor([0, 3, 4, 0],dtype=mstype.int32)
@@ -745,7 +745,7 @@ def csr_softmax(logits: CSRTensor, dtype: mstype):
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> import mindspore.common.dtype as mstype
         >>> from mindspore import Tensor, CSRTensor
         >>> logits_indptr = Tensor([0, 4, 6], dtype=mstype.int32)
@@ -807,7 +807,7 @@ def csr_add(a: CSRTensor, b: CSRTensor, alpha: Tensor, beta: Tensor) -> CSRTenso
     Examples:
         >>> import mindspore.common.dtype as mstype
         >>> from mindspore import Tensor, CSRTensor
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> a_indptr = Tensor([0, 1, 2], dtype=mstype.int32)
         >>> a_indices = Tensor([0, 1], dtype=mstype.int32)
         >>> a_values = Tensor([1, 2], dtype=mstype.float32)

mindspore/ops/function/sparse_unary_func.py

@@ -102,7 +102,7 @@ def coo_cos(x: COOTensor) -> COOTensor:
 
 
 def csr_tan(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes tangent of `x` element-wise.
 
     .. math::
@@ -139,7 +139,7 @@ def csr_tan(x: CSRTensor) -> CSRTensor:
 
 
 def coo_tan(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Computes tangent of `x` element-wise.
 
     .. math::
@@ -331,10 +331,6 @@ def csr_relu(x: CSRTensor) -> CSRTensor:
 
         ReLU(x) = (x)^+ = \max(0, x)
 
-    Note:
-        In general, this operator is more commonly used. The difference from `ReLuV2` is that the `ReLuV2` will
-        output one more Mask.
-
     Args:
         x (CSRTensor): Input CSRTensor.
 
@@ -376,14 +372,10 @@ def coo_relu(x: COOTensor) -> COOTensor:
 
         ReLU(x) = (x)^+ = \max(0, x)
 
-    Note:
-        In general, this operator is more commonly used. The difference from `ReLuV2` is that the `ReLuV2` will
-        output one more Mask.
-
     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.2/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`.
@@ -1034,7 +1026,7 @@ def coo_floor(x: COOTensor) -> COOTensor:
 
 
 def csr_atan(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Computes the trigonometric inverse tangent of the input element-wise.
 
     .. math::
@@ -1565,7 +1557,7 @@ def coo_softsign(x: COOTensor) -> COOTensor:
 
 
 def csr_log1p(x: CSRTensor) -> CSRTensor:
-    """
+    r"""
     Returns the natural logarithm of one plus the input CSRTensor element-wise.
 
     .. math::
@@ -1603,7 +1595,7 @@ def csr_log1p(x: CSRTensor) -> CSRTensor:
 
 
 def coo_log1p(x: COOTensor) -> COOTensor:
-    """
+    r"""
     Returns the natural logarithm of one plus the input COOTensor element-wise.
 
     .. math::
@@ -1800,7 +1792,7 @@ def csr_asinh(x: CSRTensor) -> CSRTensor:
         out_i = \sinh^{-1}(input_i)
 
     Args:
-        x (CSRTensor): The input CSRTensor of inverse hyperbolic sine function.
+        x (CSRTensor): The input CSRTensor of inverse hyperbolic sine function, i.e. :math:`input_i`.
 
     Returns:
         CSRTensor, has the same shape and type as `x`.
@@ -1946,7 +1938,8 @@ def csr_acosh(x: CSRTensor) -> CSRTensor:
         out_i = \cosh^{-1}(input_i)
 
     Args:
-        x (CSRTensor): The input CSRTensor of inverse hyperbolic cosine function, its element must be in range [1, inf].
+        x (CSRTensor): The input CSRTensor of inverse hyperbolic cosine function, i.e. :math:`input_i`,
+            its element must be in range [1, inf].
 
     Returns:
         CSRTensor, has the same shape and type as `x`.

mindspore/ops/function/spectral_func.py

@@ -106,7 +106,7 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
         window_length (Tensor): The size of returned window, with data type int32, int64.
             The input data should be an integer with a value of [0, 1000000].
         periodic (bool, optional): Indicates whether to returns a window to be used as periodic function or
-            a symmetric window. Default: ``True`` .
+            a symmetric window. Default: ``True`` , indicating that the returned window is a periodic function.
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The datatype of returned tensor.

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.2/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.
@@ -36,12 +36,12 @@ def vmap(fn, in_axes=0, out_axes=0):
         This is an experimental API that is subject to change or deletion.
 
     Note:
-        1. The power of vmap comes from the implementation of VmapRules of primitives. Although we have designed a
-        generalized rule for user custom operators, we can not guarantee that it works well for all operators,
-        unknown exceptions may occur, please be aware the risk of use.
-        2. When calling the random number generation methods within the scope of vmap, the same random number is
-        generated among vector functions each time. If you expect each vector branch to use different random numbers,
-        you need to generate batch random numbers externally in advance and then transfer them to vmap.
+        - The power of vmap comes from the implementation of VmapRules of primitives. Although we have designed a
+          generalized rule for user custom operators, we can not guarantee that it works well for all operators,
+          unknown exceptions may occur, please be aware the risk of use.
+        - When calling the random number generation methods within the scope of vmap, the same random number is
+          generated among vector functions each time. If you expect each vector branch to use different random numbers,
+          you need to generate batch random numbers externally in advance and then transfer them to vmap.
 
     Args:
         fn (Union[Cell, Function, CellList]): Function to be mapped along the parameter axes, which takes at least one
@@ -69,13 +69,13 @@ def vmap(fn, in_axes=0, out_axes=0):
         correspond to those of `fn`, but it adds an extra batch dimension at positions specified by `in_axes` and
         `out_axes`.
 
-    Raises:
-        RuntimeError: If base elements in `in_axes` or `out_axes` are not a None or an integer.
-            If the all base elements in `in_axes` or `out_axes` are None.
-            If `in_axes` is not single integer, and the length of `in_axes` is not equal to the arguments sizes.
-            If `out_axes` is not single integer, and the length of `out_axes` is not equal to the outputs sizes.
-            If the `axis_size` of each arguments in the scope of `vmap` are not equal.
-            If the axis in `in_axes` or `out_axes` is out of bounds.
+    :raise RuntimeError:
+        - If base elements in `in_axes` or `out_axes` are not a None or an integer.
+        - If the all base elements in `in_axes` or `out_axes` are None.
+        - If `in_axes` is not single integer, and the length of `in_axes` is not equal to the arguments sizes.
+        - If `out_axes` is not single integer, and the length of `out_axes` is not equal to the outputs sizes.
+        - If the `axis_size` of each arguments in the scope of `vmap` are not equal.
+        - If the axis in `in_axes` or `out_axes` is out of bounds.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``