mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/train/model.py

@@ -23,28 +23,30 @@ import math
 import copy
 import numpy as np
 
+import mindspore
 from mindspore import log as logger
 from mindspore.train.serialization import save_checkpoint, load_checkpoint
 from mindspore.train.callback._checkpoint import ModelCheckpoint, _chg_ckpt_file_name_if_same_exist
 from mindspore.common.tensor import Tensor
-from mindspore.nn.metrics import get_metrics, get_metric_fn
-from mindspore._checkparam import check_input_data, check_output_data, Validator
+from mindspore.train.metrics import get_metrics, get_metric_fn
+from mindspore._checkparam import check_input_data, check_output_data
+from mindspore import _checkparam as Validator
 from mindspore.train.callback import _InternalCallbackParam, RunContext, _CallbackManager, Callback, TimeMonitor
 from mindspore.train.callback import __all__ as internal_cb_names
 from mindspore import context
-from mindspore.parallel._utils import _get_parallel_mode, _get_device_num, _get_global_rank, \
-    _get_parameter_broadcast, _device_number_check, _parameter_broadcast_check, _parallel_predict_check, \
+from mindspore.parallel._utils import _get_parallel_mode, _get_device_num, _get_parameter_broadcast, \
+    _device_number_check, _parameter_broadcast_check, _parallel_predict_check, \
     _reset_op_id_with_offset
 from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver, _is_role_sched, _is_ps_mode, \
     _cache_enable, _enable_distributed_mindrt
-from mindspore.nn.metrics import Loss
+from mindspore.train.metrics import Loss
 from mindspore import nn
 from mindspore.boost import AutoBoost
 from mindspore.context import ParallelMode
-from mindspore.parallel._cost_model_context import _set_multi_subgraphs
 from mindspore.parallel._recovery_context import _set_recovery_context, _get_recovery_context
 from mindspore.train.dataset_helper import DatasetHelper, connect_network_with_dataset
 from mindspore.common.api import _pynative_executor
+from mindspore.dataset.core.config import get_debug_mode
 from mindspore.dataset.engine.datasets import _set_training_dataset, _reset_training_dataset
 from mindspore.train import amp
 
@@ -125,14 +127,15 @@ class Model:
                              three elements: the positions of loss value, predicted value and label in outputs of the
                              `eval_network`. In this case, the loss value will be passed to the `Loss` metric, the
                              predicted value and label will be passed to other metrics.
-                             :func: `mindindex.nn.metric.set_indexes` is recommended instead of `eval_indexes`.
+                             :func:`mindspore.train.Metric.set_indexes` is recommended instead of `eval_indexes`.
                              Default: None.
-        amp_level (str): Option for argument `level` in :func:`mindspore.build_train_network`, level for mixed
+        amp_level (str): Option for argument `level` in :func:`mindspore.amp.build_train_network`, level for mixed
             precision training. Supports ["O0", "O1", "O2", "O3", "auto"]. Default: "O0".
 
             - "O0": Do not change.
             - "O1": Cast the operators in white_list to float16, the remaining operators are kept in float32.
-              This is an experimental feature and is subjected to change.
+              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 run in float32, using dynamic loss scale.
             - "O3": Cast network to float16, the BatchNorm is also cast to float16, loss scale will not be used.
             - auto: Set level to recommended level in different devices. Set level to "O2" on GPU, set
@@ -143,7 +146,7 @@ class Model:
             The BatchNorm strategy can be changed by `keep_batchnorm_fp32` settings in `kwargs`. `keep_batchnorm_fp32`
             must be a bool. The loss scale strategy can be changed by `loss_scale_manager` setting in `kwargs`.
             `loss_scale_manager` should be a subclass of :class:`mindspore.amp.LossScaleManager`.
-            The more detailed explanation of `amp_level` setting can be found at `mindspore.build_train_network`.
+            The more detailed explanation of `amp_level` setting can be found at `mindspore.amp.build_train_network`.
 
         boost_level (str): Option for argument `level` in `mindspore.boost`, level for boost mode
             training. Supports ["O0", "O1", "O2"]. Default: "O0".
