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

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 from collections import Counter
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class BleuScore(Metric):
@@ -38,12 +38,12 @@ class BleuScore(Metric):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.nn as nn
+        >>> from mindspore.train import BleuScore
         >>>
         >>> candidate_corpus = [['i', 'have', 'a', 'pen', 'on', 'my', 'desk']]
         >>> reference_corpus = [[['i', 'have', 'a', 'pen', 'in', 'my', 'desk'],
         ...                      ['there', 'is', 'a', 'pen', 'on', 'the', 'desk']]]
-        >>> metric = nn.BleuScore()
+        >>> metric = BleuScore()
         >>> metric.clear()
         >>> metric.update(candidate_corpus, reference_corpus)
         >>> bleu_score = metric.eval()

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

@@ -17,8 +17,8 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class ConfusionMatrix(Metric):
@@ -27,7 +27,7 @@ class ConfusionMatrix(Metric):
     including binary classification and multiple classification.
 
     If you only need confusion matrix, use this class. If you want to calculate other metrics, such as 'PPV',
-    'TPR', 'TNR', etc., use class 'mindspore.nn.ConfusionMatrixMetric'.
+    'TPR', 'TNR', etc., use class :class:`mindspore.train.ConfusionMatrixMetric` .
 
     Args:
         num_classes (int): Number of classes in the dataset.
