mindspore 2.1.0__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/_extends/parse/standard_method.py

@@ -24,11 +24,11 @@ from mindspore.common import mutable
 import mindspore.common._monad as monad
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
-    _extend, _dict_clear, _haskey, _update, _fromkeys
+    _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 
 from ... import _checkparam as validator
-from ..._checkparam import check_is_number, check_reshape_shp, prepare_shape_for_squeeze, \
-    check_axis_in_range, check_axis_valid, check_and_canonicalize_axes
+from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
+    check_axis_valid, check_and_canonicalize_axes
 from ...ops import functional as F
 from ...ops import operations as P
 from ...ops import composite
@@ -58,7 +58,6 @@ size_op_ = P.Size()
 _format = Format()
 _reduce_sum_default = P.ReduceSum()
 _reduce_sum_keepdims = P.ReduceSum(True)
-_mean_keepdims = P.ReduceMean(True)
 _csr_mm = _csr_ops.CSRMM()
 
 itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
@@ -92,10 +91,7 @@ def mean(x, axis=None, keep_dims=False):
         >>> print(output)
         2.0
     """
-    if axis is None:
-        axis = ()
-    reduce_mean = P.ReduceMean(keep_dims)
-    return reduce_mean(x, axis)
+    return F.mean(x, axis, keep_dims)
 
 
 def ndimension(x):
@@ -176,11 +172,7 @@ def all_(x, axis=(), keep_dims=False):
     Returns:
         Tensor, has the same data type as x.
     """
-
-    if axis is None:
-        axis = ()
-    reduce_all = P.ReduceAll(keep_dims)
-    return reduce_all(x, axis)
+    return F.all(x, axis, keep_dims)
 
 
 def angle(x):
@@ -816,12 +808,7 @@ def squeeze(x, axis=None):
         >>> print(x.shape)
         (2, 2)
     """
-    shape = F.shape(x)
-    if axis is None:
-        return F.squeeze(x)
-    # yield squeezed shape based on the axes
-    new_shape = prepare_shape_for_squeeze(shape, axis)
-    return F.reshape(x, new_shape)
+    return F.squeeze(x, axis)
 
 
 def unbind(input, dim=0):
@@ -856,17 +843,7 @@ def argmax(x, axis=None, keepdims=False):
         >>> print(a.argmax())
         5
     """
-    is_axis_none = False
-    if axis is None:
-        x = ravel(x)
-        axis = 0
-        is_axis_none = True
-    if x.dtype == mstype.bool_:
-        x = x.astype(mstype.int32)
-    out = P.Argmax(axis, mstype.int64)(x)
-    if keepdims and not is_axis_none:
-        out = expand_dims(out, axis)
-    return out
+    return F.argmax(x, axis, keepdims)
 
 
 def argmin(x, axis=None, keepdims=False):
@@ -1443,8 +1420,9 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
 
     e = F.eye(n, m, dtype)
     if offset >= m or offset <= -n:
-        e = F.fill(dtype, (n, m), 0)
-    elif offset != 0:
+        zero_shape = shape[:-2] + (0,)
+        return F.zeros(zero_shape, dtype)
+    if offset != 0:
         e = e.astype(mstype.float32)
         if offset > 0:
             e_left = F.fill(dtype, (n, offset), 0)
@@ -1730,6 +1708,22 @@ def take(x, indices, axis=None, mode='clip'):
     return res.reshape(shape_out)
 
 
+def ms_type(input, dtype=None):
+    r"""
+    Change the dtype of the Tensor to the `dtype` . Return the type if `dtype` is None.
+    """
+    if dtype is None:
+        return str(input.dtype)
+    return input.astype(dtype)
+
+
+def type_as(input, other):
+    r"""
+    Change the dtype of `input` to the dtype of `other`.
+    """
+    return input.astype(other.dtype)
+
+
 def _infer_out_shape(*shapes):
     """
     Returns shape of output after broadcasting. Raises ValueError if shapes cannot be broadcast.
@@ -1737,8 +1731,8 @@ def _infer_out_shape(*shapes):
     shape_out = list()
     max_len = ms_max([len(it) for it in shapes])
     for i in range(max_len):
-        items = [it[i-(max_len-len(it))] if i - (max_len - len(it))
-                 >= 0 else 1 for it in shapes]
+        items = [it[i - (max_len - len(it))] if i - (max_len - len(it))
+                                                >= 0 else 1 for it in shapes]
         max_size = 0 if 0 in items else ms_max(items)
         shape_out.append(max_size)
     return tuple(shape_out)
@@ -1849,12 +1843,14 @@ def searchsorted(x, v, side='left', sorter=None):
         >>> print(x.searchsorted(3))
         2
     """
