mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/function/clip_func.py

@@ -22,28 +22,95 @@ from mindspore.ops import functional as F
 from mindspore.nn.cell import Cell
 from mindspore.common.tensor import Tensor
 from mindspore.common import dtype as mstype
+from mindspore.common.api import jit
 from mindspore.ops.primitive import _primexpr
 from mindspore import _checkparam as Validator
-from mindspore.ops._primitive_cache import _get_cache_prim
 
 __all__ = [
     'clip_by_value',
+    'clip_by_norm',
     'clamp',
     'clip',
     'clip_by_global_norm',
 ]
 
 hyper_map = C.HyperMap()
-max_op = _get_cache_prim(P.Maximum)()
-min_op = _get_cache_prim(P.Minimum)()
-cast_op = _get_cache_prim(P.Cast)()
-scalar2tensor_op = _get_cache_prim(P.ScalarToTensor)()
-partial_op = _get_cache_prim(P.Partial)()
+max_op = P.Maximum()
+min_op = P.Minimum()
+cast_op = P.Cast()
+scalar2tensor_op = P.ScalarToTensor()
+partial_op = P.Partial()
 expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
 get_square_sum = C.MultitypeFuncGraph("get_square_sum")
 apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
 
 
+def _old_norm(norm_type, x):
+    """Add norm function"""
+    out = F.pow((F.reduce_sum(F.pow(x, norm_type))), 1. / norm_type).astype(x.dtype)
+    return out
+
+
+@jit
+def _cal_total_norm(x, norm_type):
+    if norm_type == float('inf'):
+        func = lambda data: data.abs().max()
+        total_norm = max(hyper_map(func, x))
+    else:
+        total_norm = _old_norm(norm_type, F.stack(hyper_map(partial_op(_old_norm, norm_type), x)))
+    return total_norm
+
+
+def clip_by_norm(x, max_norm, norm_type=2.0, error_if_nonfinite=False):
+    r"""
+    Clip norm of a set of input Tensors. This norm is the result of calculating the norm of all elements in the input
+    separately, connecting them into a vector, and then calculating the norm.
+
+    Note:
+        The interface is suitable for gradient clipping scenarios, and only supports input of type float.
+
+    Args:
+          x (Union(Tensor, list[Tensor], tuple[Tensor])): Input that wishes to be clipped.
+          max_norm (Union(float, int)): The upper limit of the norm for this group of network parameters.
+          norm_type (Union(float, int)): Norm type. Default: ``2.0``.
+          error_if_nonfinite (bool): If it is ``True``, an exception is thrown if the total norm from the input
+              is nan, inf or -inf. If it is ``False``, no exception will be thrown.Default: ``False`` .
+
+    Returns:
+        Tensors, a list or tuple of Tensors, representing clipped Tensors.
+
+    Raises:
+          RuntimeError: If the total norm from the `x` is nan, inf or -inf.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([[0.8748, 0.1425, 0.0076], [0.7721, 0.4084, 0.0552], [4.6376, 0.2914, 2.1120]])
+        >>> out = ops.clip_by_norm(x, max_norm=1)
+        >>> print(out)
+        [[0.16650201 0.02712224 0.00144652]
+         [0.14695495 0.07773139 0.0105063 ]
+         [0.8826814  0.0554626  0.40198016]]
+    """
+    is_tensor = False
+    if isinstance(x, Tensor):
+        x = [x]
+        is_tensor = True
+    total_norm = _cal_total_norm(x, norm_type)
+    if error_if_nonfinite and F.logical_or(total_norm.isnan(), total_norm.isinf()):
+        raise RuntimeError(f"For clip_by_norm, the total norm of order {norm_type} from input is non-finite.")
+    clip_coef = max_norm / (total_norm + 1e-6)
+    if clip_coef < 1:
+        ret = hyper_map(partial_op(F.mul, clip_coef), x)
+    else:
+        ret = x
+    if is_tensor:
+        return ret[0]
+    return ret
+
+
 def clip_by_value(x, clip_value_min=None, clip_value_max=None):
     r"""
     Clips tensor values to a specified min and max.
@@ -115,6 +182,7 @@ def clip_by_value(x, clip_value_min=None, clip_value_max=None):
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
     """
