mindspore 2.6.0rc1__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/ops/function/debug_func.py

@@ -15,6 +15,8 @@
 
 """Operators for debug function."""
 
+__all__ = ['print_', 'tensordump']
+
 from mindspore.ops.operations.debug_ops import Print
 from mindspore.common.tensor import Tensor
 from mindspore.ops import operations as P
@@ -22,7 +24,7 @@ from .._primitive_cache import _get_cache_prim
 
 
 def print_(*input_x):
-    """
+    r"""
     Outputs the inputs to stdout.
     The outputs are printed to screen by default.
     It can also be saved in a file by setting the parameter  `print_file_path` in `context`.
@@ -38,7 +40,7 @@ def print_(*input_x):
         This function is used for debugging.
 
     Args:
-        input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print_.
+        input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print\_.
             Supports multiple inputs which are separated by ','.
 
     Returns:
@@ -122,6 +124,7 @@ def tensordump(file_name, tensor, mode='out'):
             --master_port=11450 --log_dir=msrun_log --join=True --cluster_time_out=300 tensordump_example.py
 
         >>> import os
+        >>> import time
         >>> import numpy as np
         >>> import mindspore
         >>> from mindspore import nn, context
@@ -148,15 +151,16 @@ def tensordump(file_name, tensor, mode='out'):
         >>> strategy1 = ((1, 2), (2, 1))
         >>> strategy2 = ((1, 2), (2, 1))
         >>> with no_init_parameters():
-        >>>     net = Net(strategy1, strategy2)
+        ...     net = Net(strategy1, strategy2)
         >>> x = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
         >>> y = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
         >>> b = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
-        >>> parallel_net = Autoparallel(net, parallel_mode="semi_auto")
+        >>> parallel_net = AutoParallel(net, parallel_mode="semi_auto")
         >>> parallel_net.dataset_strategy(config="full_batch")
         >>> out = parallel_net(x, y, b)
         >>> print(f"out shape is: {out.shape}")
         >>> # out shape is (64, 64)
+        >>> time.sleep(0.5) # npy file is generated asynchronously, spend an interval time then load it.
         >>> matmul1_output_slice = np.load(f'rank_{rank_id}_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)
@@ -176,6 +180,5 @@ def tensordump(file_name, tensor, mode='out'):
     _tensordump = _get_cache_prim(P.TensorDump)(input_output=mode)
     return _tensordump(file_name, tensor)
 
-__all__ = ['print_', 'tensordump']
 
 __all__.sort()

mindspore/ops/function/grad/grad_func.py

@@ -654,9 +654,7 @@ def _check_jvp_input_v_len(inputs_len, v_len):
 
 def jvp(fn, inputs, v, has_aux=False):
     """
-    Compute the jacobian-vector-product of the given network. The calculation procedure of JVP can be found in
-    `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
+    Compute the jacobian-vector-product of the given network.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -869,9 +867,7 @@ _vjp_grad_op_with_weight = _Grad(get_all=True, get_by_list=True, sens_param=True
 
 def vjp(fn, *inputs, weights=None, has_aux=False):
     """
-    Compute the vector-jacobian-product of the given network. `vjp` matches
-    `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
+    Compute the vector-jacobian-product of the given network.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -1070,9 +1066,7 @@ _vmap = _Vmap()
 
 def jacfwd(fn, grad_position=0, has_aux=False):
     """
-    Compute Jacobian via forward mode, corresponding to
-    `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
+    Compute Jacobian via forward mode.
     When number of outputs is much greater than that of inputs, it's better to calculate Jacobian via forward mode than
     reverse mode to get better performance.
 
@@ -1241,9 +1235,7 @@ _grad = _Grad(get_by_position=True, has_aux=False, sens_param=True)
 
 def jacrev(fn, grad_position=0, has_aux=False):
     """
-    Compute Jacobian via reverse mode, corresponding to
-    `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
+    Compute Jacobian via reverse mode.
     When number of inputs is much greater than that of outputs, it's better to calculate Jacobian via reverse mode than
     forward mode to get better performance.
 
@@ -1395,7 +1387,7 @@ def stop_gradient(value):
         >>> mindspore.ops.grad(f1)(mindspore.tensor(x))
         Tensor(shape=[], dtype=Float32, value= 6)
         >>>
-        >>> # The same function with stop_gradient, return a zero gradient because x is effectively treated as a constant.
+        >>> # With stop_gradient, return a zero gradient because x is effectively treated as a constant.
         >>> def f2(x):
         ...     return mindspore.ops.stop_gradient(x) ** 2
         >>> f2(x)