@@ -163,8 +166,8 @@ class Model:
             the Graph mode + Ascend platform, and for better acceleration, refer to the documentation to configure
             boost_config_dict.
     Examples:
-        >>> import mindspore as ms
         >>> from mindspore import nn
+        >>> from mindspore.train import Model
         >>>
         >>> class Net(nn.Cell):
         ...     def __init__(self, num_class=10, num_channel=1):
@@ -190,10 +193,10 @@ class Model:
         >>> net = Net()
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
         >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics=None)
+        >>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
         >>> # For details about how to build the dataset, please refer to the variable `dataset_train` in tutorial
         >>> # document on the official website:
-        >>> # https://www.mindspore.cn/tutorials/zh-CN/r1.10/beginner/quick_start.html
+        >>> # https://www.mindspore.cn/tutorials/zh-CN/r2.0/beginner/quick_start.html
         >>> dataset = create_custom_dataset()
         >>> model.train(2, dataset)
     """
@@ -213,7 +216,6 @@ class Model:
         self._process_amp_args(kwargs)
         self._parallel_mode = _get_parallel_mode()
         self._device_number = _get_device_num()
-        self._global_rank = _get_global_rank()
         self._parameter_broadcast = _get_parameter_broadcast()
         self._metrics = metrics
 
@@ -323,11 +325,6 @@ class Model:
             network = nn.WithLossCell(network, self._loss_fn)
         # If need to check if loss_fn is not None, but optimizer is None
 
-        if self._parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
-            network.set_auto_parallel()
-            if self._optimizer is None:
-                # In this case, multiple optimizer(s) is supposed to be included in 'self._network'
-                _set_multi_subgraphs()
         if net_inputs is not None:
             network.set_inputs(*net_inputs)
         return network
@@ -368,18 +365,10 @@ class Model:
                 self._eval_network.set_inputs(*net_inputs)
             self._eval_indexes = [0, 1, 2]
 
-        if self._parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
-            if self._optimizer is None:
-                # In this case, multiple optimizer(s) is supposed to be included in 'self._network'
-                _set_multi_subgraphs()
-            self._eval_network.set_auto_parallel()
-
     def _build_predict_network(self):
         """Build the network for prediction."""
         self._predict_network = self._network
-        if self._parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
-            # Unlike the cases in build_train_network() and build_eval_network(), 'multi_subgraphs' is not set
-            self._predict_network.set_auto_parallel()
+        # Unlike the cases in build_train_network() and build_eval_network(), 'multi_subgraphs' is not set
 
     def _clear_metrics(self):
         """Clear metrics local values."""
@@ -408,13 +397,12 @@ class Model:
     def _get_metrics(self):
         """Get metrics local values."""
         metrics = dict()
-        # Embedding cache server as a storage service, no need to execute eval, just give fake metrics.
-        is_embedding_cache_server = _is_role_pserver() and _cache_enable()
+        # There's no need for server to execute eval, just give fake metrics.
         for key, value in self._metric_fns.items():
-            if not is_embedding_cache_server:
+            if not _is_role_pserver():
                 metrics[key] = value.eval()
             else:
-                metrics[key] = 0
+                metrics[key] = 1
         return metrics
 
     def _get_scaling_sens(self):
@@ -444,7 +432,7 @@ class Model:
         if dataset_sink_mode:
             network = connect_network_with_dataset(network, dataset_helper)
 
-        if is_train:
+        if _get_recovery_context("enable_recovery") and is_train:
             _set_training_dataset(dataset_helper)
 
 
@@ -452,9 +440,6 @@ class Model:
         network.phase = phase
         self._backbone_is_train = is_train
 
-        if self._parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
-            network.set_auto_parallel()
-
         return dataset_helper, network
 
     def _check_network_mode(self, network, is_train):
@@ -515,6 +500,10 @@ class Model:
         _device_number_check(self._parallel_mode, self._device_number)
 
         if train_dataset:
+            if not isinstance(train_dataset, mindspore.dataset.Dataset):
+                raise TypeError("The type of 'train_dataset' must be `Dataset`, "
+                                "but got {}.".format(type(train_dataset)))
+
             _parameter_broadcast_check(self._parallel_mode, self._parameter_broadcast)
             if self._parameter_broadcast:
                 self._train_network.set_broadcast_flag()
@@ -532,6 +521,9 @@ class Model:
                 break
 
         if valid_dataset:
+            if not isinstance(valid_dataset, mindspore.dataset.Dataset):
+                raise TypeError("The type of 'valid_dataset' must be `Dataset`, "
+                                "but got {}.".format(type(valid_dataset)))
             if not self._metric_fns:
                 raise RuntimeError("If define `valid_dataset`, metric fn can not be None or empty, "
                                    "you should set the argument 'metrics' for model.")
@@ -603,7 +595,7 @@ class Model:
             callbacks = cb_params.list_callback
         cb_params.train_dataset_element = None
         cb_params.network = self._network
-        if (_is_role_pserver() and not _enable_distributed_mindrt()) or _is_role_sched():
+        if _is_role_sched():
             epoch = 1
         # Embedding cache server only run one step.
         if (_is_role_pserver() or _is_role_sched()) and _cache_enable():
@@ -686,7 +678,7 @@ class Model:
             cb_params.train_network = train_network
 
             # Perform recovery for process which is restarted.
-            self._reset_training_step_for_abnormal_process(cb_params)
+            self._reset_training_step_for_abnormal_process(cb_params, dataset_helper)
             # Perform recovery for process which is not restarted.
             self._reset_training_step_for_normal_process(cb_params, dataset_helper)
 
@@ -702,19 +694,27 @@ class Model:
                 train_network = self._check_network_mode(train_network, True)
                 outputs = train_network(*inputs)
                 cb_params.net_outputs = outputs
+
+                if _is_role_sched():
+                    os._exit(0)
+
                 # In disaster recovery scenarios, need not to execute callbacks if this step executes failed.
                 need_exec_callback_step_end = not (self.enable_recovery and _get_recovery_context("need_reset"))
                 if need_exec_callback_step_end:
                     list_callback.on_train_step_end(run_context)
 
-                if (_is_role_pserver() and not _enable_distributed_mindrt()) or _is_role_sched():
-                    os._exit(0)
                 # Embedding cache server only run one step.
                 if is_embedding_cache_server:
                     break
 
             dataset_helper.continue_send()
 
+            # When it's distributed training and using MindRT,
+            # the node id should be reset to start from 0.
+            # This is to avoid the timeout when finding the actor route tables in 'train' and 'eval' case(or 'fit').
+            if _enable_distributed_mindrt():
+                _reset_op_id_with_offset()
+
             self._eval_during_train(valid_infos, cb_params, list_callback)
 
             # In disaster recovery scenarios, need not to execute callbacks if this epoch executes failed.
@@ -809,7 +809,7 @@ class Model:
         else:
             self.need_load_ckpt = False
 
-    def _reset_training_step_for_abnormal_process(self, cb_params):
+    def _reset_training_step_for_abnormal_process(self, cb_params, dataset_helper):
         """
         Execute recovery for abnormal exit process when restart.
 