+
     def get_log2_size(size):
         """Get log2 size"""
         log2_res = F.log2(F.cast(size, mstype.float32))
         ceil_res = F.ceil(log2_res)
         cast_res = F.cast(ceil_res, mstype.int64)
         return cast_res
+
     if side not in ('left', 'right'):
         const_utils.raise_value_error('invalid value for keyword "side"')
     a = x.astype(mstype.float32)
@@ -1892,8 +1888,6 @@ def fill(x, value):
             const_utils.raise_type_error("If None is used as value, the original Tensor's dtype must be float.")
         value = nan_tensor
         return F.tile(value, x.shape).astype(x.dtype)
-    if not isinstance(value, (int, float, bool)):
-        const_utils.raise_type_error("input value must be a scalar.")
     return F.fill(x.dtype, x.shape, value)
 
 
@@ -2009,7 +2003,7 @@ def var(x, axis=None, ddof=0, keepdims=False):
         axis = ()
     else:
         axis = check_and_canonicalize_axes(axis, x.ndim)
-    x_mean = _mean_keepdims(x, axis)
+    x_mean = F.mean(x, axis, True)
     x_sub = F.tensor_sub(x, x_mean)
     x_pow = F.tensor_pow(x_sub, 2)
     if keepdims:
@@ -2117,27 +2111,14 @@ def sum(input, axis=None, dtype=None, keepdims=False, initial=None):  # pylint:
         >>> print(input_x.sum(axis=1))
         [10. 35.]
     """
-    input_x = input.astype(mstype.int32) if input.dtype == mstype.bool_ else input
-    dtype = input_x.dtype if dtype is None else dtype
-    dtype = check_astype_dtype_const(dtype)
-    if not isinstance(keepdims, int):
-        const_utils.raise_type_error("integer argument expected")
     if initial is not None and not isinstance(initial, (int, float, bool)):
-        const_utils.raise_type_error("initial argument should be a scalar.")
-    if axis is None:
-        axis = ()
-    else:
-        axis = check_and_canonicalize_axes(axis, input.ndim)
-
-    if not check_type_support(input_x.dtype, 'GPU', (mstype.float64, mstype.float32, mstype.float16)):
-        input_x = input_x.astype(mstype.float32)
-    if keepdims:
-        res = _reduce_sum_keepdims(input_x, axis)
-    else:
-        res = _reduce_sum_default(input_x, axis)
+        raise TypeError(f"For Tensor.sum, initial must be int, float or bool, but got {type(initial)}.")
+    res = F.sum(input, axis, keepdims)
     if initial is not None:
         res += initial
-    return res.astype(dtype)
+    if dtype is not None:
+        res = res.astype(dtype)
+    return res
 
 
 @_primexpr
@@ -2363,7 +2344,7 @@ def itemset(data, *args):
 
 def ms_iter(xs):
     """Implementation of `iter`."""
-    return xs.__ms_iter__()
+    return xs.__ms_iter__
 
 
 def ms_next(it):
@@ -2389,13 +2370,9 @@ def str_func(*data):
     if data_len == 0:
         return ''
     data = data[0]
-    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
-        const_utils.raise_type_error(
-            "str() does not support sparse tensor input.")
-    if not F.isconstant(data):
-        const_utils.raise_type_error(
-            "str() does not support non-constant input.")
-    return cast_to_str(data)
+    if F.isconstant(data):
+        return cast_to_str(data)
+    return data.__str__()
 
 
 @constexpr
@@ -2514,17 +2491,15 @@ def tuple_func(*data):
     """Implementation of `tuple`."""
     data_len = len(data)
     if data_len >= 2:
-        const_utils.raise_type_error("tuple() requires 0 or 1 arguments.")
+        raise TypeError("tuple() requires 0 or 1 arguments.")
     if data_len == 0:
         return F.make_tuple()
     data = data[0]
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
-        const_utils.raise_type_error(
-            "tuple() does not support single sparse tensor input.")
+        raise TypeError("tuple() does not support single sparse tensor input.")
     if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
         data_type = F.typeof(data)
-        const_utils.raise_type_error(
-            str(data_type) + " object is not iterable.")
+        raise TypeError(str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
     if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
@@ -2792,26 +2767,6 @@ def ms_len(data):
     return data.__len__()
 
 
-@constexpr
-def python_len_with_check(data):
-    """Return the result of python built-in len function with iterable check"""
-    if not hasattr(data, "__iter__"):
-        raise TypeError(str(type(data)) +
-                        " object is not iterable in graph mode.")
-    return len(data)
-
-
-def ms_len_with_iterable_check(data):
-    """Implementation of `len` with iterable check, used in len of condition."""
-    if not isinstance(data, Tensor) and F.isconstant(data):
-        return python_len_with_check(data)
-    if not hasattr(data, "__len__"):
-        type_str = str(F.typeof(data))
-        const_utils.raise_type_error(
-            type_str + " object is not iterable in graph mode.")
-    return data.__len__()
-
-
 def floor(x):
     """Rounds a tensor down to the closest integer element-wise."""
     return x.__floor__()
@@ -2864,14 +2819,10 @@ def enumerate_(x, start=0):
     x_type = F.typeof(x)
     ret = ()
     op_name = "enumerate"
-    if check_is_tuple_or_list_or_tensor(x_type, op_name, "first input") and \
-            check_is_const_int(start, op_name, "start"):
+    if check_is_const_int(start, op_name, "start"):
         if check_is_tensor(x_type):
             for i in range(x.shape[0]):
                 ret += ((start + i, x[i]),)
-        elif F.is_sequence_shape_unknown(x):
-            const_utils.raise_value_error(
-                "For 'enumerate', the dynamic length input is unsupported in graph mode")
         else:
             ret = zip(range(start, start + len(x)), x)
     return ret
@@ -2941,6 +2892,13 @@ def to_coo(x):
     return F.dense_to_sparse_coo(x)
 
 
+def tolist(x):
+    """
+    Convert a Tensor to List, if the input is Tensor scalar, Python scalar will be returned.
+    """
+    return x.asnumpy().tolist()
+
+
 @constexpr
 def check_select_condition(cond_type):
     """
