mindspore 2.4.10__cp39-cp39-manylinux1_x86_64.whl → 2.5.0__cp39-cp39-manylinux1_x86_64.whl

mindspore/ops/function/clip_func.py

@@ -26,11 +26,13 @@ from mindspore.ops.primitive import _primexpr
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore import _checkparam as Validator
 from mindspore.ops.auto_generate import clamp_tensor, clamp_scalar
+from mindspore.ops.auto_generate import inplace_clamp_tensor, inplace_clamp_scalar
 
 __all__ = [
     'clip_by_value',
     'clip_by_norm',
     'clamp',
+    'clamp_',
     'clip',
     'clip_by_global_norm',
 ]
@@ -277,6 +279,68 @@ def clamp(input, min=None, max=None):
         return clamp_tensor(input, min, max)
     return clamp_scalar(input, min, max)
 
+
+def clamp_(input, min=None, max=None):
+    r"""
+    Clamps tensor values between the specified minimum value and maximum value.
+
+    Limits the value of :math:`input` to a range, whose lower limit is `min` and upper limit is `max` .
+
+    .. warning::
+
+        This is an experimental API that is subject to change or deletion.
+
+    .. math::
+
+        out_i= \left\{
+        \begin{array}{align}
+            max & \text{ if } input_i\ge max \\
+            input_i & \text{ if } min \lt input_i \lt max \\
+            min & \text{ if } input_i \le min \\
+        \end{array}\right.
+
+    Note:
+        - `min` and `max` cannot be None at the same time;
+        - When `min` is None and `max` is not None, the elements in Tensor larger than `max` will become `max`;
+        - When `min` is not None and `max` is None, the elements in Tensor smaller than `min` will become `min`;
+        - If `min` is greater than `max`, the value of all elements in Tensor will be set to `max`;
+        - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
+
+    Args:
+          input (Tensor): Input data, which type is Tensor. Tensors of arbitrary dimensions are supported.
+          min (Union(Tensor, float, int), optional): The minimum value. Default: ``None`` .
+          max (Union(Tensor, float, int), optional): The maximum value. Default: ``None`` .
+
+    Returns:
+          Tensor, a clipped Tensor.
+          The data type and shape are the same as input.
+
+    Raises:
+          ValueError: If both `min` and `max` are None.
+          TypeError: If the type of `input` is not in Tensor.
+          TypeError: If the type of `min` is not in None, Tensor, float or int.
+          TypeError: If the type of `max` is not in None, Tensor, float or int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> # case 1: the data type of input is Tensor
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> min_value = Tensor(5, mindspore.float32)
+        >>> max_value = Tensor(20, mindspore.float32)
+        >>> input = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> input.clamp_(min_value, max_value)
+        >>> print(input)
+        [[ 5. 20.  5.  7.]
+         [ 5. 11.  6. 20.]]
+    """
+    if isinstance(min, Tensor) or isinstance(max, Tensor):
+        return inplace_clamp_tensor(input, min, max)
+    return inplace_clamp_scalar(input, min, max)
+
 def clip(input, min=None, max=None):
     r"""
     Alias for :func:`mindspore.ops.clamp` .

mindspore/ops/function/debug_func.py

@@ -28,8 +28,8 @@ def print_(*input_x):
     Once set, the output will be saved in the file specified by print_file_path.
     :func:`mindspore.parse_print` can be employed to reload the data.
     For more information, please refer to :func:`mindspore.set_context` and :func:`mindspore.parse_print`.
-    In Ascend platform with graph mode, can set environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
-    to solve operator execution failure when outputting big tensor or outputting tensor intensively.
+    In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+    can be set to solve operator execution failure when outputting big tensor or outputting tensor intensively.
 
     Note:
         In pynative mode, please use python print function.
@@ -73,10 +73,11 @@ def tensordump(file_name, tensor, mode='out'):
     """
     Save Tensor in numpy's npy format.
 
