mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/train/data_sink.py

@@ -12,25 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""
-Data sink help for minddata dataset
-
-Note:
-    This feature is a beta feature, and we are still improving its functionality.
-"""
-
-import math
+"""Data sink help for minddata dataset"""
 from functools import wraps
 import mindspore.ops as ops
 from mindspore import context
-from mindspore.common.api import ms_function
+from mindspore.common.dtype import pytype_to_dtype
+from mindspore.common.api import jit
 from mindspore.train._utils import _exec_datagraph, _get_types_and_shapes
-from mindspore.train.dataset_helper import _has_dynamic_shape
+from mindspore.train.dataset_helper import _has_dynamic_shape, _check_inputs
 import mindspore.dataset as ds
 from mindspore._c_expression import _set_dataset_mode_config
+from mindspore.parallel._utils import _get_device_num, _need_to_full, _to_full_shapes, _get_pipeline_stages
+from mindspore import _checkparam as Validator
 
 
-def _init_sink_dataset(dataset, steps, sink_size):
+def _init_sink_dataset(dataset, sink_size, input_signature, create_info):
     """
     Initialize data sinking
     """
@@ -42,45 +38,127 @@ def _init_sink_dataset(dataset, steps, sink_size):
     dynamic_shape = _has_dynamic_shape(dataset_shapes) or ds.config.get_dynamic_shape()
 
     # create transfer_dataset
-    create_data_info_queue = (sink_size == 1 and dataset_size != 1 and
-                              context.get_context('device_target') == 'Ascend' and not dynamic_shape)
-    transfer_dataset = _exec_datagraph(dataset, sink_size, create_data_info_queue=create_data_info_queue)
+    is_info_queue = (create_info and sink_size == 1 and dataset_size != 1 and
+                     input_signature is None and not dynamic_shape and
+                     context.get_context('device_target') == 'Ascend' and not context.get_context("enable_ge"))
+    transfer_dataset = _exec_datagraph(dataset, sink_size, create_data_info_queue=is_info_queue)
+    dataset.__transfer_dataset__ = transfer_dataset
 
     # send data
-    sink_count = math.ceil(steps/dataset_size)
-    transfer_dataset.send(sink_count)
+    transfer_dataset.send(-1)
 
     # create GetNext op
+    if input_signature is not None:
+        _check_inputs(input_signature, dataset_shapes, dataset_types)
+
     queue_name = transfer_dataset.queue_name
+    if _need_to_full() and context.get_context('mode') == context.GRAPH_MODE:
+        device_num = _get_device_num() // _get_pipeline_stages()
+        dataset_shapes = _to_full_shapes(dataset_shapes, device_num)
     next_op = ops.GetNext(dataset_types, dataset_shapes, len(dataset_types), queue_name)
 
     _set_dataset_mode_config('sink')
 
     dataset.__transfer_dataset__ = transfer_dataset
 
-    return next_op, create_data_info_queue
+    return next_op, is_info_queue
+
+
+class _DataSinkAux:
+    @staticmethod
+    def __deepcopy__(memodict):
+        return
 
 
-def data_sink(fn, dataset, steps, sink_size=1, jit=False):
+def _get_next_op(dataset, ori_next_op, is_info_queue):
+    """
+    get the next operation.
+    """
+
+    if not is_info_queue:
+        return ori_next_op, ''
+
+    if not hasattr(dataset, '__sink_aux__'):
+        dataset.__sink_aux__ = _DataSinkAux()
+        dataset.__sink_aux__.next_ops = {}
+        dataset.__sink_aux__.sink_funcs = {}
+
+    queue_name = dataset.__transfer_dataset__.queue_name
+    dataset_types, dataset_shapes = dataset.__transfer_dataset__.get_data_info()
+    dataset_types = [pytype_to_dtype(x) for x in dataset_types]
+    key = str(dataset_types) + str(dataset_shapes)
+    if key in dataset.__sink_aux__.next_ops:
+        next_op = dataset.__sink_aux__.next_ops[key]
+    else:
+        if _need_to_full() and context.get_context('mode') == context.GRAPH_MODE:
+            device_num = _get_device_num() // _get_pipeline_stages()
+            dataset_shapes = _to_full_shapes(dataset_shapes, device_num)
+        next_op = ops.GetNext(dataset_types, dataset_shapes, len(dataset_types), queue_name)
+
+    return next_op, (key, dataset_shapes, dataset_types)
+
+
+def _get_sink_fun(sink_fun, key_info, is_info_queue, dataset, jit_config):
+    """
+    get the sink function.
+    """
+    if not is_info_queue:
+        if not hasattr(dataset, '__sink_fun__'):
+            if jit_config is None:
+                dst_sink_fun = sink_fun
+            else:
+                dst_sink_fun = jit(sink_fun, jit_config=jit_config)
+            dataset.__sink_fun__ = dst_sink_fun
+
+        return dataset.__sink_fun__
+
+    key = key_info[0]
+    if key in dataset.__sink_aux__.sink_funcs:
+        dst_sink_fun = dataset.__sink_aux__.sink_funcs[key]
+    else:
+        if jit_config is None:
+            dst_sink_fun = sink_fun
+        else:
+            dst_sink_fun = jit(sink_fun, jit_config=jit_config)
+        dataset.__sink_aux__.sink_funcs[key] = dst_sink_fun
+
+    return dst_sink_fun
+
+
+def data_sink(fn, dataset, sink_size=1, jit_config=None, input_signature=None):
     """
     A wrapper function to generate a function for the input function.
 