@@ -824,7 +824,7 @@ class Model:
                 os.remove(cb_params.latest_ckpt_file)
                 raise RuntimeError(e.__str__() + ", load ckpt failed and remove the ckpt: "\
                                    + cb_params.latest_ckpt_file) from e
-            _reset_training_dataset(cb_params.cur_step_num)
+            _reset_training_dataset(cb_params.cur_step_num, dataset_helper.sink_size())
             self.need_load_ckpt = False
 
     def _reset_training_step_for_normal_process(self, cb_params, dataset_helper):
@@ -853,9 +853,9 @@ class Model:
                 self.epoch_iter = recovery_epoch_num
                 cb_params.cur_epoch_num = self.epoch_iter + 1
                 cb_params.last_save_ckpt_step = cb_params.cur_step_num
-                _reset_training_dataset(cb_params.cur_step_num)
+                _reset_training_dataset(cb_params.cur_step_num, dataset_helper.sink_size())
             else:
-                _reset_training_dataset(0)
+                _reset_training_dataset(0, dataset_helper.sink_size())
 
             _set_recovery_context(need_reset=False)
 
@@ -909,12 +909,12 @@ class Model:
                 outputs = self._train_network(*next_element)
                 cb_params.net_outputs = outputs
                 if self._loss_scale_manager and self._loss_scale_manager.get_drop_overflow_update():
