mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/train/callback/_lambda_callback.py

@@ -30,18 +30,18 @@ class LambdaCallback(Callback):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        on_train_epoch_begin (Function): called at each train epoch begin.
-        on_train_epoch_end (Function): called at each train epoch end.
-        on_train_step_begin (Function):  called at each train step begin.
-        on_train_step_end (Function): called at each train step end.
-        on_train_begin (Function): called at the beginning of model train.
-        on_train_end (Function): called at the end of model train.
-        on_eval_epoch_begin (Function): called at eval epoch begin.
-        on_eval_epoch_end (Function): called at eval epoch end.
-        on_eval_step_begin (Function): called at each eval step begin.
-        on_eval_step_end (Function): called at each eval step end.
-        on_eval_begin (Function): called at the beginning of model eval.
-        on_eval_end (Function): called at the end of model eval.
+        on_train_epoch_begin (Function): called at each train epoch begin. Default: ``None`` .
+        on_train_epoch_end (Function): called at each train epoch end. Default: ``None`` .
+        on_train_step_begin (Function):  called at each train step begin. Default: ``None`` .
+        on_train_step_end (Function): called at each train step end. Default: ``None`` .
+        on_train_begin (Function): called at the beginning of model train. Default: ``None`` .
+        on_train_end (Function): called at the end of model train. Default: ``None`` .
+        on_eval_epoch_begin (Function): called at eval epoch begin. Default: ``None`` .
+        on_eval_epoch_end (Function): called at eval epoch end. Default: ``None`` .
+        on_eval_step_begin (Function): called at each eval step begin. Default: ``None`` .
+        on_eval_step_end (Function): called at each eval step end. Default: ``None`` .
+        on_eval_begin (Function): called at the beginning of model eval. Default: ``None`` .
+        on_eval_end (Function): called at the end of model eval. Default: ``None`` .
 
     Examples:
         >>> import numpy as np
@@ -54,7 +54,7 @@ class LambdaCallback(Callback):
         >>> crit = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> opt = nn.Momentum(net.trainable_params(), 0.01, 0.9)
         >>> lambda_callback = LambdaCallback(on_train_epoch_end=
-        ... lambda run_context: print("loss: ", run_context.original_args().net_outputs))
+        ... lambda run_context: print("loss:", run_context.original_args().net_outputs))
         >>> model = Model(network=net, optimizer=opt, loss_fn=crit, metrics={"recall"})
         >>> model.train(2, train_dataset, callbacks=[lambda_callback])
         loss: 1.6127687

mindspore/train/callback/_landscape.py

@@ -180,17 +180,18 @@ class SummaryLandscape:
     Examples:
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> from mindspore.nn import Loss, Accuracy
-        >>> from mindspore.train import Model, SummaryCollector, SummaryLandscape
+        >>> from mindspore.train import Model, Accuracy, Loss
+        >>> from mindspore import SummaryCollector, SummaryLandscape
         >>>
         >>> if __name__ == '__main__':
         ...     # If the device_target is Ascend, set the device_target to "Ascend"
         ...     ms.set_context(mode=ms.GRAPH_MODE, device_target="GPU")
-        ...     mnist_dataset_dir = '/path/to/mnist_dataset_directory'
-        ...     # The detail of create_dataset method shown in model_zoo.official.cv.lenet.src.dataset.py
-        ...     ds_train = create_dataset(mnist_dataset_dir, 32)
-        ...     # The detail of LeNet5 shown in model_zoo.official.cv.lenet.src.lenet.py
-        ...     network = LeNet5(10)
+        ...     # Create the dataset taking MNIST as an example. Refer to
+        ...     # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        ...     ds_train = create_dataset()
+        ...     # Define the network structure of LeNet5. Refer to
+        ...     # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        ...     network = LeNet5()
         ...     net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
         ...     net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
         ...     model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
@@ -208,12 +209,15 @@ class SummaryLandscape:
         ...
         ...     # Simple usage for visualization landscape:
         ...     def callback_fn():
-        ...         network = LeNet5(10)
+        ...         # Define the network structure of LeNet5. Refer to
+        ...         # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        ...         network = LeNet5()
         ...         net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
         ...         metrics = {"Loss": Loss()}
         ...         model = Model(network, net_loss, metrics=metrics)