-    In Parallel situation, tensordump will dump slice of data at each rank.
+    .. warning::
+        - The parameter mode will no longer support the value 'all'.
 
-    In Ascend platform with graph mode,
-    Your code OpA --> OpB may compiled as OpA --> RedistributionOps --> OpB.
+    In Parallel situation, tensordump will dump slice of data at each rank.
+    In Ascend platform with graph mode, Your code OpA --> OpB may compiled as OpA --> RedistributionOps --> OpB.
 
     Note: The redistribution operator is introduced,
     Due to inter-device communication and shard strategies in the static graph parallel scenario.
@@ -91,21 +92,21 @@ def tensordump(file_name, tensor, mode='out'):
     Different requirements of saving dump data can be achieved by configuring parameter mode:
 
     - If the mode is 'out', the dump data contains only OpA's output slice.
-    - If the mode is 'all', the dump data contains both OpA's output slice and OpB's input slice.
     - If the mode is 'in', the dump data contains only OpB's input slice.
 
-    For mode 'all' or 'in', the input slice npy file format is: id_fileName_cNodeID_dumpMode_rankID.npy.
+    For mode 'in', the input slice npy file format is: fileName_dumpMode_dtype_id.npy.
 
-    For mode 'out' or 'all' the output slice npy file format is: id_filename.npy.
+    For mode 'out', the output slice npy file format is: filename_dtype_id.npy.
 
-    - id: An auto increment ID.
     - fileName: Value of the parameter file_name
       (if parameter file_name is a user-specified path, the value of fileName is the last level of the path).
-    - cNodeID: The cnode ID in ir graph of step_parallel_end.ir.
     - dumpMode: Value of the parameter mode.
-    - rankID: Logical device id.
+    - dtype: The original data type. Data of type bfloat16 stored in the .npy file will be converted to float32.
+    - id: An auto increment ID.
 
     Note:
+        - In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+          can be set to solve operator execution failure when outputting big tensor or outputting tensor intensively.
         - The operator of tensordump doesn't support in control flow.
         - If current parallel mode is STAND_ALONE, mode should only be 'out'.
         - Parameter mode will be set to 'out' if user doesn't configure it.
@@ -114,23 +115,24 @@ def tensordump(file_name, tensor, mode='out'):
     Args:
         file_name (str): The path of the npy file saves.
         tensor (Tensor): The tensor that user want to dump.
-        mode (str, optional): Used to control tensordump behavior, available value is one of ['in', 'out', 'all'].
+        mode (str, optional): Used to control tensordump behavior, available value is one of ['in', 'out'].
             Default value is ``out``.
 
     Raises:
         TypeError: If `file_name` is not str.
         TypeError: If `tensor` is not Tensor.
         TypeError: If `mode` is not str.
-        ValueError: If `mode` is not in one of ['in', 'out', 'all'].
+        ValueError: If `mode` is not in one of ['in', 'out'].
 
     Supported Platforms:
         ``Ascend``
 
     Examples:
         .. note::
-            Using msrun command to run below example: msrun --worker_num=2 --local_worker_num=2 --master_port=11450
-            --log_dir=msrun_log --join=True --cluster_time_out=300 tensordump_example.py
+            Using msrun command to run below example: msrun --worker_num=2 --local_worker_num=2
+            --master_port=11450 --log_dir=msrun_log --join=True --cluster_time_out=300 tensordump_example.py
 
+        >>> import os
         >>> import numpy as np
         >>> import mindspore as ms
         >>> from mindspore import nn, Tensor, ops, context
@@ -147,11 +149,12 @@ def tensordump(file_name, tensor, mode='out'):
         ...
         ...     def construct(self, x, y, b):
         ...         out1 = self.matmul1(x, y)
-        ...         ops.tensordump(dump_path, out1, 'all')
+        ...         ops.tensordump(dump_path, out1, 'out')
         ...         out2 = self.matmul2(out1, b)
         ...         return out2
         ...