-                    _, overflow, _ = outputs
+                    overflow = outputs[1]
                     overflow = np.all(overflow.asnumpy())
                     self._loss_scale_manager.update_loss_scale(overflow)
 
                 list_callback.on_train_step_end(run_context)
-                if (_is_role_pserver() and not _enable_distributed_mindrt()) or _is_role_sched():
+                if _is_role_sched():
                     os._exit(0)
                 # Embedding cache server only run one step.
                 if is_embedding_cache_server:
@@ -923,6 +923,12 @@ class Model:
                 if should_stop:
                     break
 
+            # When it's distributed training and using MindRT,
+            # the node id should be reset to start from 0.
+            # This is to avoid the timeout when finding the actor route tables in 'train' and 'eval' case(or 'fit').
+            if _enable_distributed_mindrt():
+                _reset_op_id_with_offset()
+
             self._eval_during_train(valid_infos, cb_params, list_callback)
 
             train_dataset.reset()
@@ -942,7 +948,7 @@ class Model:
 
         list_callback.on_train_end(run_context)
 
-    def train(self, epoch, train_dataset, callbacks=None, dataset_sink_mode=True, sink_size=-1, initial_epoch=0):
+    def train(self, epoch, train_dataset, callbacks=None, dataset_sink_mode=False, sink_size=-1, initial_epoch=0):
         """
         Training API.
 
@@ -980,7 +986,7 @@ class Model:
                                                             Default: None.
             dataset_sink_mode (bool): Determines whether to pass the data through dataset channel.
                                       Configure pynative mode or CPU, the training process will be performed with
-                                      dataset not sink. Default: True.
+                                      dataset not sink. Default: False.
             sink_size (int): Control the amount of data in each sink. `sink_size` is invalid if `dataset_sink_mode`
                              is False.
                              If sink_size = -1, sink the complete dataset for each epoch.
@@ -990,20 +996,25 @@ class Model:
                                  Default: 0.
 
         Examples:
-            >>> import mindspore as ms
             >>> from mindspore import nn
+            >>> from mindspore.train import Model
             >>>
             >>> # For details about how to build the dataset, please refer to the tutorial
             >>> # document on the official website.
             >>> dataset = create_custom_dataset()
             >>> net = Net()
             >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-            >>> loss_scale_manager = ms.FixedLossScaleManager()
+            >>> loss_scale_manager = ms.FixedLossScaleManager(1024., False)
             >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-            >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics=None,
+            >>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None,
             ...                  loss_scale_manager=loss_scale_manager)
             >>> model.train(2, dataset)
         """
+        device_target = context.get_context("device_target")
+        if _is_ps_mode() and not _cache_enable() and (device_target in ["Ascend", "CPU"]) and dataset_sink_mode:
+            logger.info("For PS mode, reset datasink mode to False when using Ascend or CPU backend.")
+            dataset_sink_mode = False
+
         Validator.check_bool(dataset_sink_mode)
         if isinstance(self._train_network, nn.GraphCell) and dataset_sink_mode:
             raise ValueError("Dataset sink mode is currently not supported when training with a GraphCell.")
@@ -1016,11 +1027,10 @@ class Model:
 
         # Parameter server and embedding cache mode check.
         if _is_ps_mode():
-            if dataset_sink_mode and not _cache_enable():
-                raise ValueError("Parameter server mode does not support 'data_sink_mode=True'.")
             if not dataset_sink_mode and _cache_enable():
-                raise ValueError("Embedding cache mode should run with 'data_sink_mode=True'.")
+                raise ValueError("Embedding cache mode should run with 'dataset_sink_mode=True'.")
 
+        self._check_sink_mode_for_ds_debug_mode(dataset_sink_mode)
 
         Validator.check_is_int(sink_size)
         Validator.check_non_negative_int(epoch)
@@ -1050,11 +1060,18 @@ class Model:
                     sink_size=sink_size,
                     initial_epoch=initial_epoch)
 
-        # When it's Parameter Server training and using MindRT,
+        # When it's distributed training and using MindRT,
         # the node id should be reset to start from 0.