@@ -3305,7 +3263,6 @@ def check_is_tuple_or_list_or_tensor(x, op_name, arg_name):
         f"For '{op_name}', the '{arg_name}' should be tuple or list or tensor, but got {x}.")
 
 
-@constexpr
 def check_is_const_int(x, op_name, arg_name):
     """check whether x is const int."""
     if x is None:
@@ -3652,6 +3609,11 @@ def dict_get(self_, key_index, default_value=None):
     return F.dict_getitem(self_, key_index)
 
 
+def dict_setitem(self_, key, target):
+    """Dictionary setitem"""
+    return _dict_setitem(self_, key, target)
+
+
 def dict_clear(self_):
     """Clear the dict"""
     return _dict_clear(self_)
@@ -3902,6 +3864,13 @@ def cos(x):
     return F.cos(x)
 
 
+def count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32):
+    r"""
+    For details, please refer to :func:`mindspore.ops.count_nonzero`.
+    """
+    return F.count_nonzero(x, axis, keep_dims, dtype)
+
+
 def cov(x, *, correction=1, fweights=None, aweights=None):
     r"""
     For details, please refer to :func:`mindspore.ops.cov`.
@@ -4180,7 +4149,8 @@ def expand(input, size):
     r"""
     Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
     """
-    return F.expand(input, size)
+    size = P.TensorToTuple()(size)
+    return F.broadcast_to(input, size)
 
 
 def cumprod(input, dim, dtype=None):
@@ -4202,6 +4172,13 @@ def div(input, value, *, rounding_mode=None):
     return F.div(input, value, rounding_mode=rounding_mode)
 
 
+def eq(input, other):
+    r"""
+    Computes the equivalence between the tensor `input` and the given input tensor `other` element-wise.
+    """
+    return F.equal(input, other)
+
+
 def equal(x, y):
     r"""
     Computes the equivalence between the tensor `x` and the given input tensor `y` element-wise.

mindspore/_extends/parse/trope.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-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.

mindspore/_extends/remote/kernel_build_server.py

@@ -15,7 +15,7 @@
 """kernel build server"""
 import os
 from mindspore import log as logger
-from mindspore._extends.parallel_compile.akg_compiler.akg_process import create_akg_parallel_process
+from mindspore._extends.parallel_compile.akg_compiler.akg_process import create_akg_parallel_process, create_akg_v2_parallel_process
 
 
 class Messager:
@@ -124,8 +124,8 @@ class Messager:
         raise NotImplementedError
 
 
-class AkgBuilder():
-    """Akg building wrapper"""
+class AkgBuilderBase():
+    """Base Class for kernel compiler building wrapper"""
 
     def __init__(self, platform):
         self.platform = platform
