mindspore 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/function/clip_func.py

@@ -25,6 +25,7 @@ from mindspore.common import dtype as mstype
 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
 
 __all__ = [
     'clip_by_value',
@@ -242,18 +243,17 @@ def clamp(input, min=None, max=None):
         - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
 
     Args:
-          input (Union(Tensor, list[Tensor], tuple[Tensor])): Input data, which type is Tensor or a list or tuple of
-            Tensor. Tensors of arbitrary dimensions are supported.
+          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:
-          Union(Tensor, tuple[Tensor], list[Tensor]), a clipped Tensor or a tuple or a list of clipped Tensor.
+          Union(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 or list[Tensor] or tuple[Tensor].
+          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.
 
@@ -272,21 +272,10 @@ def clamp(input, min=None, max=None):
         >>> print(output)
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
-        >>> # case 2: the data type of input is list[Tensor]
-        >>> min_value = 5
-        >>> max_value = 20
-        >>> input_x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> input_y = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp([input_x,input_y], min_value, max_value)
-        >>> for out in output:
-        ...     print(out)
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
     """
-    return clip_by_value(input, min, max)
-
+    if isinstance(min, Tensor) or isinstance(max, Tensor):
+        return clamp_tensor(input, min, max)
+    return clamp_scalar(input, min, max)
 
 def clip(input, min=None, max=None):
     r"""

mindspore/ops/function/grad/grad_func.py

@@ -660,7 +660,7 @@ def jvp(fn, inputs, v, has_aux=False):
     """
     Compute the jacobian-vector-product of the given network. `jvp` matches
     `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.3.q1/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -875,7 +875,7 @@ 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/r2.3.q1/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -1074,7 +1074,7 @@ 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/r2.3.q1/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
     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.
 
@@ -1245,7 +1245,7 @@ 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/r2.3.q1/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
     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.
 
@@ -1376,7 +1376,7 @@ def stop_gradient(value):
     StopGradient is used for eliminating the effect of a value on the gradient, such as truncating
     the gradient propagation from an output of a function.
     For more details, please refer to `Stop Gradient
-    <https://www.mindspore.cn/tutorials/en/r2.3.q1/beginner/autograd.html#stop-gradient>`_.
+    <https://www.mindspore.cn/tutorials/en/master/beginner/autograd.html#stop-gradient>`_.
 
     Args:
         value (Any): The value whose effect on the gradient to be eliminated.

mindspore/ops/function/linalg_func.py

@@ -250,7 +250,7 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
     Batch matrices are supported. If x is a batch matrix, the output has the same batch dimension when
     atol or rtol is float.
     If atol or rtol is a Tensor, its shape must be broadcast to the singular value returned by
-    `x.svd <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/ops/mindspore.ops.svd.html>`_ .
+    `x.svd <https://www.mindspore.cn/docs/en/master/api_python/ops/mindspore.ops.svd.html>`_ .
     If x.shape is :math:`(B, M, N)`, and the shape of atol or rtol is :math:`(K, B)`, the output
     shape is :math:`(K, B, N, M)`.
     When the Hermitian is True, temporary support only real domain, x is treated as a real symmetric, so x is
@@ -260,13 +260,13 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
     characteristic value), it is set to zero, and is not used in the computations.
     If rtol is not specified and x is a matrix of dimensions (M, N), then rtol is set to
     be :math:`rtol=max(M, N)*\varepsilon`, :math:`\varepsilon` is the
-    `eps <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/ops/mindspore.ops.Eps.html>`_ value of x.dtype.
+    `eps <https://www.mindspore.cn/docs/en/master/api_python/ops/mindspore.ops.Eps.html>`_ value of x.dtype.
     If rtol is not specified and atol specifies a value larger than zero, rtol is set to zero.
 
     .. note::
         This function uses
-        `svd <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/ops/mindspore.ops.svd.html>`_ internally,
-        (or `eigh <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/scipy/mindspore.scipy.linalg.eigh.html>`_ ,
+        `svd <https://www.mindspore.cn/docs/en/master/api_python/ops/mindspore.ops.svd.html>`_ internally,
+        (or `eigh <https://www.mindspore.cn/docs/en/master/api_python/scipy/mindspore.scipy.linalg.eigh.html>`_ ,
         when `hermitian = True` ). So it has the same problem as these functions. For details,
         see the warnings in svd() and eigh().