mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/train/callback/_backup_and_restore.py

@@ -0,0 +1,120 @@
+# Copyright 2022 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.
+# ============================================================================
+"""backup and restore related classes and functions."""
+from __future__ import absolute_import
+
+import os
+import stat
+
+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 import _checkparam as Validator
+
+
+class BackupAndRestore(Callback):
+    """
+    Callback to back up and restore the parameters during training.
+
+    Note:
+        This function can only use in training.
+
+    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
+                                        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
+                                        training is finished. Default: True.
+
+    Raises:
+        ValueError: If backup_dir is not str.
+        ValueError: If save_freq is not 'epoch' or int.
+        ValueError: If delete_checkpoint is not bool.
+
+    Examples:
+        .. 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/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
+        >>>
+        >>> net = LeNet5()
+        >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
+        >>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
+        >>> model = Model(net, loss_fn=loss, optimizer=optim)
+        >>> data_path = './MNIST_Data'
+        >>> dataset = create_dataset(data_path)
+        >>> backup_ckpt = BackupAndRestore("backup")
+        >>> model.train(10, dataset, callbacks=backup_ckpt)
+    """
+    def __init__(self, backup_dir, save_freq="epoch", delete_checkpoint=True):
+        super(BackupAndRestore, self).__init__()
+        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(save_freq)
+        else:
+            self.save_freq = 1
+        self.delete_checkpoint = Validator.check_bool(delete_checkpoint)
+
+    def on_train_begin(self, run_context):
+        """
+        Load the backup checkpoint file at the beginning of epoch.
+
+        Args:
+            run_context (RunContext): Context of the process running. For more details,
+                    please refer to :class:`mindspore.train.RunContext`.
+        """
+        if os.path.exists(self.backup_file):
+            cb_params = run_context.original_args()
+            train_net = cb_params.train_network
+            logger.info("Restore checkpoint file is {}, load checkpoint into train net.".format(self.backup_file))
+            load_checkpoint(self.backup_file, net=train_net)
+
+    def on_train_epoch_end(self, run_context):
+        """
+        Backup checkpoint file at the end of train epoch.
+
+        Args:
+           run_context (RunContext): Context of the process running. For more details,
+                   please refer to :class:`mindspore.train.RunContext`.
+        """
+        cb_params = run_context.original_args()
+        cur_epoch_num = cb_params.cur_epoch_num
+        if cur_epoch_num % self.save_freq == 0:
+            train_net = cb_params.train_network
+            logger.info("Train task end, backup checkpoint file: {}.".format(self.backup_file))
+            save_checkpoint(train_net, self.backup_file)
+
+    def on_train_end(self, run_context):
+        """
+        Deleted checkpoint file at the end of train.
+
+        Args:
+            run_context (RunContext): Context of the process running. For more details,
+                    please refer to :class:`mindspore.train.RunContext`.
+        """
+        run_context.original_args()
+        cb_params = run_context.original_args()
+        cur_epoch_num = cb_params.cur_epoch_num
+        if self.delete_checkpoint:
+            logger.info("Delete restore checkpoint file {} at {} epoch.".format(self.backup_file, cur_epoch_num))
+            os.chmod(self.backup_file, stat.S_IWRITE)
+            os.remove(self.backup_file)

mindspore/train/callback/_callback.py

@@ -93,14 +93,14 @@ 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/r1.10/debug/custom_debug.html>`_.
+    `Callback <https://www.mindspore.cn/tutorials/experts/en/r2.0/debug/custom_debug.html>`_.
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore as ms
         >>> from mindspore import nn
         >>> from mindspore import dataset as ds
-        >>> class Print_info(ms.Callback):
+        >>> from mindspore.train import Model, Callback
+        >>> class Print_info(Callback):
         ...     def step_end(self, run_context):
         ...         cb_params = run_context.original_args()
         ...         print("step_num: ", cb_params.cur_step_num)