-        >>> ms.set_context(mode=ms.GRAPH_MODE, save_graphs=2)
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> os.environ["MS_DEV_SAVE_GRAPHS"] = "2"
         >>> context.set_auto_parallel_context(parallel_mode='semi_auto_parallel', full_batch=True)
         >>> strategy1 = ((1, 2), (2, 1))
         >>> strategy2 = ((1, 2), (2, 1))
@@ -161,17 +164,22 @@ def tensordump(file_name, tensor, mode='out'):
         >>> b = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
         >>> out = net(x, y, b)
         >>> print(f"out shape is: {out.shape}")
-        >>> matmul1_output_slice = np.load('0_mul1_mul2.npy')                       # load matmul1's output slice
-        >>> matmul2_input_slice = np.load('1_mul1_mul2_CNode_64_all_rank_0.npy')    # load matmul2's input slice
+        >>> # out shape is (64, 64)
+        >>> matmul1_output_slice = np.load('dumps/rank_0/mul1_mul2_float32_0.npy')      # load matmul1's output slice
+        >>> print(f"matmul1_output_slice is loaded, shape is: {matmul1_output_slice.shape}")
+        >>> # matmul1_output_slice is loaded, shape is: (64, 64)
     """
+
     if not isinstance(file_name, str):
         raise TypeError(f"Parameter file_name should only be build_in str type but got: {type(file_name)}")
     if not isinstance(tensor, Tensor):
         raise TypeError(f"Parameter tensor should only be Tensor type, but got: {type(tensor)}")
     if not isinstance(mode, str):
         raise TypeError(f"Parameter mode should only be build_in str type, but got: {type(mode)}")
-    mode_list = ['out', 'in', 'all']
+    mode_list = ['out', 'in']
     if mode not in mode_list:
+        if mode == 'all':
+            raise ValueError(f"Argument [mode] has been not supported value of 'all'.")
         raise ValueError(f"Parameter mode should in {mode_list}, but got {mode}")
     _tensordump = _get_cache_prim(P.TensorDump)(input_output=mode)
     return _tensordump(file_name, tensor)

mindspore/ops/function/image_func.py

@@ -252,7 +252,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
         >>> crop_size = (24, 24)
         >>> output = ops.crop_and_resize(Tensor(image), Tensor(boxes), Tensor(box_indices), crop_size)
         >>> print(output.shape)
-         (5, 24, 24, 3)
+        (5, 24, 24, 3)
     """
     _crop_and_resize_check(image, boxes, box_indices, crop_size)
     image_shape = image.shape

mindspore/ops/function/linalg_func.py

@@ -119,7 +119,7 @@ def eig(A):
     Returns:
         - **eigen_values** (Tensor) - Shape :math:`(*, N)`. eigenvalues of
           the corresponding matrix. The eigenvalues may not have an order.
-        - **eigen_vectors** (Tensor) - Shape :math:`(*, N, N)`,columns of eigen vectors represent
+        - **eigen_vectors** (Tensor) - Shape :math:`(*, N, N)`, columns of eigen vectors represent
         - **normalized** (unit length) eigenvectors of corresponding eigenvalues.
 
     Raises:
@@ -157,7 +157,7 @@ def eigvals(A):
             with float32, float64, complex64 or complex128 data type.
 
     Returns:
-        Tensor, with shape :math:`(*, N)`. Returns the eigenvalues of
+        **eigen_values** (Tensor) - Shape :math:`(*, N)`. Returns the eigenvalues of
         the corresponding matrix, which may not have an order.
 
     Raises:
@@ -217,9 +217,10 @@ def svd(input, full_matrices=False, compute_uv=True):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor, set_context
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor
         >>> from mindspore import ops
-        >>> set_context(device_target="CPU")
+        >>> ms.set_device(device_target="CPU")
         >>> input = Tensor(np.array([[1, 2], [-4, -5], [2, 1]]).astype(np.float32))
         >>> s, u, v = ops.svd(input, full_matrices=True, compute_uv=True)
         >>> print(s)