mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/train/amp.py

@@ -17,8 +17,7 @@ from __future__ import absolute_import
 
 import mindspore as ms
 from mindspore import nn
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.nn.wrap.cell_wrapper import _TrainPipelineAccuStepCell
 from mindspore.nn.wrap.loss_scale import _TrainPipelineWithLossScaleCell
@@ -27,12 +26,14 @@ from mindspore.parallel._utils import _get_pipeline_stages
 from mindspore.train.loss_scale_manager import DynamicLossScaleManager, LossScaleManager
 from mindspore import boost, context
 from mindspore.ops import operations as P
+from mindspore.ops import Primitive
+from mindspore import log as logger
 
 
 STREE = None
 
 
-AMP_WHITE_LIST_Cell = (
+AMP_WHITE_LIST = [
     nn.Conv1d,
     nn.Conv2d,
     nn.Conv3d,
@@ -42,11 +43,7 @@ AMP_WHITE_LIST_Cell = (
     nn.Dense,
     nn.LSTMCell,
     nn.RNNCell,
-    nn.GRUCell
-)
-
-
-AMP_WHITE_LIST_OPS = (
+    nn.GRUCell,
     P.Conv2D,
     P.Conv3D,
     P.Conv2DTranspose,
@@ -57,106 +54,173 @@ AMP_WHITE_LIST_OPS = (
     P.PReLU,
     P.ReLU,
     P.Ger
-)
+]
 
 
-AMP_BLACK_LIST = (
+AMP_BLACK_LIST = [
     nn.BatchNorm1d,
     nn.BatchNorm2d,
     nn.BatchNorm3d,
     nn.LayerNorm
-)
+]
 
 
 class _OutputTo16(nn.Cell):
     """Wrap cell for amp. Cast network output back to float16."""
-
-    def __init__(self, op):
+    def __init__(self, backbone):
         super(_OutputTo16, self).__init__(auto_prefix=False)
-        self._op = op
+        self._backbone = backbone
+        if isinstance(backbone, nn.Cell) and backbone.jit_config_dict:
+            self._jit_config_dict = backbone.jit_config_dict
 
     def construct(self, x):
-        return F.cast(self._op(x), mstype.float16)
+        return F.cast(self._backbone(x), mstype.float16)
 
 
 class _OutputTo32(nn.Cell):
-    "Wrap loss for amp. Cast network output back to float32"
-
+    """Wrap loss for amp. Cast network output back to float32."""
     def __init__(self, backbone):
         super(_OutputTo32, self).__init__(auto_prefix=False)
         self._backbone = backbone
-        self._jit_config_dict = backbone._jit_config_dict
+        if isinstance(backbone, nn.Cell) and backbone.jit_config_dict:
+            self._jit_config_dict = backbone.jit_config_dict
 
     def construct(self, *inputs):
         out = self._backbone(*inputs)
         return F.mixed_precision_cast(mstype.float32, out)
 
 
-def _insert_cast_operator(stree):
+def _allow_mix_precision(node, allowed_list) -> bool:
+    """
+    Check whether current node need do mix precision. Follow conditions need to be satisfied:
+        1) Type of node is one of (Primitive, nn.Cell)
+        2) Node is not P.Cast()
+        3) to_float(mindspore.float16) is not set in Cell
+    """
+    if node.get_instance() in allowed_list:
+        return True
+    if not issubclass(node.get_instance_type(), (Primitive, nn.Cell)):
+        return False
+    if isinstance(node.get_instance(), P.Cast):
+        return False
+    if issubclass(node.get_instance_type(), nn.Cell):
+        # if cell is already in allowed_list, it means to_float(mindspore.float16) is set by amp.
+        # if cell is not in allowed_list, but has to_float(mindspore.float16),
+        # it means to_float(mindspore.float16) is set by user.
+        if node.get_instance().to_float_fp16:
+            return False
+    allowed_list.append(node.get_instance())
+    return True
+
+
+def _insert_cast_operator_process(node, stree):
     """insert cast for operators in white_list."""
     new_cast_node = None
+    # insert cast float16 before the primitive operators
+    if issubclass(node.get_instance_type(), Primitive):
+        for idx in range(len(node.get_inputs())):
+            position = stree.before(node)
+            new_node = P.Cast()
+            arg = ms.rewrite.ScopedValue.create_name_values([node.get_inputs()[idx].get_targets()[0].value,
+                                                             "mindspore.float16"])
+            new_cast_node = ms.rewrite.Node.create_call_cell(new_node,
+                                                             targets=['x_cast_{}'.format(node.get_name())],
+                                                             args=arg,
+                                                             name='incast_{}{}'.format(node.get_name(), idx))
+            stree.insert(position, new_cast_node)
+            node.set_arg_by_node(idx, new_cast_node)
+    # insert cast float16 before the Cell operators
+    elif issubclass(node.get_instance_type(), nn.Cell):
+        node.get_instance().to_float(mstype.float16)
+    # ignore if subclass is not one of (Primitive, nn.Cell)
+    else:
+        return
+
+    # insert cast float32 after the operators
+    position = stree.after(node)
+    new_node = P.Cast()
+    arg = ms.rewrite.ScopedValue.create_name_values([node.get_targets()[0].value,
+                                                     "mindspore.float32"])
+    new_cast_node = ms.rewrite.Node.create_call_cell(new_node,
+                                                     targets=['x_cast_{}'.format(node.get_name())],
+                                                     args=arg,
+                                                     name='outcast_{}'.format(node.get_name()))
+    # insert node & unique names
+    stree.insert(position, new_cast_node)
+    # update argument names
+    for user in node.get_users():
+        if user.get_name() == new_cast_node.get_name():
+            continue
+        for idx, arg in enumerate(user.get_args()):
+            if arg == node.get_targets()[0]:
+                user.set_arg_by_node(idx, new_cast_node)
+
+
+def _insert_cast_operator_white_list(stree, white_list):
+    """insert cast for operators in white_list."""
+    allowed_list = []
     for node in stree.nodes():
         if node.get_targets() is None:
             continue
-        in_white_list = False
-        if node.get_node_type() != ms.rewrite.NodeType.Tree:
-            # insert cast before the primitive operators in white_list
-            if node.get_instance_type() in AMP_WHITE_LIST_OPS:
-                in_white_list = True
-                for idx in range(len(node.get_inputs())):
-                    position = stree.before(node)
-                    new_node = P.Cast()
-                    arg = ms.rewrite.ScopedValue.create_name_values([node.get_inputs()[idx].get_targets()[0].value,
-                                                                     "mindspore.float16"])
-                    new_cast_node = ms.rewrite.Node.create_call_cell(new_node,
-                                                                     targets=['x_cast_{}'.format(node.get_name())],
-                                                                     args=arg,
-                                                                     name='incast_{}{}'.format(node.get_name(), idx))
-                    stree.insert(position, new_cast_node)
-                    node.set_arg_by_node(idx, new_cast_node)
-            # insert cast before the Cell operators in white_list
-            elif node.get_instance_type() in AMP_WHITE_LIST_Cell:
-                in_white_list = True
-                node.get_instance().to_float(mstype.float16)
-
-            # insert cast after the operators in white_list
-            if in_white_list:
-                position = stree.after(node)
-                new_node = P.Cast()
-                arg = ms.rewrite.ScopedValue.create_name_values([node.get_targets()[0].value,
-                                                                 "mindspore.float32"])
-                new_cast_node = ms.rewrite.Node.create_call_cell(new_node,
-                                                                 targets=['x_cast_{}'.format(node.get_name())],
-                                                                 args=arg,
-                                                                 name='outcast_{}'.format(node.get_name()))
-                for i in range(len(node.get_users())):
-                    follow_node = node.get_users()[i]
-                    stree.insert(position, new_cast_node)
-                    idx = follow_node.get_args().index(node.get_targets()[0])
-                    follow_node.set_arg_by_node(idx, new_cast_node)
-        else:
+        if node.get_node_type() == ms.rewrite.NodeType.CellContainer:
+            for n in node.get_handler().node_list:
+                if n.get_node_type() == ms.rewrite.NodeType.Tree:
+                    _insert_cast_operator_white_list(ms.rewrite.TreeNodeHelper.get_sub_tree(ms.rewrite.Node(n)),
+                                                     white_list)
+        elif node.get_node_type() == ms.rewrite.NodeType.Tree:
             substree = ms.rewrite.TreeNodeHelper.get_sub_tree(node)
-            _insert_cast_operator(substree)
-
-
-def _removed_cast_pair(node):
-    """the cast pairs should be removed."""
-    for i in range(len(node.get_users())):
-        follow_node = node.get_users()[i]
-        if follow_node.get_instance_type() != P.Cast:
-            return False
-    node_dtype = node.get_args()[1]
-    if len(node.get_users()).__trunc__() == 0:
+            _insert_cast_operator_white_list(substree, white_list)
+        elif node.get_instance_type() in white_list and _allow_mix_precision(node, allowed_list):
+            _insert_cast_operator_process(node, stree)
+
+
+def _need_removed_cast_pair(node):
+    """check whether the cast pairs should be removed."""
+    cast_dtypes = ms.rewrite.ScopedValue.create_name_values(["mindspore.float16", "mindspore.float32"])
+    cast_dtype_f16 = cast_dtypes[0]
+    cast_dtype_f32 = cast_dtypes[1]
+    # current node should be P.Cast()(x, mindspore.float32)
+    if node.get_instance_type() != P.Cast:
         return False
-    follow_node_dtype = node.get_users()[0].get_args()[1]
-    for i in range(1, len(node.get_users())):
-        dtype = node.get_users()[i].get_args()[1]
-        if dtype == follow_node_dtype:
-            continue
-    if i == len(node.get_users()) - 1 and follow_node_dtype != node_dtype:
-        return True
+    node_cast_type = node.get_args()[1]
+    if node_cast_type != cast_dtype_f32:
+        return False
+    # all user nodes should be P.Cast()(x, mindspore.float16) or Cell with to_float(mindspore.float16)
+    if not node.get_users():
+        return False
+    for user in node.get_users():
+        if isinstance(user.get_instance(), nn.Cell):
+            if not user.get_instance().to_float_fp16:
+                return False
+        elif user.get_instance_type() == P.Cast:
+            user_cast_type = user.get_args()[1]
+            if user_cast_type != cast_dtype_f16:
+                return False
+        else:
+            return False
+    return True
 
-    return False
+
+def _removed_cast_pair_process(stree, cast_f32_node):
+    """remove the duplicated cast operators."""
+    for user_node in cast_f32_node.get_users():
+        # remove cast f16 nodes
+        if user_node.get_instance_type() == P.Cast:
+            cast_f16_node = user_node
+            # modify arguments using cast_f16's target[0] to cast_f32's args[0], which is f16 type
+            for cast_f16_user in cast_f16_node.get_users():
+                for idx, arg in enumerate(cast_f16_user.get_args()):
+                    if arg == cast_f16_node.get_targets()[0]:
+                        cast_f16_user.set_arg(idx, cast_f32_node.get_args()[0])
+            stree.erase_node(cast_f16_node)
+        # update args of cell f16 nodes
+        elif isinstance(user_node.get_instance(), nn.Cell):
+            cell_f16_node = user_node
+            for idx, arg in enumerate(cell_f16_node.get_args()):
+                if arg == cast_f32_node.get_targets()[0]:
+                    cell_f16_node.set_arg(idx, cast_f32_node.get_args()[0])
+    # remove the cast f32 node
+    stree.erase_node(cast_f32_node)
 
 
 def _remove_duplicated_cast(stree):
@@ -164,36 +228,28 @@ def _remove_duplicated_cast(stree):
     for node in stree.nodes():
         if node.get_targets() is None:
             continue
-        if node.get_node_type() != ms.rewrite.NodeType.Tree:
-            if node.get_instance_type() == P.Cast and _removed_cast_pair(node):
-                # remove the following cast node first
-                len_users = len(node.get_users())
-                for i in range(len_users):
-                    follow_node = node.get_users()[i]
-                    for n in follow_node.get_users():
-                        idx = n.get_args().index(follow_node.get_targets()[0])
-                        n.set_arg_by_node(idx, node.get_inputs()[0])
-                    stree.erase_node(follow_node)
-                # remove the current cast node
-                stree.erase_node(node)
-        else:
+        if node.get_node_type() == ms.rewrite.NodeType.CellContainer:
+            for n in node.get_handler().node_list:
+                if n.get_node_type() == ms.rewrite.NodeType.Tree:
+                    _remove_duplicated_cast(ms.rewrite.TreeNodeHelper.get_sub_tree(ms.rewrite.Node(n)))
+        elif node.get_node_type() == ms.rewrite.NodeType.Tree:
             substree = ms.rewrite.TreeNodeHelper.get_sub_tree(node)
             _remove_duplicated_cast(substree)
+        elif _need_removed_cast_pair(node):
+            _removed_cast_pair_process(stree, node)
 
 
-def _auto_white_list(network):
+def _auto_white_list(network, white_list):
     """process the white list of network."""
     global STREE
     STREE = ms.rewrite.SymbolTree.create(network)
-    _insert_cast_operator(STREE)
+    _insert_cast_operator_white_list(STREE, white_list)
     _remove_duplicated_cast(STREE)
     return STREE.get_network()
 
 
-def _auto_black_list(network, black_list=None):
+def _auto_black_list(network, black_list):
     """process the black list of network."""
-    if black_list is None:
-        black_list = AMP_BLACK_LIST
     network.to_float(mstype.float16)
     cells = network.name_cells()
     change = False
@@ -201,7 +257,7 @@ def _auto_black_list(network, black_list=None):
         subcell = cells[name]
         if subcell == network:
             continue
-        if isinstance(subcell, black_list):
+        if isinstance(subcell, tuple(black_list)):
             network._cells[name] = _OutputTo16(subcell.to_float(mstype.float32))
             change = True
         else:
@@ -234,12 +290,13 @@ def auto_mixed_precision(network, amp_level="O0"):
     """
     if not isinstance(network, nn.Cell):
         raise TypeError("The network type should be Cell.")
+
     if amp_level == "O0":
         pass
     elif amp_level == "O1":
-        return _auto_white_list(network)
+        return _auto_white_list(network, AMP_WHITE_LIST)
     elif amp_level == "O2":
-        _auto_black_list(network)
+        _auto_black_list(network, AMP_BLACK_LIST)
     elif amp_level == "O3":
         network.to_float(mstype.float16)
     else:
@@ -257,7 +314,7 @@ def _do_keep_batchnorm_fp32(network):
         subcell = cells[name]
         if subcell == network:
             continue
-        elif isinstance(subcell, AMP_BLACK_LIST):
+        elif isinstance(subcell, nn.Cell) and isinstance(subcell, tuple(AMP_BLACK_LIST)):
             network._cells[name] = _OutputTo16(subcell.to_float(mstype.float32))
             change = True
         else:
@@ -308,8 +365,8 @@ def _check_level(level, boost_level):
     if not isinstance(level, str):
         raise TypeError("The argument `level` must be a string in ['O0', 'O1', 'O2', 'O3', 'auto'], \
                          but got type {}.".format(type(level)))
-    validator.check('level', level, "", ['O0', 'O1', 'O2', 'O3', 'auto'], Rel.IN)
-    validator.check('boost_level', boost_level, "", ['O0', 'O1', 'O2'], Rel.IN)
+    validator.check('level', level, "", ['O0', 'O1', 'O2', 'O3', 'auto'], validator.IN)
+    validator.check('boost_level', boost_level, "", ['O0', 'O1', 'O2'], validator.IN)
 
     if level == "auto":
         device_target = context.get_context('device_target')
@@ -331,13 +388,12 @@ def _add_loss_network(network, loss_fn, cast_model_type):
     """Add loss network."""
 
     class WithLossCell(nn.Cell):
-        "Wrap loss for amp. Cast network output back to float32"
-
+        """Wrap loss for amp. Cast network output back to float32."""
         def __init__(self, backbone, loss_fn):
             super(WithLossCell, self).__init__(auto_prefix=False)
             self._backbone = backbone
             self._loss_fn = loss_fn
-            if backbone.jit_config_dict:
+            if isinstance(backbone, nn.Cell) and backbone.jit_config_dict:
                 self._jit_config_dict = backbone.jit_config_dict
 
         def construct(self, data, label):
@@ -366,6 +422,8 @@ def build_train_network(network, optimizer, loss_fn=None, level='O0', boost_leve
 
             - "O0": Do not change.
             - "O1": Cast the operators in white_list to float16, the remaining operators are kept in float32.
+              The operators in the whitelist: [Conv1d, Conv2d, Conv3d, Conv1dTranspose, Conv2dTranspose,
+              Conv3dTranspose, Dense, LSTMCell, RNNCell, GRUCell, MatMul, BatchMatMul, PReLU, ReLU, Ger].
             - "O2": Cast network to float16, keep batchnorm and `loss_fn` (if set) run in float32,
               using dynamic loss scale.
             - "O3": Cast network to float16, with additional property `keep_batchnorm_fp32=False` .
@@ -460,3 +518,116 @@ def build_train_network(network, optimizer, loss_fn=None, level='O0', boost_leve
     else:
         network = nn.TrainOneStepCell(network, optimizer, loss_scale).set_train()
     return network
+
+
+def get_white_list():
+    """
+    Provide a copy of internal white list used by auto mixed precision.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Returns:
+        list, A copy of internal white list.
+    """
+    white_list = AMP_WHITE_LIST.copy()
+    return white_list
+
+
+def get_black_list():
+    """
+    Provide a copy of internal black list used by auto mixed precision.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Returns:
+        list, A copy of internal black list.
+    """
+    black_list = AMP_BLACK_LIST.copy()
+    return black_list
+
+
+def custom_mixed_precision(network, *, white_list=None, black_list=None):
+    """
+    Custom mixed precision by setting whitelist or blacklist.
+    When the `white_list` is provided, primitives and cells in `white_list` will perform the precision conversion.
+    When the `black_list` is provided, primitives and cells that are not in `black_list` will perform the pereision
+    conversion.
+    Only one of `white_list` and `black_list` should be provided.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Note:
+        - `custom_mixed_precision` should not be used at the same time as `auto_mixed_precision` . When both
+          `build_train_network` and `custom_mixed_precision` are used, `build_train_network` need to be called with
+          `level='O0'` before call `custom_mixed_precision` .
+        - Primitives for blacklist is not support yet.
+
+    Args:
+        network (Cell): Definition of the network.
+        white_list (list[Primitive, Cell], optional): White list of custom mixed precision. Defaults: None, means
+            white list is not used.
+        black_list (list[Primitive, Cell], optional): Black list of custom mixed precision. Defaults: None, means
+            black list is not used.
+
+    Returns:
+        network (Cell), A network supporting mixed precision.
+
+    Raises:
+        TypeError: The network type is not Cell.
+        ValueError: Neither `white_list` nor `black_list` is provided.
+        ValueError: Both `white_list` and `black_list` are provided.
+
+    Examples:
+        >>> from mindspore import amp
+        >>> net = MyNet()
+        >>> custom_white_list = amp.get_white_list()
+        >>> custom_white_list.append(nn.Tanhshrink)
+        >>> net = amp.custom_mixed_precision(net, white_list=custom_white_list)
+    """
+    if not isinstance(network, nn.Cell):
+        raise TypeError("The network type should be Cell.")
+
+    if white_list is None and black_list is None:
+        raise ValueError("For custom_mixed_precision, one of white_list and black_list must be provided.")
+
+    if white_list is not None and black_list is not None:
+        raise ValueError("For custom_mixed_precision, the white_list or black_list cannot be provided "
+                         "at the same time, please provide one or the other.")
+
+    if white_list is not None:
+        _list_check(white_list, "white_list")
+        return _auto_white_list(network, white_list)
+
+    _list_check(black_list, "black_list")
+    _auto_black_list(network, black_list)
+    network = _OutputTo32(network)
+    return network
+
+
+def _list_check(custom_list: list, list_name: str):
+    """
+    check whether custom list is valid
+
+    Raises:
+        TypeError: The type of custom_list is not list.
+        TypeError: The element in custom_list is not a class.
+        TypeError: The subclass of element in custom_list is not one of ['Cell', 'Primitive'].
+    """
+    if not isinstance(custom_list, list):
+        raise TypeError(f"The type of {list_name} should be list, but got {type(custom_list)}")
+
+    for elem in custom_list:
+        if not isinstance(elem, type):
+            raise TypeError(f"The element in {list_name} should be a class, but got {elem}")
+
+        if not issubclass(elem, nn.Cell) and not issubclass(elem, Primitive):
+            raise TypeError(f"The subclass of element in {list_name} should be one of 'Cell' and 'Primitive', "
+                            f"but got {elem}")
+
+    if list_name == 'black_list':
+        for elem in AMP_BLACK_LIST:
+            if elem not in custom_list:
+                logger.warning(f"{elem} is removed from internal black list.")

mindspore/train/callback/_backup_and_restore.py

@@ -22,7 +22,7 @@ from mindspore import log as logger
 from mindspore.train.serialization import load_checkpoint, save_checkpoint
 from mindspore.train.callback._callback import Callback
 from mindspore.train._utils import _make_directory
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 
 
 class BackupAndRestore(Callback):
@@ -34,7 +34,7 @@ class BackupAndRestore(Callback):
 
     Args:
         backup_dir (str): Path to store and load the checkpoint file.
-        save_freq(Union['epoch', int]): When set to `'epoch'` the callback saves the checkpoint at the end of
+        save_freq(Union['epoch', int]): When set to 'epoch' the callback saves the checkpoint at the end of
                                         each epoch. When set to an integer, the callback saves the checkpoint
                                         every `save_freq` epoch. Default: 'epoch'.
         delete_checkpoint(bool): If `delete_checkpoint=True`, the checkpoint will be deleted after
@@ -49,8 +49,8 @@ class BackupAndRestore(Callback):
         .. note::
             Before running the following example, you need to customize the network LeNet5 and
             dataset preparation function create_dataset. Refer to
-            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0.0-alpha/beginner/model.html>`_
-            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0.0-alpha/beginner/dataset.html>`_ .
+            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0/beginner/model.html>`_
+            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0/beginner/dataset.html>`_ .
 
         >>> from mindspore import nn
         >>> from mindspore.train import Model, BackupAndRestore
@@ -69,7 +69,7 @@ class BackupAndRestore(Callback):
         ckpt_dir = _make_directory(backup_dir)
         self.backup_file = os.path.join(ckpt_dir, 'backup.ckpt')
         if save_freq != "epoch":
-            self.save_freq = Validator.check_positive_int(step_size)
+            self.save_freq = Validator.check_positive_int(save_freq)
         else:
             self.save_freq = 1
         self.delete_checkpoint = Validator.check_bool(delete_checkpoint)

mindspore/train/callback/_callback.py

@@ -93,7 +93,7 @@ class Callback:
     recording current attributes. Users can add custimized attributes to the information.
     Training process can also be stopped by calling `request_stop` method. For details
     of custom Callback, please check
-    `Callback <https://www.mindspore.cn/tutorials/experts/en/r2.0.0-alpha/debug/custom_debug.html>`_.
+    `Callback <https://www.mindspore.cn/tutorials/experts/en/r2.0/debug/custom_debug.html>`_.
 
     Examples:
         >>> import numpy as np
@@ -437,7 +437,7 @@ class RunContext:
     `RunContext.original_args()` and add extra attributes to the information, but also can stop the
     training process by calling `request_stop` method. For details of custom Callback,
     please check
-    `Callback <:https//www.mindspore.cn/tutorials/experts/en/r2.0.0-alpha/debug/custom_debug.html>`_.
+    `Callback <:https//www.mindspore.cn/tutorials/experts/en/r2.0/debug/custom_debug.html>`_.
 
     `RunContext.original_args()` holds the model context information as a dictionary variable, and
     different attributes of the dictionary are stored in training or eval process. Details are as follows:

mindspore/train/callback/_checkpoint.py

@@ -23,7 +23,7 @@ import threading
 import mindspore.context as context
 from mindspore import log as logger
 from mindspore import nn
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.train._utils import _make_directory
 from mindspore.train.serialization import save_checkpoint, _save_graph
 from mindspore.parallel._cell_wrapper import destroy_allgather_cell
@@ -107,8 +107,8 @@ class CheckpointConfig:
         .. note::
             Before running the following example, you need to customize the network LeNet5 and
             dataset preparation function create_dataset. Refer to
-            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0.0-alpha/beginner/model.html>`_
-            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0.0-alpha/beginner/dataset.html>`_ .
+            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0/beginner/model.html>`_
+            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0/beginner/dataset.html>`_ .
 
         >>> from mindspore import nn
         >>> from mindspore.common.initializer import Normal

mindspore/train/callback/_early_stop.py

@@ -21,7 +21,7 @@ import numpy as np
 
 from mindspore import ops, nn
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.train.serialization import load_param_into_net
 from mindspore import log as logger
 from mindspore.ops import ReduceOp
@@ -85,8 +85,8 @@ class EarlyStopping(Callback):
         .. note::
             Before running the following example, you need to customize the network LeNet5 and
             dataset preparation function create_dataset. Refer to
-            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0.0-alpha/beginner/model.html>`_
-            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0.0-alpha/beginner/dataset.html>`_ .
+            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0/beginner/model.html>`_
+            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0/beginner/dataset.html>`_ .
 
         >>> from mindspore import nn
         >>> from mindspore.train import Model, EarlyStopping

mindspore/train/callback/_lambda_callback.py

@@ -26,8 +26,8 @@ class LambdaCallback(Callback):
     at the appropriate time (during `mindspore.train.Model.{train | eval | fit}`). Note that
     each stage of callbacks expects one positional arguments: `run_context`.
 
-    Note:
-        This is an experimental interface that is subject to change or deletion.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         on_train_epoch_begin (Function): called at each train epoch begin.