@@ -45,11 +45,12 @@ class ConfusionMatrix(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import ConfusionMatrix
         >>>
         >>> x = Tensor(np.array([1, 0, 1, 0]))
         >>> y = Tensor(np.array([1, 0, 0, 1]))
-        >>> metric = nn.ConfusionMatrix(num_classes=2, normalize='no_norm', threshold=0.5)
+        >>> metric = ConfusionMatrix(num_classes=2, normalize='no_norm', threshold=0.5)
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> output = metric.eval()
@@ -151,7 +152,7 @@ class ConfusionMatrixMetric(Metric):
     of `metric_name`.
 
     If you want to calculate metrics related to confusion matrix, such as 'PPV', 'TPR', 'TNR', use this class.
-    If you only want to calculate confusion matrix, please use 'mindspore.metrics.ConfusionMatrix'.
+    If you only want to calculate confusion matrix, please use :class:`mindspore.train.ConfusionMatrix` .
 
     Args:
         skip_channel (bool): Whether to skip the measurement calculation on the first channel of the predicted output.
@@ -174,9 +175,10 @@ class ConfusionMatrixMetric(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import ConfusionMatrixMetric
         >>>
-        >>> metric = nn.ConfusionMatrixMetric(skip_channel=True, metric_name="tpr",
+        >>> metric = ConfusionMatrixMetric(skip_channel=True, metric_name="tpr",
         ...                                   calculation_method=False, decrease="mean")
         >>> metric.clear()
         >>> x = Tensor(np.array([[[0], [1]], [[1], [0]]]))

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

@@ -17,8 +17,8 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class CosineSimilarity(Metric):
@@ -35,10 +35,10 @@ class CosineSimilarity(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn
+        >>> from mindspore.train import CosineSimilarity
         >>>
         >>> test_data = np.array([[1, 3, 4, 7], [2, 4, 2, 5], [3, 1, 5, 8]])
-        >>> metric = nn.CosineSimilarity()
+        >>> metric = CosineSimilarity()
         >>> metric.clear()
         >>> metric.update(test_data)
         >>> square_matrix = metric.eval()

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

@@ -17,8 +17,8 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class Dice(Metric):
@@ -40,11 +40,12 @@ class Dice(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Dice
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
         >>> y = Tensor(np.array([[0, 1], [1, 0], [0, 1]]))
-        >>> metric = nn.Dice(smooth=1e-5)
+        >>> metric = Dice(smooth=1e-5)
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> dice = metric.eval()
@@ -68,7 +69,7 @@ class Dice(Metric):
     @rearrange_inputs
     def update(self, *inputs):
         r"""
-        Updates the internal evaluation result :math:`y\_pred` and :math:`y`.
+        Updates the internal evaluation result `y_pred` and `y`.
 
         Args:
             inputs (tuple): Input `y_pred` and `y`. `y_pred` and `y` are Tensor, list or numpy.ndarray. `y_pred` is the

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

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class MAE(Metric):
@@ -38,11 +38,12 @@ class MAE(Metric):
     Examples:
         >>> import numpy as np
         >>> import mindspore
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import MAE
         >>>
         >>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
         >>> y = Tensor(np.array([0.1, 0.25, 0.7, 0.9]), mindspore.float32)
-        >>> error = nn.MAE()
+        >>> error = MAE()
         >>> error.clear()
         >>> error.update(x, y)
         >>> result = error.eval()
@@ -114,11 +115,12 @@ class MSE(Metric):
     Examples:
         >>> import numpy as np
         >>> import mindspore
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import MSE
         >>>
         >>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
         >>> y = Tensor(np.array([0.1, 0.25, 0.5, 0.9]), mindspore.float32)
-        >>> error = nn.MSE()
+        >>> error = MSE()
         >>> error.clear()
         >>> error.update(x, y)
         >>> result = error.eval()

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 import sys
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs, _check_onehot_data
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs, _check_onehot_data
 
 
 class Fbeta(Metric):
@@ -40,11 +40,12 @@ class Fbeta(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Fbeta
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
         >>> y = Tensor(np.array([1, 0, 1]))
-        >>> metric = nn.Fbeta(1)
+        >>> metric = Fbeta(1)
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> fbeta = metric.eval()
@@ -141,7 +142,7 @@ class Fbeta(Metric):
 class F1(Fbeta):
     r"""
     Calculates the F1 score. F1 is a special case of Fbeta when beta is 1.
-    Refer to class :class:`mindspore.nn.Fbeta` for more details.
+    Refer to class :class:`mindspore.train.Fbeta` for more details.
 
     .. math::
         F_1=\frac{2\cdot true\_positive}{2\cdot true\_positive + false\_negative + false\_positive}
@@ -151,11 +152,12 @@ class F1(Fbeta):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import F1
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
         >>> y = Tensor(np.array([1, 0, 1]))
-        >>> metric = nn.F1()
+        >>> metric = F1()
         >>> metric.update(x, y)
         >>> result = metric.eval()
         >>> print(result)

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

@@ -21,8 +21,8 @@ from scipy.ndimage import morphology
 import numpy as np
 
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class _ROISpatialData(metaclass=ABCMeta):
@@ -78,9 +78,10 @@ class HausdorffDistance(Metric):
                 h(B, A) = \underset{b \in B}{\text{max}}\{\underset{a \in A}{\text{min}} \rVert b - a \rVert \}
         \end{array}
 
-    where h(A,B) is the maximum distance of a set A to the nearest point in the set B, h(B,A) is the maximum distance
+    where :math:`h(A,B)` is the maximum distance of a set A to the nearest point in the set B,
+    :math:`h(B, A)` is the maximum distance
     of a set B to the nearest point in the set A. The distance calculation is oriented, which means that most of times
-    :math:`h(A, B)` is not equal to :math:`h(B, A)`. H(A, B) is the two-way Hausdorff distance.
+    :math:`h(A, B)` is not equal to :math:`h(B, A)`. :math:`H(A, B)` is the two-way Hausdorff distance.
 
     Args:
         distance_metric (string): Three distance measurement methods are supported: "euclidean", "chessboard" or
@@ -98,11 +99,12 @@ class HausdorffDistance(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import HausdorffDistance
         >>>
         >>> x = Tensor(np.array([[3, 0, 1], [1, 3, 0], [1, 0, 2]]))
         >>> y = Tensor(np.array([[0, 2, 1], [1, 2, 1], [0, 0, 1]]))
-        >>> metric = nn.HausdorffDistance()
+        >>> metric = HausdorffDistance()
         >>> metric.clear()
         >>> metric.update(x, y, 0)
         >>> mean_average_distance = metric.eval()

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

@@ -15,7 +15,7 @@
 """Loss for evaluation"""
 from __future__ import absolute_import
 
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class Loss(Metric):
@@ -32,10 +32,11 @@ class Loss(Metric):
     Examples:
         >>> import numpy as np
         >>> import mindspore
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Loss
         >>>
         >>> x = Tensor(np.array(0.2), mindspore.float32)
-        >>> loss = nn.Loss()
+        >>> loss = Loss()
         >>> loss.clear()
         >>> loss.update(x)
         >>> result = loss.eval()

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 from scipy.ndimage import morphology
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class MeanSurfaceDistance(Metric):
@@ -54,17 +54,18 @@ class MeanSurfaceDistance(Metric):
         symmetric (bool): Whether to calculate the Mean Surface Distance between y_pred and y.
                           If False, it only calculates :math:`AvgSurDis({y\_pred} \rightarrow y)`,
                           otherwise, the mean of  distance from `y_pred` to `y` and from `y` to `y_pred`, i.e.
-                          :math:`MeanSurDis(y_{pred} \leftrightarrow y)`, will be returned. Default: False.
+                          :math:`MeanSurDis(y\_pred \leftrightarrow y)`, will be returned. Default: False.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import MeanSurfaceDistance
         >>> x = Tensor(np.array([[3, 0, 1], [1, 3, 0], [1, 0, 2]]))
         >>> y = Tensor(np.array([[0, 2, 1], [1, 2, 1], [0, 0, 1]]))
-        >>> metric = nn.MeanSurfaceDistance(symmetric=False, distance_metric="euclidean")
+        >>> metric = MeanSurfaceDistance(symmetric=False, distance_metric="euclidean")
         >>> metric.clear()
         >>> metric.update(x, y, 0)
         >>> mean_average_distance = metric.eval()

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

@@ -28,7 +28,7 @@ def rearrange_inputs(func):
     """
     This decorator is used to rearrange the inputs according to its `indexes` attribute of the class.
 
-    This decorator is currently applied on the `update` of :class:`mindspore.nn.Metric`.
+    This decorator is currently applied on the `update` of :class:`mindspore.train.Metric`.
 
     Args:
         func (Callable): A candidate function to be wrapped whose input will be rearranged.
@@ -79,7 +79,7 @@ class Metric(metaclass=ABCMeta):
     result, and `clear` will reinitialize the intermediate results.
 
     Never use this class directly, but instantiate one of its subclasses instead, for examples,
-    :class:`mindspore.nn.MAE`, :class:`mindspore.nn.Recall` etc.
+    :class:`mindspore.train.MAE`, :class:`mindspore.train.Recall` etc.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -123,7 +123,7 @@ class Metric(metaclass=ABCMeta):
 
         Note:
             When customize a metric, decorate the `update` function with the decorator
-            :func:`mindspore.nn.rearrange_inputs` for the `indexes` to take effect.
+            :func:`mindspore.train.rearrange_inputs` for the `indexes` to take effect.
 
         Args:
             indexes (List(int)): The order of logits and labels to be rearranged.
@@ -136,12 +136,13 @@ class Metric(metaclass=ABCMeta):
 
         Examples:
             >>> import numpy as np
-            >>> 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]]))
             >>> y = Tensor(np.array([1, 0, 1]))
             >>> y2 = Tensor(np.array([0, 0, 1]))
-            >>> metric = nn.Accuracy('classification').set_indexes([0, 2])
+            >>> metric = Accuracy('classification').set_indexes([0, 2])
             >>> metric.clear()
             >>> # indexes is [0, 2], using x as logits, y2 as label.
             >>> metric.update(x, y, y2)

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

@@ -19,8 +19,8 @@ import numpy as np
 
 from mindspore import nn
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 try:
     from tqdm import trange
@@ -55,6 +55,7 @@ class OcclusionSensitivity(Metric):
     Examples:
         >>> import numpy as np
         >>> from mindspore import nn, Tensor
+        >>> from mindspore.train import OcclusionSensitivity
         >>>
         >>> class DenseNet(nn.Cell):
         ...     def __init__(self):
@@ -69,7 +70,7 @@ class OcclusionSensitivity(Metric):
         >>> model = DenseNet()
         >>> test_data = np.array([[0.1, 0.2, 0.3, 0.4]]).astype(np.float32)
         >>> label = np.array(1).astype(np.int32)
-        >>> metric = nn.OcclusionSensitivity()
+        >>> metric = OcclusionSensitivity()
         >>> metric.clear()
         >>> metric.update(model, test_data, label)
         >>> score = metric.eval()

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 import math
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class Perplexity(Metric):
@@ -41,10 +41,11 @@ class Perplexity(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Perplexity
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
         >>> y = Tensor(np.array([1, 0, 1]))
-        >>> metric = nn.Perplexity(ignore_label=None)
+        >>> metric = Perplexity(ignore_label=None)
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> perplexity = metric.eval()

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 import sys
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
 
 
 class Precision(EvaluationBase):
@@ -43,11 +43,12 @@ class Precision(EvaluationBase):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Precision
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
         >>> y = Tensor(np.array([1, 0, 1]))
-        >>> metric = nn.Precision('classification')
+        >>> metric = Precision('classification')
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> precision = metric.eval()

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 import sys
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
 
 
 class Recall(EvaluationBase):
@@ -44,11 +44,12 @@ class Recall(EvaluationBase):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Recall
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
         >>> y = Tensor(np.array([1, 0, 1]))
-        >>> metric = nn.Recall('classification')
+        >>> metric = Recall('classification')
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> recall = metric.eval()

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

@@ -17,8 +17,8 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs, _binary_clf_curve
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs, _binary_clf_curve
 
 
 class ROC(Metric):
@@ -38,12 +38,13 @@ class ROC(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import ROC
         >>>
         >>> # 1) binary classification example
         >>> x = Tensor(np.array([3, 1, 4, 2]))
         >>> y = Tensor(np.array([0, 1, 2, 3]))
-        >>> metric = nn.ROC(pos_label=2)
+        >>> metric = ROC(pos_label=2)
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> fpr, tpr, thresholds = metric.eval()
@@ -58,7 +59,7 @@ class ROC(Metric):
         >>> x = Tensor(np.array([[0.28, 0.55, 0.15, 0.05], [0.10, 0.20, 0.05, 0.05], [0.20, 0.05, 0.15, 0.05],
         ...                     [0.05, 0.05, 0.05, 0.75]]))
         >>> y = Tensor(np.array([0, 1, 2, 3]))
-        >>> metric = nn.ROC(class_num=4)
+        >>> metric = ROC(class_num=4)
         >>> metric.clear()
         >>> metric.update(x, y)
         >>> fpr, tpr, thresholds = metric.eval()
@@ -93,7 +94,7 @@ class ROC(Metric):
             inputs: Input `y_pred` and `y`. `y_pred` and `y` are `Tensor`, list or numpy.ndarray.
                 In most cases (not strictly), y_pred is a list of floating numbers in range :math:`[0, 1]`
                 and the shape is :math:`(N, C)`, where :math:`N` is the number of cases and :math:`C`
-                is the number of categories. y contains values of integers. The shape is :math:`(N,C)` if one-hot
+                is the number of categories. y contains values of integers. The shape is :math:`(N, C)` if one-hot
                 encoding is used. Shape can also be :math:`(N,)` if category index is used.
         """
         if len(inputs) != 2:

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

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 from scipy.ndimage import morphology
 import numpy as np
 
-from mindspore._checkparam import Validator as validator
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 
 class RootMeanSquareDistance(Metric):
@@ -51,7 +51,7 @@ class RootMeanSquareDistance(Metric):
         distance_metric (string): Three measurement methods are supported:
                 "euclidean", "chessboard" or "taxicab". Default: "euclidean".
         symmetric (bool):  Whether to calculate the symmetric average root mean square distance between
-                y_pred and y. If False, only calculates :math:`RmsSurDis(y_{pred}, y)` surface distance,
+                y_pred and y. If False, only calculates :math:`RmsSurDis(y\_pred, y)` surface distance,
                 otherwise, the mean of  distance from `y_pred` to `y` and from `y` to `y_pred`, i.e.
                 :math:`RmsSurDis({y\_pred} \leftrightarrow y)` will be returned. Default: False.
 
@@ -60,11 +60,12 @@ class RootMeanSquareDistance(Metric):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import RootMeanSquareDistance
         >>>
         >>> x = Tensor(np.array([[3, 0, 1], [1, 3, 0], [1, 0, 2]]))
         >>> y = Tensor(np.array([[0, 2, 1], [1, 2, 1], [0, 0, 1]]))
-        >>> metric = nn.RootMeanSquareDistance(symmetric=False, distance_metric="euclidean")
+        >>> metric = RootMeanSquareDistance(symmetric=False, distance_metric="euclidean")
         >>> metric.clear()
         >>> metric.update(x, y, 0)
         >>> root_mean_square_distance = metric.eval()

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

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from mindspore.nn.metrics.metric import Metric, rearrange_inputs, _check_onehot_data
+from mindspore.train.metrics.metric import Metric, rearrange_inputs, _check_onehot_data
 
 
 class TopKCategoricalAccuracy(Metric):
@@ -37,12 +37,13 @@ class TopKCategoricalAccuracy(Metric):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import TopKCategoricalAccuracy
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
         ...         [0.9, 0.6, 0.2, 0.01, 0.3]]), mindspore.float32)
         >>> y = Tensor(np.array([2, 0, 1]), mindspore.float32)
-        >>> topk = nn.TopKCategoricalAccuracy(3)
+        >>> topk = TopKCategoricalAccuracy(3)
         >>> topk.clear()
         >>> topk.update(x, y)
         >>> output = topk.eval()
@@ -120,12 +121,13 @@ class Top1CategoricalAccuracy(TopKCategoricalAccuracy):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Top1CategoricalAccuracy
         >>>
         >>> x = Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
         ...         [0.9, 0.6, 0.2, 0.01, 0.3]]), mindspore.float32)
         >>> y = Tensor(np.array([2, 0, 1]), mindspore.float32)
-        >>> topk = nn.Top1CategoricalAccuracy()
+        >>> topk = Top1CategoricalAccuracy()
         >>> topk.clear()
         >>> topk.update(x, y)
         >>> output = topk.eval()