@@ -111,7 +111,7 @@ class Callback:
         >>> net = nn.Dense(10, 5)
         >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = Model(net, loss_fn=loss, optimizer=optim)
         >>> model.train(1, dataset, callbacks=print_cb)
         step_num: 2
     """
@@ -433,11 +433,11 @@ class RunContext:
     `RunContext` is mainly used to collect context-related information about the model during
     training or eval and pass it into the Callback object as an input parameter to share information.
 
-    Callback objects not only can obtain the Model context information by callingby
-    `RunContext.original_args()` and add extral attributes to the information, but also can stop the
+    Callback objects not only can obtain the Model context information by calling by
+    `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/r1.10/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:
@@ -509,7 +509,7 @@ class RunContext:
 
     def request_stop(self):
         """
-        Set stop requirement during training.
+        Set stop requirement during training or eval.
 
         Callbacks can use this function to request stop of iterations.
         model.train() checks whether this is called or not.

mindspore/train/callback/_checkpoint.py

@@ -23,10 +23,9 @@ 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._ps_context import _is_role_pserver, _get_ps_mode_rank, _enable_distributed_mindrt
 from mindspore.parallel._cell_wrapper import destroy_allgather_cell
 from mindspore.parallel._recovery_context import _set_recovery_context, _get_recovery_context
 from mindspore.train.callback._callback import Callback, set_cur_net
@@ -98,16 +97,22 @@ class CheckpointConfig:
         enc_key (Union[None, bytes]): Byte type key used for encryption. If the value is None, the encryption
                                       is not required. Default: None.
         enc_mode (str): This parameter is valid only when enc_key is not set to None. Specifies the encryption
-                        mode, currently supports 'AES-GCM' and 'AES-CBC'. Default: 'AES-GCM'.
+                        mode, currently supports 'AES-GCM', 'AES-CBC' and 'SM4-CBC'. Default: 'AES-GCM'.
         exception_save (bool): Whether to save the current checkpoint when an exception occurs. Default: False.
 
     Raises:
         ValueError: If input parameter is not the correct type.
 
     Examples:
-        >>> import mindspore as ms
+        .. 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/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
+        >>> from mindspore.train import Model, CheckpointConfig, ModelCheckpoint
         >>>
         >>> class LeNet5(nn.Cell):
         ...     def __init__(self, num_class=10, num_channel=1):
@@ -133,11 +138,11 @@ class CheckpointConfig:
         >>> net = LeNet5()
         >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = Model(net, loss_fn=loss, optimizer=optim)
         >>> data_path = './MNIST_Data'
         >>> dataset = create_dataset(data_path)
-        >>> config = ms.CheckpointConfig(saved_network=net)
-        >>> ckpoint_cb = ms.ModelCheckpoint(prefix='LeNet5', directory='./checkpoint', config=config)
+        >>> config = CheckpointConfig(saved_network=net)
+        >>> ckpoint_cb = ModelCheckpoint(prefix='LeNet5', directory='./checkpoint', config=config)
         >>> model.train(10, dataset, callbacks=ckpoint_cb)
     """
 
@@ -419,8 +424,6 @@ class ModelCheckpoint(Callback):
         Args:
             run_context (RunContext): Context of the train running.
         """
-        if _is_role_pserver() and not _enable_distributed_mindrt():
-            self._prefix = "PServer_" + str(_get_ps_mode_rank()) + "_" + self._prefix
         cb_params = run_context.original_args()
 
         # In disaster recovery scenario, the training process may be rolled back to the last step where

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
@@ -82,8 +82,14 @@ class EarlyStopping(Callback):
         ValueError: The monitor value is not a scalar.
 
     Examples:
-        >>> from mindspore.train.callback import EarlyStopping
-        >>> from mindspore import Model, nn
+        .. 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/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
         >>> net = LeNet5()
         >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
@@ -126,7 +132,7 @@ class EarlyStopping(Callback):
 
         Args:
             run_context (RunContext): Context information of the model. For more details,