@@ -133,8 +133,9 @@ class AkgBuilder():
         self.akg_processor = None
 
     def create(self, process_num, waitime):
-        """ Create akg processor"""
-        self.akg_processor = create_akg_parallel_process(process_num, waitime, self.platform)
+        """ Create compiler processor"""
+        del process_num, waitime
+        raise NotImplementedError
 
     def accept_json(self, json):
         """ Accept json"""
@@ -145,7 +146,7 @@ class AkgBuilder():
         return self.akg_processor.compile(self.attrs)
 
     def handle(self, messager, arg):
-        """Handle message about akg"""
+        """Handle message about compiler"""
         if arg == 'AKG/START':
             messager.send_ack()
             process_num_str = messager.get_message()
@@ -172,7 +173,23 @@ class AkgBuilder():
                     messager.send_ack(False)
                     break
         else:
-            raise RuntimeError("Unknown message type: %s" % arg)
+            raise RuntimeError(f"Unknown message type: {arg}")
+
+
+class AkgBuilder(AkgBuilderBase):
+    """Akg building wrapper"""
+
+    def create(self, process_num, waitime):
+        """ Create akg processor"""
+        self.akg_processor = create_akg_parallel_process(process_num, waitime, self.platform)
+
+
+class AkgV2Builder(AkgBuilderBase):
+    """Akg V2 building wrapper"""
+
+    def create(self, process_num, waitime):
+        """ Create akg v2 processor"""
+        self.akg_processor = create_akg_v2_parallel_process(process_num, waitime, self.platform)
 
 
 def get_logger():

mindspore/_extends/remote/kernel_build_server_akg_v2.py

@@ -0,0 +1,55 @@
+# 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.
+# ============================================================================
+"""kernel build server for akg v2 kernels"""
+import sys
+import warnings
+from mindspore._extends.remote.kernel_build_server import Messager, get_logger, AkgV2Builder
+
+
+class AkgV2Messager(Messager):
+    '''
+    Default Messager for akg v2 kernels.
+    It works as a server, communicating with c++ client.
+    '''
+
+    def __init__(self, fdin, fdout):
+        super().__init__(fdin, fdout)
+        get_logger().info("[TRACE] AKG V2 Messager init...")
+        self.akg_v2_builder = AkgV2Builder("default")
+
+    def handle(self):
+        """
+        Communicate with remote client.
+        Reference protocol between them at PR#4063
+        """
+        arg = self.get_message()
+        if "AKG" in arg:
+            self.akg_v2_builder.handle(self, arg)
+        else:
+            self.send_ack(False)
+            self.exit()
+
+    def exit(self):
+        get_logger().info("[TRACE] AKG V2 Messager Exit...")
+        exit()
+
+
+if __name__ == '__main__':
+    warnings.simplefilter("ignore")
+    if len(sys.argv) != 3:
+        raise Exception(f"Incorrect argv: {sys.argv}")
+    get_logger().debug(f"[TRACE] argv: {str(sys.argv)}")
+    messager = AkgV2Messager(int(sys.argv[1]), int(sys.argv[2]))
+    messager.run()

mindspore/_install_custom.py

@@ -0,0 +1,43 @@
+# 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.
+# ============================================================================
+"""install custom op files"""
+
+import os
+import platform
+import importlib.util
+from mindspore import log as logger
+
+
+def _install_custom():
+    """install custom op files"""
+    if platform.system() != "Linux":
+        return
+    custom_op_path = os.environ.get("MS_DEV_CUSTOM_OPP_PATH")
+    if not custom_op_path:
+        return
+    if not os.path.isdir(custom_op_path):
+        logger.warning("The path set in env 'MS_DEV_CUSTOM_OPP_PATH' is not a directory: '{}'".format(custom_op_path))
+    else:
+        for file_name in os.listdir(custom_op_path):
+            file_path = os.path.join(custom_op_path, file_name)
+            if os.path.isfile(file_path) and file_name.endswith(".py") and file_name != "__init__.py":
+                logger.info("start import file: '{}'".format(file_path))
+                mod_spec = importlib.util.spec_from_file_location(os.path.splitext(file_name)[0], file_path)
+                mod = importlib.util.module_from_spec(mod_spec)
+                mod_spec.loader.exec_module(mod)
+    os.environ.pop("MS_DEV_CUSTOM_OPP_PATH")
+
+
+_install_custom()

mindspore/amp.py