-    The generated function will be executed in data sinking mode.
+    Note:
+        When using data sinking, the dataset will automatically cycle. At this time,
+        only the total number of training steps (total_step) and the number of steps for each sinking (sink_size)
+        need to be considered. When switching from training by rounds (epochs) to data sinking,
+        the formula is as follows:
+
+        total_step = epochs * dataset_size
+
+        train_sink_step = total_step / sink_size
+
+        After transforming from `mindspore.data_sink`, you need to execute `train_sink_step` step for training.
 
     Args:
         fn (Function): The Python function that will be run with dataset.
         dataset (Dataset): The dataset iterator. The dataset can be generated by dataset generator API in
-                           :class:`mindspore.dataset`, such as :class:`mindspore.dataset.ImageFolderDataset`.
-        steps (int): The total running steps. `steps` must be positive integer.
+            :class:`mindspore.dataset`, such as :class:`mindspore.dataset.ImageFolderDataset`.
         sink_size (int): Control the amount of data in each sink. `sink_size` must be positive integer. Default: 1.
-        jit (bool): Controls the execution mode(Graph mode/PyNative mode) of the generated function. Default: False,
-                    means running in PyNative mode.
+        jit_config (JitConfig): Controls the execution mode(Graph mode/PyNative mode) of the generated function, and Jit
+            config for compile. Default: None, means running in PyNative mode.
+        input_signature (Union[Tensor, List or Tuple of Tensors]): The Tensor which describes the input arguments.
+            The shape and dtype of the Tensor will be supplied to this function. If input_signature is specified,
+            each input to `fn` must be a `Tensor`. And the input parameters of `fn` cannot accept `**kwargs`. The shape
+            and dtype of actual inputs should keep the same as input_signature. Otherwise, TypeError will be raised.
+            Default: None.
 
     Returns:
         Function, the generated function will be executed in data sinking mode.
 
     Raises:
-        ValueError: If `steps` or `sink_size` is not positive integer.
+        ValueError: If `sink_size` is not positive integer.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -97,7 +175,7 @@ def data_sink(fn, dataset, steps, sink_size=1, jit=False):
         ...     out = x + y
         ...     return out
         >>>
-        >>> sink_process = ms.train.data_sink(func_net, dataset, steps=2, sink_size=1)
+        >>> sink_process = ms.train.data_sink(func_net, dataset, sink_size=1)
         >>> for _ in range(2):
         ...     out = sink_process()
         ...     print(out)