-                    please refer to :class:`mindspore.RunContext`.
+                    please refer to :class:`mindspore.train.RunContext`.
         """
 
         self.wait = 0
@@ -144,7 +150,7 @@ class EarlyStopping(Callback):
 
         Args:
             run_context (RunContext): Context information of the model. For more details,
-                    please refer to :class:`mindspore.RunContext`.
+                    please refer to :class:`mindspore.train.RunContext`.
         """
         cb_params = run_context.original_args()
 
@@ -185,7 +191,7 @@ class EarlyStopping(Callback):
 
         Args:
             run_context (RunContext): Context information of the model. For more details,
-                    please refer to :class:`mindspore.RunContext`.
+                    please refer to :class:`mindspore.train.RunContext`.
         """
 
         if self.stopped_epoch > 0 and self.verbose:
@@ -201,7 +207,7 @@ class EarlyStopping(Callback):
 
         Args:
             cb_params (dict): A dictionary stores context information of the model. For more details,
-                    please refer to :class:`mindspore.RunContext`.
+                    please refer to :class:`mindspore.train.RunContext`.
         """
         monitor_candidates = {}
         if self.monitor == "loss":

mindspore/train/callback/_history.py

@@ -31,20 +31,20 @@ class History(Callback):
     outputs will be recorded.
 
     Note:
-        Normally used in `mindspore.Model.train` or `mindspore.Model.fit`.
+        Normally used in `mindspore.train.Model.train` or `mindspore.train.Model.fit`.
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore as ms
         >>> import mindspore.dataset as ds
         >>> from mindspore import nn
+        >>> from mindspore.train import Model, History
         >>> data = {"x": np.float32(np.random.rand(64, 10)), "y": np.random.randint(0, 5, (64,))}
         >>> train_dataset = ds.NumpySlicesDataset(data=data).batch(32)
         >>> net = nn.Dense(10, 5)
         >>> crit = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> opt = nn.Momentum(net.trainable_params(), 0.01, 0.9)
-        >>> history_cb = ms.History()
-        >>> model = ms.Model(network=net, optimizer=opt, loss_fn=crit, metrics={"recall"})
+        >>> history_cb = History()
+        >>> model = Model(network=net, optimizer=opt, loss_fn=crit, metrics={"recall"})
         >>> model.train(2, train_dataset, callbacks=[history_cb])
         >>> print(history_cb.epoch)
         >>> print(history_cb.history)
@@ -61,8 +61,8 @@ class History(Callback):
         Initialize the `epoch` property at the begin of training.
 
         Args:
-            run_context (RunContext): Context of the `mindspore.Model.{train | eval}`. For more details,
-                    please refer to :class:`mindspore.RunContext`.
+            run_context (RunContext): Context of the `mindspore.train.Model.{train | eval}`. For more details,
+                    please refer to :class:`mindspore.train.RunContext`.
         """
         self.epoch = {"epoch": []}
 
@@ -71,8 +71,8 @@ class History(Callback):
         Records the first element of network outputs and metrics information at the end of epoch.
 
         Args:
-            run_context (RunContext): Context of the `mindspore.Model.{train | eval}`.  For more details,
-                    please refer to :class:`mindspore.RunContext`.
+            run_context (RunContext): Context of the `mindspore.train.Model.{train | eval}`.  For more details,
+                    please refer to :class:`mindspore.train.RunContext`.
         """
         cb_params = run_context.original_args()
         epoch = cb_params.get("cur_epoch_num", 1)

mindspore/train/callback/_lambda_callback.py

@@ -23,11 +23,11 @@ class LambdaCallback(Callback):
     Callback for creating simple, custom callbacks.
 
     This callback is constructed with anonymous functions that will be called
-    at the appropriate time (during `mindspore.Model.{train | eval | fit}`). Note that
+    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.
@@ -45,17 +45,17 @@ class LambdaCallback(Callback):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore as ms
         >>> import mindspore.dataset as ds
         >>> from mindspore import nn