+
     def _clip_by_value(clip_min, clip_max, x):
         if not isinstance(x, Tensor):
             raise TypeError("For 'clip_by_value', the type of argument 'x' must be "
@@ -193,23 +261,23 @@ def clamp(input, min=None, max=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> # case 1: the data type of x is Tensor
+        >>> # 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)
-        >>> x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp(x, min_value, max_value)
+        >>> input = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> output = ops.clamp(input, min_value, max_value)
         >>> print(output)
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
-        >>> # case 2: the data type of x is list[Tensor]
+        >>> # case 2: the data type of input is list[Tensor]
         >>> min_value = 5
         >>> max_value = 20
-        >>> x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> y = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp([x,y], min_value, max_value)
+        >>> 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.]

mindspore/ops/function/debug_func.py

@@ -34,7 +34,7 @@ def print_(*input_x):
         This function is used for debugging. When too much data is printed at the same time,
         in order not to affect the main process, the framework may discard some data. If you need to record the
         data completely, you are recommended to use the `Summary` function, and can check
-        `Summary <https://www.mindspore.cn/mindinsight/docs/en/r2.1/summary_record.html>`_.
+        `Summary <https://www.mindspore.cn/mindinsight/docs/en/r2.2/summary_record.html>`_.
 
     Args:
         input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print_.

mindspore/ops/function/grad/grad_func.py

@@ -655,7 +655,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.1/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/r2.2/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
@@ -862,16 +862,23 @@ def _check_tensor(inputs):
     return True
 
 
-def vjp(fn, *inputs, has_aux=False):
+_vjp_grad_op = _Grad(get_all=True, sens_param=True, merge_forward=True)
+_vjp_grad_op_with_weight = _Grad(get_all=True, get_by_list=True, sens_param=True, merge_forward=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/r2.1/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/r2.2/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
             Tensors.
         inputs (Union[Tensor, tuple[Tensor], list[Tensor]]): The inputs to `fn` .
+        weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
+            calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
+            Default: ``None`` .
         has_aux (bool): If True, only the first output of `fn` contributes the gradient of `fn`, while the other outputs
             will be returned straightly. It means the `fn` must return more than one outputs in this case.
             Default: ``False``.
@@ -947,9 +954,12 @@ def vjp(fn, *inputs, has_aux=False):
             fn_ = aux_fn
         else:
             fn_ = fn
+        sens = v
         if len(v) == 1:
-            return _grad_all(fn_)(*inputs, v[0])
-        return _grad_all(fn_)(*inputs, v)
+            sens = v[0]
+        if weights is None:
+            return _vjp_grad_op(fn_)(*inputs, sens)
+        return _vjp_grad_op_with_weight(fn_, weights)(*inputs, sens)
 
     res = fn(*inputs)
     if has_aux:
@@ -1058,7 +1068,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.1/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/r2.2/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.
 
@@ -1229,7 +1239,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.1/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/r2.2/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.
 
@@ -1360,7 +1370,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.1/beginner/autograd.html#stop-gradient>`_.
+    <https://www.mindspore.cn/tutorials/en/r2.2/beginner/autograd.html#stop-gradient>`_.
 
     Args:
         value (Any): The value whose effect on the gradient to be eliminated.

mindspore/ops/function/image_func.py

@@ -184,10 +184,16 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
             the output size of the cropped and resized images.
             Only positive values are supported. Supported type: int32.
         method (str, optional): An optional string that specifies the sampling method for resizing.
-            It can be ``"bilinear"`` , ``"nearest"`` or ``"bilinear_v2"`` . The option ``"bilinear"`` stands for
-            standard bilinear interpolation algorithm, while ``"bilinear_v2"`` may result in better result in some
-            cases. ``"nearest"`` is the nearest neighbor interpolation algorithm.
-            Default: ``"bilinear"`` .
+            It can be ``"bilinear"`` , ``"nearest"`` or ``"bilinear_v2"`` . Default: ``"bilinear"`` .
+
+            - ``"nearest"``: Nearest neighbor interpolation. Each output pixel is assigned the value of the
+              nearest input pixel. This method is simple and fast but can result in blocky or pixelated outputs.
+            - ``"bilinear"``: Bilinear interpolation. Each output pixel is a weighted average of the four nearest input
+              pixels, computed using bilinear interpolation. This method produces smoother results compared
+              to nearest neighbor interpolation.
+            - ``"bilinear_v2"``: The optimized variant of
+              ``"bilinear"``, it may achieve better result(higher precision and speed) in some cases.
+
         extrapolation_value (float, optional): An optional float value used extrapolation, if applicable.
             Default: ``0.0`` .
 

mindspore/ops/function/linalg_func.py

@@ -79,7 +79,7 @@ def cond(A, p=None):
         >>> print(ms.ops.cond(x))
         1.4142
         >>> print(ms.ops.cond(x, 'fro'))
-        1.1623
+        3.1622777
     """
     matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
     if p is None:
@@ -275,7 +275,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.1/api_python/ops/mindspore.ops.svd.html>`_ .
+    `x.svd <https://www.mindspore.cn/docs/en/r2.2/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
@@ -285,13 +285,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.1/api_python/ops/mindspore.ops.Eps.html>`_ value of x.dtype.
+    `eps <https://www.mindspore.cn/docs/en/r2.2/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.1/api_python/ops/mindspore.ops.svd.html>`_ internally,
-        (or `eigh <https://www.mindspore.cn/docs/en/r2.1/api_python/scipy/mindspore.scipy.linalg.eigh.html>`_ ,
+        `svd <https://www.mindspore.cn/docs/en/r2.2/api_python/ops/mindspore.ops.svd.html>`_ internally,
+        (or `eigh <https://www.mindspore.cn/docs/en/r2.2/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().