+        # This is to avoid the timeout when finding the actor route tables in 'train' and 'eval' case(or 'fit').
         if _enable_distributed_mindrt():
             _reset_op_id_with_offset()
 
+    @staticmethod
+    def _check_sink_mode_for_ds_debug_mode(dataset_sink_mode):
+        if get_debug_mode() and dataset_sink_mode:
+            raise ValueError("Dataset sink mode is not supported when dataset pipeline debug mode is on. "
+                             "Please manually turn off sink mode.")
+
     @staticmethod
     def _check_methods_for_custom_callbacks(callbacks, current_mode):
         """
@@ -1083,13 +1100,14 @@ class Model:
                                          "using customized callbacks." % (cb_name, invalid_methods_names))
 
     def fit(self, epoch, train_dataset, valid_dataset=None, valid_frequency=1, callbacks=None,
-            dataset_sink_mode=True, valid_dataset_sink_mode=True, sink_size=-1, initial_epoch=0):
+            dataset_sink_mode=False, valid_dataset_sink_mode=False, sink_size=-1, initial_epoch=0):
         """
         Fit API.
 
         Evaluation process will be performed during training process if `valid_dataset` is provided.
 
-        More details please refer to `mindspore.Model.train` and `mindspore.Model.eval`.
+        More details please refer to :func:`mindspore.train.Model.train` and
+        :func:`mindspore.train.Model.eval`.
 
         Args:
             epoch (int): Total training epochs. Generally, train network will be trained on complete dataset per epoch.
@@ -1115,9 +1133,9 @@ class Model:
                                                             Default: None.
             dataset_sink_mode (bool): Determines whether to pass the train data through dataset channel.
                                       Configure pynative mode or CPU, the training process will be performed with
-                                      dataset not sink. Default: True.
+                                      dataset not sink. Default: False.
             valid_dataset_sink_mode (bool): Determines whether to pass the validation data through dataset channel.
-                                      Default: True.
+                                      Default: False.
             sink_size (int): Control the amount of data in each sink. `sink_size` is invalid if `dataset_sink_mode`
                              is False.
                              If sink_size = -1, sink the complete dataset for each epoch.
@@ -1127,8 +1145,8 @@ class Model:
                                  Default: 0.
 
         Examples:
-            >>> import mindspore as ms
             >>> from mindspore import nn
+            >>> from mindspore.train import Model
             >>>
             >>> # For details about how to build the dataset, please refer to the tutorial
             >>> # document on the official website.
@@ -1137,9 +1155,13 @@ class Model:
             >>> net = Net()
             >>> loss = nn.SoftmaxCrossEntropyWithLogits()
             >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-            >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics={"accuracy"})