+        >>> from mindspore.train import Model, LambdaCallback
         >>> data = {"x": np.float32(np.random.rand(64, 10)), "y": np.random.randint(0, 5, (64,))}
         >>> train_dataset = ds.NumpySlicesDataset(data=data).batch(32)
         >>> net = nn.Dense(10, 5)
         >>> crit = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> opt = nn.Momentum(net.trainable_params(), 0.01, 0.9)
-        >>> lambda_callback = ms.LambdaCallback(on_train_epoch_end=
+        >>> lambda_callback = LambdaCallback(on_train_epoch_end=
         ... lambda run_context: print("loss: ", run_context.original_args().net_outputs))
-        >>> model = ms.Model(network=net, optimizer=opt, loss_fn=crit, metrics={"recall"})
+        >>> model = Model(network=net, optimizer=opt, loss_fn=crit, metrics={"recall"})
         >>> model.train(2, train_dataset, callbacks=[lambda_callback])
         loss: 1.6127687
         loss: 1.6106578

mindspore/train/callback/_landscape.py

@@ -38,7 +38,7 @@ from mindspore.train.summary.enums import PluginEnum
 from mindspore.train.anf_ir_pb2 import DataType
 from mindspore.train._utils import check_value_type, _make_directory
 from mindspore.train.dataset_helper import DatasetHelper
-from mindspore.nn.metrics import get_metrics
+from mindspore.train.metrics import get_metrics
 from mindspore import context
 
 # if there is no path, you need to set to empty list
@@ -181,6 +181,7 @@ class SummaryLandscape:
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
         >>> from mindspore.nn import Loss, Accuracy
+        >>> from mindspore.train import Model, SummaryCollector, SummaryLandscape
         >>>
         >>> if __name__ == '__main__':
         ...     # If the device_target is Ascend, set the device_target to "Ascend"
@@ -192,10 +193,10 @@ class SummaryLandscape:
         ...     network = LeNet5(10)
         ...     net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
         ...     net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
-        ...     model = ms.Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
+        ...     model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
         ...     # Simple usage for collect landscape information:
         ...     interval_1 = [1, 2, 3, 4, 5]
-        ...     summary_collector = ms.SummaryCollector(summary_dir='./summary/lenet_interval_1',
+        ...     summary_collector = SummaryCollector(summary_dir='./summary/lenet_interval_1',
         ...                                          collect_specified_data={'collect_landscape':{"landscape_size": 4,
         ...                                                                                        "unit": "step",
         ...                                                                          "create_landscape":{"train":True,
@@ -215,7 +216,7 @@ class SummaryLandscape:
         ...         ds_eval = create_dataset(mnist_dataset_dir, 32)
         ...         return model, network, ds_eval, metrics
         ...
-        ...     summary_landscape = ms.SummaryLandscape('./summary/lenet_interval_1')
+        ...     summary_landscape = SummaryLandscape('./summary/lenet_interval_1')
         ...     # parameters of collect_landscape can be modified or unchanged
         ...     summary_landscape.gen_landscapes_with_multi_process(callback_fn,
         ...                                                        collect_landscape={"landscape_size": 4,
@@ -261,10 +262,10 @@ class SummaryLandscape:
             callback_fn (python function): A python function object. User needs to write a function,
                 it has no input, and the return requirements are as follows.
 
-                - mindspore.Model: User's model object.
+                - mindspore.train.Model: User's model object.
                 - mindspore.nn.Cell: User's network object.
                 - mindspore.dataset: User's dataset object for create loss landscape.
-                - mindspore.nn.Metrics: User's metrics object.
+                - mindspore.train.Metrics: User's metrics object.
             collect_landscape (Union[dict, None]): The meaning of the parameters
                 when creating loss landscape is consistent with the fields
                 with the same name in SummaryCollector. The purpose of setting here
@@ -281,7 +282,7 @@ class SummaryLandscape:
                   For example, in image dataset, You can set num_samples is 2048,
                   which means that 2048 images are used to create loss landscape.
                   Default: 2048.
-                - intervals (List[List[int]): Specifies the interval
+                - intervals (List[List[int]]): Specifies the interval
                   in which the loss landscape. For example: If the user wants to
                   create loss landscape of two training processes, they are 1-5 epoch
                   and 6-10 epoch respectively. They can set [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]].
@@ -293,6 +294,12 @@ class SummaryLandscape:
                 Default: None. The default save path is the same as the summary file.
         """
 
+        executor = None
+        if len(device_ids) > 1:
+            executor = ProcessPoolExecutor(len(device_ids))
+            futures = [executor.submit(self._set_context, i) for i in device_ids]
+            wait(futures, return_when=ALL_COMPLETED)
+
         output_path = os.path.realpath(output) if output is not None else self._summary_dir
         summary_record = SummaryRecord(output_path)
         self._check_device_ids(device_ids)
@@ -320,13 +327,14 @@ class SummaryLandscape:
                 json.dump(data, file)
             os.chmod(json_path, stat.S_IRUSR)
 
-        for interval, landscape in self._list_landscapes(callback_fn=callback_fn, device_ids=device_ids):
+        for interval, landscape in self._list_landscapes(callback_fn=callback_fn, executor=executor,
+                                                         device_ids=device_ids):
             summary_record.add_value(PluginEnum.LANDSCAPE.value, f'landscape_{str(interval)}', landscape)
             summary_record.record(0)
             summary_record.flush()
         summary_record.close()
 
-    def _list_landscapes(self, callback_fn, device_ids=None):
+    def _list_landscapes(self, callback_fn, executor=None, device_ids=None):
         """Create landscape with single device and list all landscape."""
 
         if not os.path.exists(os.path.join(self._ckpt_dir, 'train_metadata.json')):
@@ -342,39 +350,30 @@ class SummaryLandscape:
         kwargs = dict(proz=0.2, landscape_size=data['landscape_size'], device_ids=device_ids, callback_fn=callback_fn)
 
         start = time.time()
-        with ProcessPoolExecutor(max_workers=len(device_ids)) as executor:
-            if len(device_ids) > 1:
-                futures = []
-                for device_id in device_ids:
-                    future = executor.submit(self._set_context, device_id)
-                    futures.append(future)
-                wait(futures, return_when=ALL_COMPLETED)
-
-            kwargs['executor'] = executor if len(device_ids) > 1 else None
-
-            if data['create_landscape']['train']:
-                for i, epochs in enumerate(self._epoch_group.values()):
-                    self._log_message(data['create_landscape'], index=i, interval=epochs)
-                    kwargs['epochs'] = epochs
-                    mid_time = time.time()
-                    landscape_data = self._create_landscape_by_pca(**kwargs)
-                    logger.info("Create landscape end, use time: %s s." % (round(time.time() - mid_time, 6)))
-                    landscape_data.unit = data['unit']
-                    landscape_data.step_per_epoch = data['step_per_epoch']
-                    landscape_data.num_samples = data['num_samples']
-                    yield [epochs[0], epochs[-1]], landscape_data.transform_to_loss_landscape_msg(landscape_data)
-
-            if data['create_landscape']['result']:
-                final_epochs = [list(self._epoch_group.values())[-1][-1]]
-                self._log_message(data['create_landscape'], final_epochs=final_epochs)
-                kwargs['epochs'] = final_epochs
+        kwargs['executor'] = executor
+        if data['create_landscape']['train']:
+            for i, epochs in enumerate(self._epoch_group.values()):
+                self._log_message(data['create_landscape'], index=i, interval=epochs)
+                kwargs['epochs'] = epochs
                 mid_time = time.time()
-                landscape_data = self._create_landscape_by_random(**kwargs)
+                landscape_data = self._create_landscape_by_pca(**kwargs)
                 logger.info("Create landscape end, use time: %s s." % (round(time.time() - mid_time, 6)))
                 landscape_data.unit = data['unit']
                 landscape_data.step_per_epoch = data['step_per_epoch']
                 landscape_data.num_samples = data['num_samples']
-                yield final_epochs, landscape_data.transform_to_loss_landscape_msg(landscape_data)
+                yield [epochs[0], epochs[-1]], landscape_data.transform_to_loss_landscape_msg(landscape_data)
+
+        if data['create_landscape']['result']:
+            final_epochs = [list(self._epoch_group.values())[-1][-1]]
+            self._log_message(data['create_landscape'], final_epochs=final_epochs)
+            kwargs['epochs'] = final_epochs
+            mid_time = time.time()
+            landscape_data = self._create_landscape_by_random(**kwargs)
+            logger.info("Create landscape end, use time: %s s." % (round(time.time() - mid_time, 6)))
+            landscape_data.unit = data['unit']
+            landscape_data.step_per_epoch = data['step_per_epoch']
+            landscape_data.num_samples = data['num_samples']
+            yield final_epochs, landscape_data.transform_to_loss_landscape_msg(landscape_data)
         logger.info("Total use time: %s s." % (round(time.time() - start, 6)))
 
     def _log_message(self, create_landscape, index=None, interval=None, final_epochs=None):
@@ -815,7 +814,6 @@ class SummaryLandscape:
                 raise ValueError(f'For "{self.__class__.__name__}.gen_landscapes_with_multi_process", the parameter '
                                  f'"device_ids" should be between 0 and 7,but got {i}.')
 
-
     def _check_collect_landscape_data(self, collect_landscape):
         """Check collect landscape data type and value."""
         for param in collect_landscape.keys():

mindspore/train/callback/_loss_monitor.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.train.callback._callback import Callback, _handle_loss
 
 
@@ -38,13 +38,19 @@ class LossMonitor(Callback):
         ValueError: If per_print_times is not an integer or less than zero.
 
     Examples:
-        >>> import mindspore as ms
+        .. 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/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, LossMonitor
         >>>
         >>> net = LeNet5()
         >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = Model(net, loss_fn=loss, optimizer=optim)
         >>> data_path = './MNIST_Data'
         >>> dataset = create_dataset(data_path)
         >>> loss_monitor = LossMonitor()
@@ -63,7 +69,7 @@ class LossMonitor(Callback):
 
         Args:
             run_context (RunContext): Include some information of the model.  For more details,
-                    please refer to :class:`mindspore.RunContext`.
+                    please refer to :class:`mindspore.train.RunContext`.
         """
         cb_params = run_context.original_args()
 
@@ -89,12 +95,12 @@ class LossMonitor(Callback):
 
     def on_train_epoch_end(self, run_context):
         """
-        When LossMoniter used in `model.fit`, print eval metrics at the end of epoch if current epoch
+        When LossMonitor used in `model.fit`, print eval metrics at the end of epoch if current epoch
         should do evaluation.
 
         Args:
             run_context (RunContext): Include some information of the model. For more details,
-                    please refer to :class:`mindspore.RunContext`.
+                    please refer to :class:`mindspore.train.RunContext`.
         """
         cb_params = run_context.original_args()
         metrics = cb_params.get("metrics")

mindspore/train/callback/_lr_scheduler_callback.py

@@ -34,10 +34,8 @@ class LearningRateScheduler(Callback):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore as ms
         >>> from mindspore import nn
-        >>> from mindspore import LearningRateScheduler
-        >>> import mindspore.nn as nn
+        >>> from mindspore.train import Model, LearningRateScheduler
         >>> from mindspore import dataset as ds
         ...
         >>> def learning_rate_function(lr, cur_step_num):
@@ -50,7 +48,7 @@ class LearningRateScheduler(Callback):
         >>> net = nn.Dense(10, 5)
         >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> optim = nn.Momentum(net.trainable_params(), learning_rate=lr, momentum=momentum)
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = Model(net, loss_fn=loss, optimizer=optim)
         ...
         >>> data = {"x": np.float32(np.random.rand(64, 10)), "y": np.random.randint(0, 5, (64,))}
         >>> dataset = ds.NumpySlicesDataset(data=data).batch(32)