@@ -15,11 +15,13 @@
 """ms function for mixed precision."""
 from __future__ import absolute_import
 
+import os
 from abc import ABC, abstractmethod
 from mindspore.common import mutable
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
 from mindspore import _checkparam as validator
+from mindspore._c_expression import MSContext
 from .common import dtype as mstype
 from . import context
 from . import ops
@@ -37,8 +39,13 @@ _partial = ops.Partial()
 
 
 @constexpr
-def _ascend_target():
-    return context.get_context("device_target") == "Ascend"
+def _ascend_910A_target():
+    return MSContext.get_instance().get_ascend_soc_version() == "ascend910"
+
+
+@constexpr
+def _ascend_910B_target():
+    return MSContext.get_instance().get_ascend_soc_version() == "ascend910b"
 
 
 @constexpr
@@ -72,9 +79,10 @@ def _overflow(inputs):
 
 
 @jit
-def _all_finite(inputs):
+def _all_finite(inputs, check_overflow_mode):
     """all finite check"""
-    if _ascend_target():
+    if (_ascend_910A_target()) or \
+       (_ascend_910B_target() and check_overflow_mode != "INFNAN_MODE"):
         status = Tensor([0] * 8, mstype.int32)
         status = ops.depend(status, inputs)
         get_status = _get_cache_prim(NPUGetFloatStatusV2)()(status)
@@ -83,6 +91,7 @@ def _all_finite(inputs):
         get_status = ops.depend(get_status, clear_status)
         status_finite = get_status.equal(Tensor(0, mstype.int32)).all()
         return status_finite
+
     outputs = _hypermap(_partial(_overflow), inputs)
     flag_sum = ops.addn(outputs).reshape(())
     status_finite = ops.less(flag_sum, 1)
@@ -117,10 +126,11 @@ def all_finite(inputs):
 
     Tutorial Examples:
         - `Automatic Mix Precision - Loss Scaling
-          <https://mindspore.cn/tutorials/en/r2.1/advanced/mixed_precision.html#loss-scaling>`_
+          <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
     """
     inputs = mutable(inputs)
-    return _all_finite(inputs)
+    _check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
+    return _all_finite(inputs, _check_overflow_mode)
 
 
 @jit_class
@@ -132,11 +142,36 @@ class LossScaler(ABC):
     to scale and unscale the loss value and gradients to avoid overflow, `adjust` is used to update the
     loss scale value.
 
-    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/r2.1/advanced/
+    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/r2.2/advanced/
     mixed_precision.html#loss-scaling>`_.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
+
+    Examples:
+        >>> from mindspore.amp import LossScaler, _grad_scale_map, _grad_unscale_map
+        >>> from mindspore import ops, Parameter, Tensor
+        >>> from mindspore.common import dtype as mstype
+        >>>
+        >>> class MyLossScaler(LossScaler):
+        ...     def __init__(self, scale_value):
+        ...         self.scale_value = Parameter(Tensor(scale_value, dtype=mstype.float32), name="scale_value")
+        ...
+        ...     def scale(self, inputs):
+        ...         inputs = mutable(inputs)
+        ...         return _grad_scale_map(self.scale_value, inputs)
+        ...
+        ...     def unscale(self, inputs):
+        ...         inputs = mutable(inputs)
+        ...         return _grad_unscale_map(self.scale_value, inputs)
+        ...
+        ...     def adjust(self, grads_finite):
+        ...         scale_mul_factor = self.scale_value * self.scale_factor
+        ...         scale_value = ops.select(grads_finite, scale_mul_factor, self.scale_value)
+        ...         ops.assign(self.scale_value, scale_value)
+        ...         return True
+        >>>
+        >>> loss_scaler = MyLossScaler(1024)
     """
     @abstractmethod
     def scale(self, inputs):
@@ -234,7 +269,8 @@ class StaticLossScaler(LossScaler):
 
     def adjust(self, grads_finite):
         """
-        `scale_value` is fixed.
+        Adjust `scale_value` in `LossScaler`. `scale_value` is fixed in `StaticLossScaler`, so this method
+        return False directly.
 
         Args:
             grads_finite (Tensor): a scalar bool Tensor indicating whether the grads are finite.
@@ -298,7 +334,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_scale_map(self.scale_value, inputs)
@@ -315,7 +351,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_unscale_map(self.scale_value, inputs)
@@ -329,7 +365,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
         """
         one = ops.ones((), self.scale_value.dtype)
         scale_mul_factor = self.scale_value * self.scale_factor