-        ...         mnist_dataset_dir = '/path/to/mnist_dataset_directory'
-        ...         ds_eval = create_dataset(mnist_dataset_dir, 32)
+        ...         # Create the dataset taking MNIST as an example. Refer to
+        ...         # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        ...         ds_eval = create_dataset()
         ...         return model, network, ds_eval, metrics
         ...
         ...     summary_landscape = SummaryLandscape('./summary/lenet_interval_1')
@@ -269,19 +273,19 @@ class SummaryLandscape:
             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
-                is to allow users to freely modify creating parameters. Default: None.
+                is to allow users to freely modify creating parameters. Default: ``None`` .
 
                 - landscape_size (int): Specify the image resolution of the generated loss landscape.
-                  For example, if it is set to 128, the resolution of the landscape is 128 * 128.
+                  For example, if it is set to ``128`` , the resolution of the landscape is 128 * 128.
                   The calculation time increases with the increase of resolution.
-                  Default: 40. Optional values: between 3 and 256.
+                  Default: ``40`` . Optional values: between 3 and 256.
                 - create_landscape (dict): Select how to create loss landscape.
                   Training process loss landscape(train) and training result loss landscape(result).
-                  Default: {"train": True, "result": True}. Optional: True/False.
+                  Default: {"train": True, "result": True}. Optional: ``True`` / ``False`` .
                 - num_samples (int): The size of the dataset used to create the loss landscape.
                   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.
+                  Default: ``2048`` .
                 - 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
@@ -289,9 +293,9 @@ class SummaryLandscape:
                   Note: Each interval have at least three epochs.
             device_ids (List(int)): Specifies which devices are used to create loss landscape.
                 For example: [0, 1] refers to creating loss landscape with device 0 and device 1.
-                Default: None.
+                Default: ``None`` .
             output (str): Specifies the path to save the loss landscape.
-                Default: None. The default save path is the same as the summary file.
+                Default: ``None`` . The default save path is the same as the summary file.
         """
 
         executor = None

mindspore/train/callback/_loss_monitor.py

@@ -19,6 +19,7 @@ import numpy as np
 
 from mindspore import _checkparam as Validator
 from mindspore.train.callback._callback import Callback, _handle_loss
+from mindspore._c_expression import _collect_host_info
 
 
 class LossMonitor(Callback):
@@ -32,27 +33,24 @@ class LossMonitor(Callback):
 
     Args:
         per_print_times (int): How many steps to print once loss. During sink mode, it will print loss in the
-                               nearest step. Default: 1.
+                               nearest step. Default: ``1`` .
 
     Raises:
         ValueError: If per_print_times is not an integer or less than zero.
 
     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, LossMonitor
         >>>
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
         >>> 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)
+        >>> # Create the dataset taking MNIST as an example. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        >>> dataset = create_dataset()
         >>> loss_monitor = LossMonitor()
         >>> model.train(10, dataset, callbacks=loss_monitor)
     """
@@ -72,7 +70,7 @@ class LossMonitor(Callback):
                     please refer to :class:`mindspore.train.RunContext`.
         """
         cb_params = run_context.original_args()
-
+        _collect_host_info("Callback", "LossMonitor", "step_end", level=1)
         cur_epoch_num = cb_params.get("cur_epoch_num", 1)
         loss = _handle_loss(cb_params.net_outputs)
 
@@ -103,6 +101,7 @@ class LossMonitor(Callback):
                     please refer to :class:`mindspore.train.RunContext`.
         """
         cb_params = run_context.original_args()
+        _collect_host_info("Callback", "LossMonitor", "train_epoch_end", level=1)
         metrics = cb_params.get("metrics")
         if metrics:
             print("Eval result: epoch %d, metrics: %s" % (cb_params.cur_epoch_num, metrics))

mindspore/train/callback/_on_request_exit.py

@@ -34,13 +34,13 @@ class OnRequestExit(Callback):
     including checkpoint and mindir, and then exit the training process.
 
     Args:
-        save_ckpt (bool): Whether save the checkpoint before the training process exit. Default: True.
-        save_mindir (bool): Whether save the mindir before the training process exit. Default: True.
+        save_ckpt (bool): Whether save the checkpoint before the training process exit. Default: ``True`` .
+        save_mindir (bool): Whether save the mindir before the training process exit. Default: ``True`` .
         file_name (str): The saved checkpoint and mindir file name,
