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

mindspore/ops/function/reshard_func.py

@@ -0,0 +1,104 @@
+# 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".
+        - 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.
+        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, 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/mindspore.dtype.html>`_.
 
     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,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/r2.2/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.
 
@@ -36,12 +37,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 +70,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``