@@ -105,26 +183,37 @@ def data_sink(fn, dataset, steps, sink_size=1, jit=False):
         2
     """
 
-    if sink_size <= 0 or steps <= 0:
+    Validator.check_value_type("sink_size", sink_size, int, "Data sink")
+    if sink_size <= 0:
+        raise ValueError(
+            f"The 'sink_size' must be positive, but got sink_size {sink_size}.")
+
+    if context.get_context('device_target') not in ('Ascend', 'GPU'):
         raise ValueError(
-            f"The 'steps' and 'sink_size' must be positive, but got steps {steps} sink_size {sink_size}.")
+            f"Data sinking supports ascend or gpu device target, "
+            f"but device target is {context.get_context('device_target')}.")
 
-    next_op, _ = _init_sink_dataset(dataset, steps, sink_size)
+    loop = sink_size
+    create_info = True
+    if jit_config is None:
+        create_info = (loop == 1)
+        loop = 1
+    ori_next_op, is_info_queue = _init_sink_dataset(dataset, loop, input_signature, create_info)
 
     @wraps(fn)
     def sink_process(*args, **kwargs):
+        next_op, key_info = _get_next_op(dataset, ori_next_op, is_info_queue)
+
         def sink_fun():
             data = next_op()
             out = fn(*data)
             return out
 
-        real_sink_fun = sink_fun
+        real_sink_fun = _get_sink_fun(sink_fun, key_info, is_info_queue, dataset, jit_config)
+
         loop = sink_size
-        if jit:
+        if jit_config is not None:
             loop = 1
-            if not hasattr(dataset, '__sink_fun__'):
-                dataset.__sink_fun__ = ms_function(sink_fun)
-            real_sink_fun = dataset.__sink_fun__
 
         out = None
         for _ in range(loop):

mindspore/train/dataset_helper.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 import math
 
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common.dtype import pytype_to_dtype
 from mindspore.common.api import _cell_graph_executor
 from mindspore.common._utils import is_shape_unknown
@@ -27,8 +27,7 @@ from mindspore import context, nn
 from mindspore.train._utils import _exec_datagraph, _get_types_and_shapes, _construct_tensor_list
 from mindspore.parallel._utils import _get_device_num, _get_global_rank, _need_to_full, \
     _to_full_shapes, _get_pipeline_stages
-from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver, _is_role_sched, _is_ps_mode, \
-                                   _enable_distributed_mindrt
+from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.ops import operations as P
 
 
@@ -54,7 +53,6 @@ def _dynamic_sink_data(dataset, dataset_iter):
        dataset.get_dataset_size() != 1 and \
        hasattr(dataset_iter, "sink_count") and \
        dataset_iter.sink_count == 1 and \
-       context.get_context("device_target") == "Ascend" and \
        not _has_dynamic_shape(dataset_shapes) and \
        not ds.config.get_dynamic_shape():
         return True
@@ -65,8 +63,7 @@ def _dynamic_sink_exception_scenario(dataset_iter):
     """The exception scenario for dynamic data is not applicable."""
     _, dataset_shapes = dataset_iter.types_shapes()
 
-    if _has_dynamic_shape(dataset_shapes) or (_is_role_worker() and _is_ps_mode()) or \
-       context.get_context("mode") != context.GRAPH_MODE:
+    if _has_dynamic_shape(dataset_shapes) or context.get_context("mode") != context.GRAPH_MODE:
         return True
     return False
 
@@ -86,7 +83,7 @@ class _DataWrapper(nn.Cell):
     dataset channel 'queue_name' and performs the forward computation.
     """
 
-    def __init__(self, network, dataset_types, dataset_shapes, queue_name, min_shapes=None, max_shapes=None):
+    def __init__(self, network, dataset_types, dataset_shapes, queue_name):
         super(_DataWrapper, self).__init__(
             auto_prefix=False, flags=network.get_flags())
         # Also copy the flag in `network` construct
@@ -95,23 +92,19 @@ class _DataWrapper(nn.Cell):
         self.add_flags(**flags)
         self.get_next = P.GetNext(
             dataset_types, dataset_shapes, len(dataset_types), queue_name)
-        if min_shapes is not None and max_shapes is not None:
-            Validator.check_value_type("min_shapes", min_shapes, [list, tuple])
-            Validator.check_value_type("max_shapes", max_shapes, [list, tuple])
-            self.get_next.add_prim_attr("min_shapes", min_shapes)
-            self.get_next.add_prim_attr("max_shapes", max_shapes)
         self.network = network
+        if isinstance(network, nn.Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self):
         outputs = self.get_next()
         return self.network(*outputs)
 
 