+            >>> model = Model(net, loss_fn=loss, optimizer=optim, metrics={"accuracy"})
             >>> model.fit(2, train_dataset, valid_dataset)
         """
+        device_target = context.get_context("device_target")
+        if _is_ps_mode() and not _cache_enable() and (device_target in ["Ascend", "CPU"]) and dataset_sink_mode:
+            logger.info("For PS mode, reset datasink mode to False when using Ascend or CPU backend.")
+            dataset_sink_mode = False
 
         dataset_sink_mode = Validator.check_bool(dataset_sink_mode)
         valid_dataset_sink_mode = Validator.check_bool(valid_dataset_sink_mode)
@@ -1152,9 +1174,6 @@ class Model:
                              "should be equal to value in Model.fit, but got {} and {} separately."
                              .format(train_dataset._warmup_epoch, epoch))
 
-        if dataset_sink_mode and _is_ps_mode() and not _cache_enable():
-            raise ValueError("Parameter server mode does not support 'data_sink_mode=True'.")
-
         Validator.check_is_int(sink_size)
         Validator.check_non_negative_int(epoch)
         Validator.check_non_negative_int(initial_epoch)
@@ -1173,7 +1192,7 @@ class Model:
         _device_number_check(self._parallel_mode, self._device_number)
 
         if not isinstance(valid_frequency, (int, list)):
-            raise TypeError(f"For 'Model.fit', the type of 'valid_frequency' must be a list or a integer, but got "
+            raise TypeError(f"For 'Model.fit', the type of 'valid_frequency' must be a list or an integer, but got "
                             f"type {type(valid_frequency)}.")
 
         if valid_dataset and not self._metric_fns:
@@ -1196,7 +1215,7 @@ class Model:
         Build computational graphs and data graphs with the sink mode.
 
         .. warning::
-            This is an experimental prototype that is subject to change or deletion.
+            This is an experimental API that is subject to change or deletion.
 
         Note:
             The interface builds the computational graphs, when the interface is executed first, 'Model.train' only
@@ -1212,17 +1231,18 @@ class Model:
             epoch (int): Control the training epochs. Default: 1.
 
         Examples:
-            >>> import mindspore as ms
             >>> from mindspore import nn
+            >>> from mindspore.train import Model
+            >>> from mindspore.amp import FixedLossScaleManager
             >>>
             >>> # For details about how to build the dataset, please refer to the tutorial
             >>> # document on the official website.
             >>> dataset = create_custom_dataset()
             >>> net = Net()
             >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-            >>> loss_scale_manager = ms.FixedLossScaleManager()
+            >>> loss_scale_manager = FixedLossScaleManager()
             >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-            >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics=None,
+            >>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None,
             ...                  loss_scale_manager=loss_scale_manager)
             >>> model.build(dataset, epoch=2)
             >>> model.train(2, dataset)
@@ -1231,7 +1251,7 @@ class Model:
 
     def _eval_in_fit(self, valid_dataset, callbacks=None, dataset_sink_mode=True, cb_params=None):
         """
-        Evaluation process in `mindspore.Model.fit`.
+        Evaluation process in `mindspore.train.Model.fit`.
 
         Args:
             valid_dataset (Dataset): Dataset to evaluate the model. If `valid_dataset` is provided, evaluation process
@@ -1286,6 +1306,8 @@ class Model:
         list_callback.on_eval_epoch_begin(run_context)
         for inputs in dataset_helper:
             cb_params.cur_step_num += 1
+            inputs = _transfer_tensor_to_tuple(inputs)
+            cb_params.eval_dataset_element = inputs
             list_callback.on_eval_step_begin(run_context)
             eval_network = self._check_network_mode(eval_network, False)
             outputs = eval_network(*inputs)
@@ -1330,8 +1352,9 @@ class Model:
         list_callback.on_eval_epoch_begin(run_context)
         for next_element in dataset_helper:
             cb_params.cur_step_num += 1
-            list_callback.on_eval_step_begin(run_context)
             next_element = _transfer_tensor_to_tuple(next_element)
+            cb_params.eval_dataset_element = next_element
+            list_callback.on_eval_step_begin(run_context)
             self._check_network_mode(self._eval_network, False)
             outputs = self._eval_network(*next_element)
             cb_params.net_outputs = outputs
@@ -1342,6 +1365,8 @@ class Model:
             if add_eval_loss:
                 eval_loss_fn = get_metric_fn("loss")
                 eval_loss_fn.update(outputs[self._eval_indexes[0]])
+            if run_context.get_stop_requested():
+                break
 
         list_callback.on_eval_epoch_end(run_context)
         valid_dataset.reset()
@@ -1354,7 +1379,7 @@ class Model:
         list_callback.on_eval_end(run_context)
         return metrics
 
-    def eval(self, valid_dataset, callbacks=None, dataset_sink_mode=True):
+    def eval(self, valid_dataset, callbacks=None, dataset_sink_mode=False):
         """
         Evaluation API.
 
@@ -1374,22 +1399,22 @@ class Model:
                                                             which should be executed while evaluation.
                                                             Default: None.
             dataset_sink_mode (bool): Determines whether to pass the data through dataset channel.
-                Default: True.
+                Default: False.
 
         Returns:
             Dict, the key is the metric name defined by users and the value is the metrics value for
             the model in the test mode.
 
         Examples:
-            >>> import mindspore as ms
             >>> from mindspore import nn
+            >>> from mindspore.train import Model
             >>>
             >>> # For details about how to build the dataset, please refer to the tutorial
             >>> # document on the official website.
             >>> dataset = create_custom_dataset()
             >>> net = Net()
             >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-            >>> model = ms.Model(net, loss_fn=loss, optimizer=None, metrics={'acc'})
+            >>> model = Model(net, loss_fn=loss, optimizer=None, metrics={'acc'})
             >>> acc = model.eval(dataset, dataset_sink_mode=False)
         """
         dataset_sink_mode = Validator.check_bool(dataset_sink_mode)