-            the checkpoint file add suffix '.ckpt', the mindir file add suffix '.mindir'. Default: 'Net'.
-        directory (str): The directory save checkpoint and mindir. Default: './'.
+            the checkpoint file add suffix '.ckpt', the mindir file add suffix '.mindir'. Default: ``'Net'`` .
+        directory (str): The directory save checkpoint and mindir. Default: ``'./'`` .
         sig (int): The user registered exit signal, it must be a captureable and negligible signal.
-            When the process receives the signal, exits the training or eval process. Default: signal.SIGTERM.
+            When the process receives the signal, exits the training or eval process. Default: ``signal.SIGTERM`` .
 
     Raises:
         ValueError: If the 'save_ckpt' is not a bool.
@@ -50,38 +50,21 @@ class OnRequestExit(Callback):
         ValueError: If the 'sig' is not an int or the 'sig' is signal.SIGKILL.
 
     Examples:
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> from mindspore import dataset as ds
         >>> from mindspore import nn
+        >>> from mindspore.train import Model, TimeMonitor
+        >>> import mindspore as ms
         >>>
-        >>> # Define the forward net
-        >>> class ForwardNet(nn.Cell):
-        >>>     def __init__(self, num_class=10, channel=1):
-        >>>         super(ForwardNet, self).__init__()
-        >>>         self.param = ms.Parameter(1.0)
-        >>>         self.relu = ms.ops.ReLU()
-        >>>
-        >>>     def construct(self, x):
-        >>>         return self.relu(x + self.param)
-        >>> forward_net = ForwardNet()
-        >>> loss = nn.MAELoss()
-        >>> opt = nn.Momentum(forward_net.trainable_params(), 0.01, 0.9)
-        >>> model = ms.Model(forward_net, loss_fn=loss, optimizer=opt)\
-        >>>
-        >>> # Create dataset
-        >>> def generator_multi_column():
-        >>>    i = 0
-        >>>    while i < 1000:
-        >>>        i += 1
-        >>>        yield np.ones((1, 32, 32)).astype(np.float32) * 0.01, np.array(1).astype(np.int32)
-        >>> dataset = ds.GeneratorDataset(source=generator_multi_column, column_names=["data", "label"])
-        >>> dataset = dataset.batch(32, drop_remainder=True)
-        >>>
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> 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)
+        >>> # Create the dataset taking MNIST as an example. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        >>> dataset = create_dataset()
         >>> on_request_exit = ms.train.OnRequestExit(file_name='LeNet5')
         >>> model.train(10, dataset, callbacks=on_request_exit)
-        >>> # The user send the signal SIGTERM to the training process,
-        >>> # the process would save the checkpoint and mindir, and then exit the training process.
     """
 
     def __init__(self, save_ckpt=True, save_mindir=True, file_name='Net', directory='./', sig=signal.SIGTERM):

mindspore/train/callback/_reduce_lr_on_plateau.py

@@ -20,6 +20,7 @@ import numpy as np
 
 from mindspore.common.tensor import Tensor
 from mindspore.common.parameter import Parameter
+from mindspore.common import dtype as mstype
 from mindspore import _checkparam as Validator
 from mindspore import log as logger
 from mindspore.ops import functional as F, ReduceOp
@@ -48,53 +49,49 @@ class ReduceLROnPlateau(Callback):
 
     Args:
         monitor (str): quantity to be monitored. If evaluation is performed on
-            the end of train epochs, the valid monitors can be "loss",
-            "eval_loss" or metric names passed when instantiate the `Model`;
-            otherwise the valid monitor is "loss".
-            When monitor is "loss", if train network has multiple outputs,
-            the first element will be returned as training loss.
-
+            the end of train epochs, the valid monitors can be ``"loss"``,
+            ``"eval_loss"`` or metric names passed when instantiate the `Model`;
+            otherwise the valid monitor is ``"loss"``.
+            When `monitor` is ``"loss"``, if train network has multiple outputs,
+            the first element will be returned as training loss. Default: ``'eval_loss'``.
         factor (float): factor by which the learning rate will be reduced.
-            `new_lr = lr * factor`. Default: 0.1.
+            `new_lr = lr * factor`. Default: ``0.1`` .
         patience (int): `monitor` value is better than history best value over
             `min_delta` is seen as improvement, `patience` is number of epochs
             with no improvement that would be waited. When the waiting
             counter `self.wait` is larger than or equal to `patience`,  the lr
-            will be reduced. Default: 10.
+            will be reduced. Default: ``10`` .
         verbose (bool): If False: quiet, if True: print related information.
-            Default: False.
+            Default: ``False`` .
         mode (str): one of `{'auto', 'min', 'max'}`. In "min" mode,
             the learning rate will be reduced when the
             quantity monitored has stopped decreasing; in "max" mode it will be
             reduced when the quantity monitored has stopped increasing; in "auto"
             mode, the direction is automatically inferred from the name of the
-            monitored quantity. Default: "auto".
+            monitored quantity. Default: ``'auto'`` .
         min_delta (float): threshold for measuring the new optimum, to only focus on
-            significant changes. Default: 1e-4.
+            significant changes. Default: ``1e-4`` .
         cooldown (int): number of epochs to wait before resuming normal operation after
-            lr has been reduced. Default: 0.
-        min_lr (float): lower bound on the learning rate. Default: 0.
+            lr has been reduced. Default: ``0`` .
+        min_lr (float): lower bound on the learning rate. Default: ``0`` .
 
     Raises:
-        ValueError: `mode` not in 'auto', 'min' or 'max'.
+        ValueError: `mode` not in ``'auto'``, ``'min'`` or ``'max'``.
         ValueError: The monitor value is not a scalar.
         ValueError: The learning rate is not a Parameter.
 
     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, ReduceLROnPlateau
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
         >>> 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, metrics={"acc"})
-        >>> data_path = './MNIST_Data'
-        >>> dataset = create_dataset(data_path)
+        >>> # Create the dataset taking MNIST as an example. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        >>> dataset = create_dataset()
         >>> cb = ReduceLROnPlateau(monitor="acc", patience=3, verbose=True)
         >>> model.fit(10, dataset, callbacks=cb)
     """