-def _generate_dataset_sink_mode_net(network, dataset_shapes, dataset_types, queue_name,
-                                    min_shapes=None, max_shapes=None):
+def _generate_dataset_sink_mode_net(network, dataset_shapes, dataset_types, queue_name):
     if not isinstance(network, _DataWrapper):
         network = _DataWrapper(
-            network, dataset_types, dataset_shapes, queue_name, min_shapes, max_shapes)
+            network, dataset_types, dataset_shapes, queue_name)
     return network
 
 
@@ -127,24 +120,21 @@ def _generate_network_with_dataset(network, dataset_helper, queue_name):
     Generate new network with network and dataset info.
     """
     dataset_types, dataset_shapes = dataset_helper.types_shapes()
-    if not _has_dynamic_shape(dataset_shapes):
-        (min_shapes, max_shapes) = (None, None)
-    else:
-        (min_shapes, max_shapes) = dataset_helper.dynamic_min_max_shapes()
     if network.get_inputs() and None not in network.get_inputs():
-        _check_inputs(network, dataset_shapes, dataset_types)
-        min_shapes, max_shapes = None, None
-    network = _generate_dataset_sink_mode_net(network, dataset_shapes, dataset_types,
-                                              queue_name, min_shapes, max_shapes)
+        _check_inputs(network.get_inputs(), dataset_shapes, dataset_types)
+    elif context.get_context("mode") == context.PYNATIVE_MODE:
+        dataset_shapes = tuple([(-2,)] * len(dataset_shapes))
+    network = _generate_dataset_sink_mode_net(network, dataset_shapes, dataset_types, queue_name)
     return network
 
 
-def _check_inputs(network, dataset_shapes, dataset_types):
+def _check_inputs(network_shapes, dataset_shapes, dataset_types):
     """
     Check if set inputs are correct.
     """
-    network_shapes = network.get_inputs()
     for tensor_index, ele_dataset_shape in enumerate(dataset_shapes):
+        if network_shapes[tensor_index] is None:
+            continue
         set_inputs_shape = list(network_shapes[tensor_index].shape)
         inputs_shape = list(ele_dataset_shape)
         if dataset_types[tensor_index] != network_shapes[tensor_index].dtype:
@@ -155,18 +145,15 @@ def _check_inputs(network, dataset_shapes, dataset_types):
             )
         if len(inputs_shape) != len(set_inputs_shape):
             raise ValueError(
-                f"For 'set_inputs', the Dimension of Tensor shape must be {len(inputs_shape)}, but got "
-                f"{len(set_inputs_shape)}"
-            )
-        if network_shapes[tensor_index] is None:
-            break
+                f"The {tensor_index + 1}th input dims of 'set_inputs' must be the same as network's input, "
+                f"but got 'set_inputs': {len(set_inputs_shape)} and network's input: {len(inputs_shape)}.")
         for index, ele_shape in enumerate(ele_dataset_shape):
             if network_shapes[tensor_index].shape[index] != -1:
                 if set_inputs_shape[index] != ele_shape:
                     raise ValueError(
-                        f"For 'Tensor shape', the value must be the same with that of inputs, but "
-                        f"got {set_inputs_shape[index]}"
-                    )
+                        f"The {index + 1}th input shape of 'set_inputs' must be the same as network's input, "
+                        f"but got 'set_inputs': {set_inputs_shape[index]} and network's input: "
+                        f"{dataset_shapes[tensor_index][index]}.")
             else:
                 dataset_shapes[tensor_index][index] = -1
 
@@ -231,7 +218,7 @@ def connect_network_with_dataset(network, dataset_helper):
         raise RuntimeError(
             "The API 'connect_network_with_dataset' should be called in dataset sink mode.")
 
-    if _is_role_sched() or (_is_role_pserver() and not _enable_distributed_mindrt()):
+    if _is_role_sched():
         return network
 
     if not hasattr(aux, '__network__'):
@@ -333,10 +320,8 @@ class DatasetHelper:
                 iterclass = _DatasetIterGE
             else:
                 if context.get_context("mode") == context.GRAPH_MODE:
-                    if _is_role_sched() or (_is_role_pserver() and not _enable_distributed_mindrt()):
+                    if _is_role_sched():
                         iterclass = _DatasetIterPSServer
-                    elif _is_role_worker() and _is_ps_mode() and not _enable_distributed_mindrt():
-                        iterclass = _DatasetIterPSWork
                     elif (context.get_context("device_target") == "Ascend") or \
                          (context.get_context("device_target") == "GPU"):
                         iterclass = _DatasetIterMSLoopSink
@@ -409,9 +394,9 @@ class DatasetHelper:
         """Continue to send data to device at the beginning of epoch."""
         self.iter.continue_send()
 
-    def _reset(self, step):
-        """Reset the dataset to the provided step."""
-        self.iter._reset(step)  # pylint: disable=W0212
+    def _reset(self, step, epoch):
+        """Reset the dataset to the provided step and epoch."""
+        self.iter._reset(step, epoch)  # pylint: disable=protected-access
 
     def get_data_info(self):
         """
@@ -420,28 +405,6 @@ class DatasetHelper:
         """
         return self.iter.get_data_info()
 
-    def dynamic_min_max_shapes(self):
-        """
-        Return the minimum and maximum data length of dynamic source dataset.
-
-        Examples:
-            >>> import mindspore as ms
-            >>> import numpy as np
-            >>>
-            >>> # Define a dataset pipeline
-            >>> def generator():
-            ...    for i in range(5):
-            ...        yield (np.ones((32, i)),)
-            >>>
-            >>> train_dataset = ms.dataset.GeneratorDataset(generator, ["data"])
-            >>> # config dynamic shape
-            >>> train_dataset.set_dynamic_columns(columns={"data": [32, None]})
-            >>> dataset_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=True)
-            >>>
-            >>> min_shapes, max_shapes = dataset_helper.dynamic_min_max_shapes()
-        """
-        return self.iter.dynamic_min_max_shapes()
-
 
 class _DatasetIter:
     """Base iter for dataset helper"""
@@ -457,11 +420,9 @@ class _DatasetIter:
             ds.config.set_dynamic_shape(True)
         if not hasattr(dataset, '__transfer_dataset__'):
             if hasattr(dataset, '__loop_size__'):
-                # PS mode does not support loop sink and need get the real sink size.
-                if not (_is_role_worker() and _is_ps_mode()) or _enable_distributed_mindrt():
-                    self.sink_size = dataset.__loop_size__
+                self.sink_size = dataset.__loop_size__
             create_data_info_queue = (sink_size == 1 and self.sink_count == 1 and dataset.get_dataset_size() != 1
-                                      and context.get_context("device_target") == "Ascend" and not self.dynamic_shape)
+                                      and not self.dynamic_shape)
             dataset.__transfer_dataset__ = _exec_datagraph(dataset, self.sink_size,
                                                            create_data_info_queue=create_data_info_queue)
 
@@ -478,9 +439,8 @@ class _DatasetIter:
         self.release = dataset.__transfer_dataset__.release
         self.continue_send = dataset.__transfer_dataset__.continue_send
         self.get_data_info = dataset.__transfer_dataset__.get_data_info
-        self.dynamic_min_max_shapes = dataset.dynamic_min_max_shapes
         if hasattr(dataset.__transfer_dataset__, "_reset"):
-            self._reset = dataset.__transfer_dataset__._reset  # pylint: disable=W0212
+            self._reset = dataset.__transfer_dataset__._reset  # pylint: disable=protected-access
 
     def __iter__(self):
         self.index = 0
@@ -514,9 +474,6 @@ class _DatasetIter:
         sink_size = 1
         if hasattr(self.dataset, '__loop_size__'):
             sink_size = self.dataset.__loop_size__
-        elif _is_role_worker() and _is_ps_mode() and not _enable_distributed_mindrt():
-            # PS mode does not support loop sink.
-            sink_size = 1
         else:
             if context.get_context("enable_ge") or context.get_context("device_target") == "Ascend" \
                     or context.get_context("device_target") == "GPU":
@@ -596,22 +553,6 @@ class _DatasetIterPSServer(_DatasetIter):
         self.op = op
 
 
-class _DatasetIterPSWork(_DatasetIter):
-    """Iter for context on MS_WORKER"""
-
-    def __init__(self, dataset, sink_size, epoch_num):
-        super().__init__(dataset, sink_size, epoch_num)
-        if sink_size > 0:
-            self.sink_count = sink_size
-        else:
-            self.sink_count = dataset.get_dataset_size()
-
-        def op():
-            return tuple()
-
-        self.op = op
-
-
 class _DatasetIterNormal:
     """Iter for normal(non sink) mode, feed the data from host."""
 

mindspore/train/loss_scale_manager.py

@@ -15,7 +15,7 @@
 """Loss scale manager abstract class."""
 from __future__ import absolute_import
 
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 from mindspore import nn
 
 
@@ -61,12 +61,6 @@ class FixedLossScaleManager(LossScaleManager):
         >>> from mindspore import amp, nn
         >>>
         >>> net = Net()
-        >>> #1) Drop the parameter update if there is an overflow
-        >>> loss_scale_manager = amp.FixedLossScaleManager()
-        >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-        >>> model = ms.Model(net, loss_scale_manager=loss_scale_manager, optimizer=optim)
-        >>>
-        >>> #2) Execute parameter update even if overflow occurs
         >>> loss_scale = 1024.0
         >>> loss_scale_manager = amp.FixedLossScaleManager(loss_scale, False)
         >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9, loss_scale=loss_scale)
@@ -131,6 +125,9 @@ class DynamicLossScaleManager(LossScaleManager):
         scale_factor (int): Coefficient of increase and decrease. Default: 2.
         scale_window (int): Maximum continuous normal steps when there is no overflow. Default: 2000.
 
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
     Examples:
         >>> import mindspore as ms
         >>> from mindspore import amp, nn

mindspore/{nn → train}/metrics/__init__.py

@@ -20,25 +20,25 @@ on the evaluation dataset. It's used to choose the best model.
 """
 from __future__ import absolute_import
 
-from mindspore.nn.metrics.accuracy import Accuracy
-from mindspore.nn.metrics.hausdorff_distance import HausdorffDistance
-from mindspore.nn.metrics.error import MAE, MSE
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
-from mindspore.nn.metrics.precision import Precision
-from mindspore.nn.metrics.recall import Recall
-from mindspore.nn.metrics.fbeta import Fbeta, F1
-from mindspore.nn.metrics.dice import Dice
-from mindspore.nn.metrics.roc import ROC
-from mindspore.nn.metrics.auc import auc
-from mindspore.nn.metrics.topk import TopKCategoricalAccuracy, Top1CategoricalAccuracy, Top5CategoricalAccuracy
-from mindspore.nn.metrics.loss import Loss
-from mindspore.nn.metrics.mean_surface_distance import MeanSurfaceDistance
-from mindspore.nn.metrics.root_mean_square_surface_distance import RootMeanSquareDistance
-from mindspore.nn.metrics.bleu_score import BleuScore
-from mindspore.nn.metrics.cosine_similarity import CosineSimilarity
-from mindspore.nn.metrics.occlusion_sensitivity import OcclusionSensitivity
-from mindspore.nn.metrics.perplexity import Perplexity
-from mindspore.nn.metrics.confusion_matrix import ConfusionMatrixMetric, ConfusionMatrix
+from mindspore.train.metrics.accuracy import Accuracy
+from mindspore.train.metrics.hausdorff_distance import HausdorffDistance
+from mindspore.train.metrics.error import MAE, MSE
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
+from mindspore.train.metrics.precision import Precision
+from mindspore.train.metrics.recall import Recall
+from mindspore.train.metrics.fbeta import Fbeta, F1
+from mindspore.train.metrics.dice import Dice
+from mindspore.train.metrics.roc import ROC
+from mindspore.train.metrics.auc import auc
+from mindspore.train.metrics.topk import TopKCategoricalAccuracy, Top1CategoricalAccuracy, Top5CategoricalAccuracy
+from mindspore.train.metrics.loss import Loss
+from mindspore.train.metrics.mean_surface_distance import MeanSurfaceDistance
+from mindspore.train.metrics.root_mean_square_surface_distance import RootMeanSquareDistance
+from mindspore.train.metrics.bleu_score import BleuScore
+from mindspore.train.metrics.cosine_similarity import CosineSimilarity
+from mindspore.train.metrics.occlusion_sensitivity import OcclusionSensitivity
+from mindspore.train.metrics.perplexity import Perplexity
+from mindspore.train.metrics.confusion_matrix import ConfusionMatrixMetric, ConfusionMatrix
 
 __all__ = [
     "names",
@@ -113,7 +113,7 @@ def get_metric_fn(name, *args, **kwargs):
     Gets the metric method based on the input name.
 
     Args:
-        name (str): The name of metric method. Names can be obtained by `mindspore.nn.names` .
+        name (str): The name of metric method. Names can be obtained by :func:`mindspore.train.names` .
             object for the currently supported metrics.
         args: Arguments for the metric function.
         kwargs: Keyword arguments for the metric function.

mindspore/{nn → train}/metrics/accuracy.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore.nn.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
+from mindspore.train.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
 
 
 class Accuracy(EvaluationBase):
@@ -42,11 +42,12 @@ class Accuracy(EvaluationBase):
     Examples:
         >>> import numpy as np
         >>> import mindspore
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Accuracy
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
         >>> y = Tensor(np.array([1, 0, 1]), mindspore.float32)
-        >>> metric = nn.Accuracy('classification')
+        >>> metric = Accuracy('classification')
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> accuracy = metric.eval()
@@ -72,13 +73,14 @@ class Accuracy(EvaluationBase):
 
         Args:
             inputs: Logits and labels. `y_pred` stands for logits, `y` stands for labels. `y_pred` and `y` must be a
-              `Tensor`, a list or an array.
-              For the 'classification' evaluation type, `y_pred` is a list of floating numbers in range :math:`[0, 1]`
-              and the shape is :math:`(N, C)` in most cases (not strictly), where :math:`N` is the number of cases and
-              :math:`C` is the number of categories. `y` must be in one-hot format that shape is :math:`(N, C)`, or can
-              be transformed to one-hot format that shape is :math:`(N,)`.
-              For 'multilabel' evaluation type, the value of `y_pred` and `y` can only be 0 or 1, indices with 1
-              indicate the positive category. The shape of `y_pred` and `y` are both :math:`(N, C)`.
+                `Tensor`, a list or an array.
+
+                - For the 'classification' evaluation type, `y_pred` is a list of floating numbers in range
+                  :math:`[0, 1]` and the shape is :math:`(N, C)` in most cases (not strictly), where :math:`N`
+                  is the number of cases and :math:`C` is the number of categories. `y` must be in one-hot format
+                  that shape is :math:`(N, C)`, or can be transformed to one-hot format that shape is :math:`(N,)`.
+                - For 'multilabel' evaluation type, the value of `y_pred` and `y` can only be 0 or 1, indices with 1
+                  indicate the positive category. The shape of `y_pred` and `y` are both :math:`(N, C)`.
 
         Raises:
             ValueError: If the number of the inputs is not 2.

mindspore/{nn → train}/metrics/auc.py

@@ -21,7 +21,7 @@ import numpy as np
 def auc(x, y, reorder=False):
     """
     Computes the AUC(Area Under the Curve) using the trapezoidal rule. This is a general function, given points on a
-    curve. For computing the area under the ROC-curve.
+    curve, for computing the area under the ROC-curve.
 
     Args:
         x (Union[np.array, list]): From the ROC curve(fpr), np.array with false positive rates. If multiclass,
@@ -39,15 +39,15 @@ def auc(x, y, reorder=False):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn
+        >>> from mindspore.train import ROC, auc
         >>>
         >>> y_pred = np.array([[3, 0, 1], [1, 3, 0], [1, 0, 2]])
         >>> y = np.array([[0, 2, 1], [1, 2, 1], [0, 0, 1]])
-        >>> metric = nn.ROC(pos_label=2)
+        >>> metric = ROC(pos_label=2)
         >>> metric.clear()
         >>> metric.update(y_pred, y)
         >>> fpr, tpr, thre = metric.eval()
-        >>> output = nn.auc(fpr, tpr)
+        >>> output = auc(fpr, tpr)
         >>> print(output)
         0.5357142857142857
     """