@@ -1431,8 +1456,9 @@ class Model:
             else:
                 eval_result = self._eval_process(valid_dataset, list_callback, cb_params)
 
-        # When it's Parameter Server training and using MindRT,
+        # When it's distributed training and using MindRT,
         # the node id should be reset to start from 0.
+        # This is to avoid the timeout when finding the actor route tables in 'train' and 'eval' case(or 'fit').
         if _enable_distributed_mindrt():
             _reset_op_id_with_offset()
 
@@ -1452,11 +1478,12 @@ class Model:
 
         Examples:
             >>> import numpy as np
-            >>> import mindspore as ms
+            >>> import mindspore
             >>> from mindspore import Tensor
+            >>> from mindspore.train import Model
             >>>
-            >>> input_data = Tensor(np.random.randint(0, 255, [1, 1, 32, 32]), ms.float32)
-            >>> model = ms.Model(Net())
+            >>> input_data = Tensor(np.random.randint(0, 255, [1, 1, 32, 32]), mindspore.float32)
+            >>> model = Model(Net())
             >>> result = model.predict(input_data)
         """
         self._check_network_mode(self._predict_network, False)
@@ -1466,8 +1493,9 @@ class Model:
 
         check_output_data(result)
 
-        # When it's Parameter Server training and using MindRT,
+        # When it's distributed training and using MindRT,
         # the node id should be reset to start from 0.
+        # This is to avoid the timeout when finding the actor route tables in 'train' and 'eval' case(or 'fit').
         if _enable_distributed_mindrt():
             _reset_op_id_with_offset()
 
@@ -1509,7 +1537,7 @@ class Model:
         Only dataset sink mode is supported for now.
 
         .. warning::
-            This is an experimental prototype that is subject to change and/or deletion.
+            This is an experimental API that is subject to change or deletion.
 
         Note:
             This is a pre-compile function. The arguments should be the same as model.train() function.
@@ -1538,6 +1566,7 @@ class Model:
             >>> import numpy as np
             >>> import mindspore as ms
             >>> from mindspore import Tensor, nn
+            >>> from mindspore.train import Model
             >>> from mindspore.communication import init
             >>>
             >>> ms.set_context(mode=ms.GRAPH_MODE)
@@ -1551,7 +1580,7 @@ class Model:
             >>> loss = nn.SoftmaxCrossEntropyWithLogits()
             >>> loss_scale_manager = ms.FixedLossScaleManager()
             >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-            >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics=None,
+            >>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None,
             ...                  loss_scale_manager=loss_scale_manager)
             >>> layout_dict = model.infer_train_layout(dataset)
         """
@@ -1596,13 +1625,14 @@ class Model:
             >>> import numpy as np
             >>> import mindspore as ms
             >>> from mindspore import Tensor
+            >>> from mindspore.train import Model
             >>> from mindspore.communication import init
             >>>
             >>> ms.set_context(mode=ms.GRAPH_MODE)
             >>> init()
             >>> ms.set_auto_parallel_context(full_batch=True, parallel_mode=ms.ParallelMode.SEMI_AUTO_PARALLEL)
             >>> input_data = Tensor(np.random.randint(0, 255, [1, 1, 32, 32]), ms.float32)
-            >>> model = ms.Model(Net())
+            >>> model = Model(Net())
             >>> predict_map = model.infer_predict_layout(input_data)
         """
         if context.get_context("mode") != context.GRAPH_MODE:
@@ -1615,7 +1645,6 @@ class Model:
 
         predict_net = self._predict_network
         # Unlike the cases in build_train_network() and build_eval_network(), 'multi_subgraphs' is not set
-        predict_net.set_auto_parallel()
         predict_net = self._check_network_mode(predict_net, False)
         predict_net.compile(*predict_data)
         return predict_net.parameter_layout_dict