@@ -160,7 +157,7 @@ class ReduceLROnPlateau(Callback):
         if rank_size == 1:
             reduce_monitor_value = current_monitor_value
         else:
-            reduce_monitor_value = self._reduce(Tensor(current_monitor_value.astype(np.float32))) / rank_size
+            reduce_monitor_value = self._reduce(Tensor(current_monitor_value, mstype.float32)).asnumpy() / rank_size
 
         if reduce_monitor_value is None:
             return
@@ -226,4 +223,4 @@ class ValueReduce(nn.Cell):
         self.allreduce = ops.AllReduce(ReduceOp.SUM)
 
     def construct(self, x):
-        return self.allreduce(x).asnumpy()
+        return self.allreduce(x)

mindspore/train/callback/_summary_collector.py

@@ -41,6 +41,7 @@ from mindspore.nn.optim.optimizer import Optimizer
 from mindspore.nn.loss.loss import LossBase
 from mindspore.train._utils import check_value_type, _make_directory
 from mindspore._c_expression import security
+from mindspore._c_expression import _collect_host_info
 
 HYPER_CONFIG_ENV_NAME = "MINDINSIGHT_HYPER_CONFIG"
 HYPER_CONFIG_LEN_LIMIT = 100000
@@ -70,9 +71,9 @@ class LineageMetadata:
 
 class SummaryCollector(Callback):
     """
-    SummaryCollector can help you to collect some common information.
+    SummaryCollector can help you to collect some common information,
+    such as loss, learning late, computational graph and so on.
 
-    It can help you to collect loss, learning late, computational graph and so on.
     SummaryCollector also enables the summary operator to collect data to summary files.
 
     Note:
@@ -90,50 +91,55 @@ class SummaryCollector(Callback):
             and the unit is `step`. If a frequency is set, we will collect data
             when (current steps % freq) equals to 0, and the first step will be collected at any time.
             It is important to note that if the data sink mode is used, the unit will become the `epoch`.
-            It is not recommended to collect data too frequently, which can affect performance. Default: 10.
+            It is not recommended to collect data too frequently, which can affect performance. Default: ``10`` .
+        num_process (int): Number of processes saving summary data. The more processes there are, the better the
+            performance, but there may be host memory overflow issues. Default: ``32`` .
         collect_specified_data (Union[None, dict]): Perform custom operations on the collected data.
             By default, if set to None, all data is collected as the default behavior.
             You can customize the collected data with a dictionary.
             For example, you can set {'collect_metric': False} to control not collecting metrics.
-            The data that supports control is shown below. Default: None.
+            The data that supports control is shown below. Default: ``None`` .
 
             - collect_metric (bool): Whether to collect training metrics, currently only the loss is collected.
-              The first output will be treated as the loss and it will be averaged. Default: True.
+              The first output will be treated as the loss and it will be averaged. Default: ``True`` .
             - collect_graph (bool): Whether to collect the computational graph. Currently, only
-              training computational graph is collected. Default: True.
+              training computational graph is collected. Default: ``True`` .
             - collect_train_lineage (bool): Whether to collect lineage data for the training phase,
               this field will be displayed on the `lineage page \
-              <https://www.mindspore.cn/mindinsight/docs/en/r2.0/lineage_and_scalars_comparison.html>`_
-              of MindInsight. Default: True.
+              <https://www.mindspore.cn/mindinsight/docs/en/r2.2/lineage_and_scalars_comparison.html>`_
+              of MindInsight. Default: ``True`` .
             - collect_eval_lineage (bool): Whether to collect lineage data for the evaluation phase,
-              this field will be displayed on the lineage page of MindInsight. Default: True.
+              this field will be displayed on the `lineage page
+              <https://www.mindspore.cn/mindinsight/docs/en/r2.2/lineage_and_scalars_comparison.html>`_
+              of MindInsight. Default: ``True`` .
             - collect_input_data (bool): Whether to collect dataset for each training.
               Currently only image data is supported.
               If there are multiple columns of data in the dataset, the first column should be image data.
-              Default: True.
-            - collect_dataset_graph (bool): Whether to collect dataset graph for the training phase. Default: True.
+              Default: ``True`` .
+            - collect_dataset_graph (bool): Whether to collect dataset graph for the training phase.
+              Default: ``True`` .
             - histogram_regular (Union[str, None]): Collect weight and bias for parameter distribution page
               and displayed in MindInsight. This field allows regular strings to control which parameters to collect.
               It is not recommended to collect too many parameters at once, as it can affect performance.
               Note that if you collect too many parameters and run out of memory, the training will fail.
-              Default: None, it means only the first five parameters are collected.
+              Default: ``None`` , it means only the first five parameters are collected.
             - collect_landscape (Union[dict,None]): Whether to collect the parameters needed to create the
               loss landscape. If set to None, collect_landscape parameters will not be collected. All parameter
               information is collected by default and stored in file `{summary_dir}/ckpt_dir/train_metadata.json`.
 
               - landscape_size (int): Specify the image resolution of the generated loss landscape.
-                For example, if it is set to 128, the resolution of the landscape is 128 * 128.
+                For example, if it is set to ``128`` , the resolution of the landscape is 128 * 128.
                 The calculation time increases with the increase of resolution.
-                Default: 40. Optional values: between 3 and 256.
-              - unit (str): Specify the interval strength of the training process. Default: "step".
+                Default: ``40`` . Optional values: between 3 and 256.
+              - unit (str): Specify the interval strength of the training process. Default: ``"step"`` .
                 Optional: epoch/step.
               - create_landscape (dict): Select how to create loss landscape.
                 Training process loss landscape(train) and training result loss landscape(result).
-                Default: {"train": True, "result": True}. Optional: True/False.
+                Default: {"train": True, "result": True}. Optional: ``True`` / ``False`` .
               - num_samples (int): The size of the dataset used to create the loss landscape.
                 For example, in image dataset, You can set num_samples is 128,
                 which means that 128 images are used to create loss landscape.
-                Default: 128.
+                Default: ``128`` .
               - 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
@@ -143,10 +149,11 @@ class SummaryCollector(Callback):
         keep_default_action (bool): This field affects the collection behavior of the 'collect_specified_data' field.
             True: it means that after specified data is set, non-specified data is collected as the default behavior.
             False: it means that after specified data is set, only the specified data is collected,
-            and the others are not collected. Default: True.
+            and the others are not collected. Default: ``True`` .
         custom_lineage_data (Union[dict, None]): Allows you to customize the data and present it on the MingInsight
-            lineage page. In the custom data, the type of the key supports str, and the type of value supports str, int
-            and float. Default: None, it means there is no custom data.
+            `lineage page <https://www.mindspore.cn/mindinsight/docs/en/r2.2/lineage_and_scalars_comparison.html>`_ .
+            In the custom data, the type of the key supports str, and the type of value supports str, int
+            and float. Default: ``None`` , it means there is no custom data.
         collect_tensor_freq (Optional[int]): The same semantics as the `collect_freq`, but controls TensorSummary only.
             Because TensorSummary data is too large to be compared with other summary data, this parameter is used to
             reduce its collection. By default, The maximum number of steps for collecting TensorSummary data is 20,
@@ -156,18 +163,18 @@ class SummaryCollector(Callback):
             but when the total steps is 20, both TensorSummary and other summary will be collected 3 steps.
             Also note that when in parallel mode, the total steps will be split evenly, which will
             affect the number of steps TensorSummary will be collected.
-            Default: None, which means to follow the behavior as described above.
+            Default: ``None`` , which means to follow the behavior as described above.
         max_file_size (Optional[int]): The maximum size in bytes of each file that can be written to the disk.
             For example, to write not larger than 4GB, specify `max_file_size=4*1024**3`.
-            Default: None, which means no limit.
+            Default: ``None`` , which means no limit.
         export_options (Union[None, dict]): Perform custom operations on the export data.
             Note that the size of export files is not limited by the max_file_size.
             You can customize the export data with a dictionary. For example, you can set {'tensor_format': 'npy'}
             to export tensor as npy file. The data that supports control is shown below.
-            Default: None, it means that the data is not exported.
+            Default: ``None`` , it means that the data is not exported.
 
             - tensor_format (Union[str, None]): Customize the export tensor format. Supports ["npy", None].
-              Default: None, it means that the tensor is not exported.
+              Default: ``None`` , it means that the tensor is not exported.
 
               - npy: export tensor as npy file.
 
@@ -176,17 +183,18 @@ class SummaryCollector(Callback):
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore.train import Model, SummaryCollector
-        >>> from mindspore.nn import Accuracy
+        >>> from mindspore import nn, SummaryCollector
+        >>> from mindspore.train import Model, Accuracy
         >>>
         >>> if __name__ == '__main__':
         ...     # If the device_target is GPU, set the device_target to "GPU"
         ...     ms.set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
         ...     mnist_dataset_dir = '/path/to/mnist_dataset_directory'
-        ...     # The detail of create_dataset method shown in model_zoo.official.cv.lenet.src.dataset.py
-        ...     ds_train = create_dataset(mnist_dataset_dir, 32)
-        ...     # The detail of LeNet5 shown in model_zoo.official.cv.lenet.src.lenet.py
+        ...     # Create the dataset taking MNIST as an example. Refer to
+        ...     # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        ...     ds_train = create_dataset()
+        ...     # Define the network structure of LeNet5. Refer to
+        ...     # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
         ...     network = LeNet5(10)
         ...     net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
         ...     net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
@@ -222,6 +230,7 @@ class SummaryCollector(Callback):
     def __init__(self,
                  summary_dir,
                  collect_freq=10,
+                 num_process=32,
                  collect_specified_data=None,
                  keep_default_action=True,
                  custom_lineage_data=None,
@@ -275,6 +284,7 @@ class SummaryCollector(Callback):
         self._is_parse_loss_success = True
         self._first_step = True
         self._dataset_sink_mode = True
+        self._num_process = num_process
 
     def __enter__(self):
         self._record = SummaryRecord(log_dir=self._summary_dir,
@@ -463,6 +473,7 @@ class SummaryCollector(Callback):
 
     def begin(self, run_context):
         cb_params = run_context.original_args()
+        _collect_host_info("Callback", "SummaryCollector", "begin", level=1)
         self._check_callbacks(cb_params)
 
         if cb_params.mode not in ModeEnum.to_list():
@@ -474,6 +485,7 @@ class SummaryCollector(Callback):
 
     def step_end(self, run_context):
         cb_params = run_context.original_args()
+        _collect_host_info("Callback", "SummaryCollector", "step_end", level=1)
         if cb_params.mode != ModeEnum.TRAIN.value:
             return
 
@@ -548,6 +560,7 @@ class SummaryCollector(Callback):
 
     def epoch_end(self, run_context):
         cb_params = run_context.original_args()
+        _collect_host_info("Callback", "SummaryCollector", "epoch_end", level=1)
         self._collect_tensor_data(cb_params)
         collect_landscape = self._collect_specified_data.get('collect_landscape')
         if collect_landscape is not None:
@@ -564,6 +577,7 @@ class SummaryCollector(Callback):
 
     def end(self, run_context):
         cb_params = run_context.original_args()
+        _collect_host_info("Callback", "SummaryCollector", "end", level=1)
         if cb_params.mode == ModeEnum.TRAIN.value:
             self._collect_train_lineage(cb_params)
         else: