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

mindspore/train/metrics/__init__.py

@@ -104,6 +104,14 @@ def names():
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.train.names()
+        ['F1', 'acc', 'accuracy', 'auc', 'bleu_score', 'confusion_matrix', 'confusion_matrix_metric',
+        'cosine_similarity', 'dice', 'hausdorff_distance', 'loss', 'mae', 'mean_surface_distance', 'mse',
+        'occlusion_sensitivity', 'perplexity', 'precision', 'recall', 'roc', 'root_mean_square_distance',
+        'top_1_accuracy', 'top_5_accuracy', 'topk']
     """
     return sorted(__factory__.keys())
 
@@ -125,8 +133,8 @@ def get_metric_fn(name, *args, **kwargs):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import nn
-        >>> metric = nn.get_metric_fn('precision', eval_type='classification')
+        >>> from mindspore.train import get_metric_fn
+        >>> metric = get_metric_fn('precision', eval_type='classification')
     """
     if name not in __factory__:
         raise KeyError(f"For 'get_metric_fn', unsupported metric {name}, please refer to official website "

mindspore/train/metrics/accuracy.py

@@ -34,7 +34,7 @@ class Accuracy(EvaluationBase):
     Args:
         eval_type (str): The metric to calculate the accuracy over a dataset. Supports 'classification' and
           'multilabel'. 'classification' means the dataset label is single. 'multilabel' means the dataset has multiple
-          labels. Default: 'classification'.
+          labels. Default: ``'classification'`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/train/metrics/auc.py

@@ -29,7 +29,7 @@ def auc(x, y, reorder=False):
         y (Union[np.array, list]): From the ROC curve(tpr), np.array with true positive rates. If multiclass,
                                    this is a list of such np.array, one for each class. The shape :math:`(N)`.
         reorder (bool): If False, x must rise or fall monotonously. If True, x will be sorted in ascending order.
-                           Default: False.
+                           Default: ``False`` .
 
     Returns:
         float, the area under the ROC-curve.

mindspore/train/metrics/bleu_score.py

@@ -28,8 +28,8 @@ class BleuScore(Metric):
     the quality of text translated by machine.
 
     Args:
-        n_gram (int): The n_gram value ranges from 1 to 4. Default: 4.
-        smooth (bool): Whether or not to apply smoothing. Default: False.
+        n_gram (int): The n_gram value ranges from 1 to 4. Default: ``4`` .
+        smooth (bool): Whether or not to apply smoothing. Default: ``False`` .
 
     Raises:
         ValueError: If the value range of n_gram is not from 1 to 4.

mindspore/train/metrics/confusion_matrix.py

@@ -31,14 +31,14 @@ class ConfusionMatrix(Metric):
 
     Args:
         num_classes (int): Number of classes in the dataset.
-        normalize (str): Normalization mode for confusion matrix. Default: "no_norm". Choose from:
+        normalize (str): Normalization mode for confusion matrix. Default: ``"no_norm"`` . Choose from:
 
-            - **'no_norm'** (None) - No Normalization is used. Default: None.
-            - **'target'** (str) - Normalization based on target value.
-            - **'prediction'** (str) - Normalization based on predicted value.
-            - **'all'** (str) - Normalization over the whole matrix.
+            - **"no_norm"** (None) - No Normalization is used. Default: ``None``.
+            - **"target"** (str) - Normalization based on target value.
+            - **"prediction"** (str) - Normalization based on predicted value.
+            - **"all"** (str) - Normalization over the whole matrix.
 
-        threshold (float): The threshold used to compare with the input tensor. Default: 0.5.
+        threshold (float): The threshold used to compare with the input tensor. Default: ``0.5`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -156,18 +156,18 @@ class ConfusionMatrixMetric(Metric):
 
     Args:
         skip_channel (bool): Whether to skip the measurement calculation on the first channel of the predicted output.
-                             Default: True.
-        metric_name (str): Names of supported metrics , users can also set the industry common aliases for them.  Choose
+                             Default: ``True`` .
+        metric_name (str): Names of supported metrics , users can also set the industry common aliases for them. Choose
                            from: ["sensitivity", "specificity", "precision", "negative predictive value", "miss rate",
                            "fall out", "false discovery rate", "false omission rate", "prevalence threshold",
                            "threat score", "accuracy", "balanced accuracy", "f1 score",
                            "matthews correlation coefficient", "fowlkes mallows index", "informedness", "markedness"].
-                           Default: "sensitivity".
+                           Default: ``"sensitivity"`` .
         calculation_method (bool): If true, the measurement for each sample will be calculated first.
                            If not, the confusion matrix of all samples will be accumulated first.
-                           As for classification task, 'calculation_method' should be False. Default: False.
+                           As for classification task, 'calculation_method' should be False. Default: ``False`` .
         decrease (str): The reduction method on data batch. `decrease` takes effect only when calculation_method
-                        is True. Default: "mean". Choose from:
+                        is True. Default: ``"mean"`` . Choose from:
                         ["none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"].
 
     Supported Platforms:
@@ -277,14 +277,14 @@ class _ConfusionMatrix:
 
     Args:
         skip_channel (bool): Whether to skip the measurement calculation on the first channel of the predicted
-                             output. Default: True.
+                             output. Default: ``True``.
         metric_name (str): The names of indicators are in the following range. Of course, you can also set the industry
                            common aliases for these indicators.
         calculation_method (bool): If true, the measurement for each sample will be calculated first. If not, the
                                    confusion matrix for each image (the output of function '_get_confusion_matrix')
                                    will be returned. In this way, users should achieve the confusion matrixes for all
                                    images during an epochand then use '_compute_confusion_matrix_metric' to calculate
-                                   the metric. Default: False.
+                                   the metric. Default: ``False``.
         decrease (Union[DecreaseMetric, str]): ["none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel",
                                                 "sum_channel"]
                                                Define the mode to reduce the calculation result of one batch of data.
@@ -356,7 +356,7 @@ def _get_confusion_matrix(y_pred, y, skip_channel=True):
         y (ndarray): ground truth to compute the metric. It must be one-hot format and first dim is batch.
                     The values should be binarized.
         skip_channel (bool): whether to skip metric computation on the first channel of the predicted output.
-                            Default: True.
+                            Default: ``True``.
 
     Raises:
         ValueError: when `y_pred` and `y` have different shapes.

mindspore/train/metrics/cosine_similarity.py

@@ -26,9 +26,9 @@ class CosineSimilarity(Metric):
     Computes representation similarity.
 
     Args:
-        similarity (str): 'dot' or 'cosine'. Default: 'cosine'.
-        reduction (str): 'none', 'sum', 'mean' (all along dim -1). Default: 'none'.
-        zero_diagonal (bool): If True,  diagonals of results will be set to zero. Default: True.
+        similarity (str): 'dot' or 'cosine'. Default: ``'cosine'`` .
+        reduction (str): ``'none'``, 'sum', ``'mean'`` (all along dim -1). Default: ``'none'`` .
+        zero_diagonal (bool): If True,  diagonals of results will be set to zero. Default: ``True`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/train/metrics/dice.py

@@ -33,7 +33,7 @@ class Dice(Metric):
 
     Args:
         smooth (float): A term added to the denominator to improve numerical stability. Should be greater than 0.
-                        Default: 1e-5.
+                        Default: ``1e-5`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/train/metrics/fbeta.py

@@ -120,7 +120,7 @@ class Fbeta(Metric):
         Computes the fbeta.
 
         Args:
-            average (bool): Whether to calculate the average fbeta. Default: False.
+            average (bool): Whether to calculate the average fbeta. Default: ``False``.
 
         Returns:
             numpy.ndarray or numpy.float64, the computed result.

mindspore/train/metrics/hausdorff_distance.py

@@ -78,21 +78,22 @@ 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 :math:`h(A,B)` is the maximum distance of a set A to the nearest point in the set B,
+    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)`. :math:`H(A, B)` is the two-way Hausdorff distance.
 
     Args:
-        distance_metric (string): Three distance measurement methods are supported: "euclidean", "chessboard" or
-                           "taxicab". Default: "euclidean".
+        distance_metric (string): Three distance measurement methods are supported:
+                    ``"euclidean"`` (Euclidean Distance) ,  ``"chessboard"`` (Chessboard Distance, Chebyshev Distance)
+                    or  ``"taxicab"`` (Taxicab Distance, Manhattan Distance). Default: ``"euclidean"`` .
         percentile (float): Floating point numbers between 0 and 100. Specify the percentile parameter to get the
-                            percentile of the Hausdorff distance. Default: None.
+                            percentile of the Hausdorff distance. Default: ``None`` .
         directed (bool): If True, it only calculates h(y_pred, y) distance, otherwise, max(h(y_pred, y), h(y, y_pred))
-                    will be returned. Default: False.
+                    will be returned. Default: ``False`` .
         crop (bool): Crop input images and only keep the foregrounds. In order to maintain two inputs' shapes,
                      here the bounding box is achieved by (y_pred | y) which represents the union set of two images.
-                     Default: True.
+                     Default: ``True`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -111,6 +112,7 @@ class HausdorffDistance(Metric):
         >>> print(mean_average_distance)
         1.4142135623730951
     """
+
     def __init__(self, distance_metric="euclidean", percentile=None, directed=False, crop=True):
         super(HausdorffDistance, self).__init__()
         string_list = ["euclidean", "chessboard", "taxicab"]

mindspore/train/metrics/mean_surface_distance.py

@@ -49,12 +49,13 @@ class MeanSurfaceDistance(Metric):
         \left | S(B) \right |}
 
     Args:
-        distance_metric (string): Three measurement methods are supported: "euclidean", "chessboard" or "taxicab".
-                          Default: "euclidean".
+        distance_metric (string): Three measurement methods are supported: ``"euclidean"`` (Euclidean Distance) ,
+                                ``"chessboard"`` (Chessboard Distance, Chebyshev Distance) or
+                                ``"taxicab"`` (Taxicab Distance, Manhattan Distance) Default: ``"euclidean"`` .
         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)`,
+                          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``

mindspore/train/metrics/metric.py

@@ -40,7 +40,7 @@ def rearrange_inputs(func):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore.nn import rearrange_inputs
+        >>> from mindspore.train import rearrange_inputs
         >>> class RearrangeInputsExample:
         ...     def __init__(self):
         ...         self._indexes = None
@@ -83,6 +83,42 @@ class Metric(metaclass=ABCMeta):
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>>
+        >>> class MyMAE(ms.train.Metric):
+        ...     def __init__(self):
+        ...         super(MyMAE, self).__init__()
+        ...         self.clear()
+        ...
+        ...     def clear(self):
+        ...         self._abs_error_sum = 0
+        ...         self._samples_num = 0
+        ...
+        ...     def update(self, *inputs):
+        ...         y_pred = inputs[0].asnumpy()
+        ...         y = inputs[1].asnumpy()
+        ...         abs_error_sum = np.abs(y - y_pred)
+        ...         self._abs_error_sum += abs_error_sum.sum()
+        ...         self._samples_num += y.shape[0]
+        ...
+        ...     def eval(self):
+        ...         return self._abs_error_sum / self._samples_num
+        >>>
+        >>> x = ms.Tensor(np.array([[0.1, 0.2, 0.6, 0.9], [0.1, 0.2, 0.6, 0.9]]), ms.float32)
+        >>> y = ms.Tensor(np.array([[0.1, 0.1, 0.1, 0.1], [0.1, 0.1, 0.1, 0.1]]), ms.float32)
+        >>> y2 = ms.Tensor(np.array([[0.1, 0.25, 0.7, 0.9], [0.1, 0.25, 0.7, 0.9]]), ms.float32)
+        >>> metric = MyMAE().set_indexes([0, 2])
+        >>> metric.clear()
+        >>> # indexes is [0, 2], using x as logits, y2 as label.
+        >>> metric.update(x, y, y2)
+        >>> accuracy = metric.eval()
+        >>> print(accuracy)
+        1.399999976158142
+        >>> print(metric.indexes)
+        [0, 2]
     """
     def __init__(self):
         self._indexes = None
@@ -133,22 +169,6 @@ class Metric(metaclass=ABCMeta):
 
         Raises:
             ValueError: If the type of input 'indexes'  is not a list or its elements are not all int.
-
-        Examples:
-            >>> import numpy as np
-            >>> 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 = Accuracy('classification').set_indexes([0, 2])
-            >>> metric.clear()
-            >>> # indexes is [0, 2], using x as logits, y2 as label.
-            >>> metric.update(x, y, y2)
-            >>> accuracy = metric.eval()
-            >>> print(accuracy)
-            0.3333333333333333
         """
         if not isinstance(indexes, list) or not all(isinstance(i, int) for i in indexes):
             raise ValueError("For 'set_indexes', the argument 'indexes' must be a list and all its elements must "
@@ -177,6 +197,10 @@ class Metric(metaclass=ABCMeta):
 
         Note:
             All subclasses must override this interface.
+
+        Tutorial Examples:
+            - `Evaluation Metrics - Customized Metrics
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define clear function to use this base class')
 
@@ -187,6 +211,10 @@ class Metric(metaclass=ABCMeta):
 
         Note:
             All subclasses must override this interface.
+
+        Tutorial Examples:
+            - `Evaluation Metrics - Customized Metrics
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define eval function to use this base class')
 
@@ -200,6 +228,10 @@ class Metric(metaclass=ABCMeta):
 
         Args:
             inputs: A variable-length input argument list, usually are the logits and the corresponding labels.
+
+        Tutorial Examples:
+            - `Evaluation Metrics - Customized Metrics
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define update function to use this base class')
 

mindspore/train/metrics/occlusion_sensitivity.py

@@ -40,14 +40,14 @@ class OcclusionSensitivity(Metric):
     that the occluded area is more important in the decision-making process.
 
     Args:
-        pad_val (float): The padding value of the occluded part in an image. Default: 0.0.
-        margin (Union[int, Sequence]): Create a cuboid / cube around the voxel you want to occlude. Default: 2.
-        n_batch (int): number of images in a batch. Default: 128.
+        pad_val (float): The padding value of the occluded part in an image. Default: ``0.0`` .
+        margin (Union[int, Sequence]): Create a cuboid / cube around the voxel you want to occlude. Default: ``2`` .
+        n_batch (int): number of images in a batch. Default: ``128`` .
         b_box (Sequence): Bounding box on which to perform the analysis. The output image will also match in size.
                           There should be a minimum and maximum for all dimensions except batch:
                           ``[min1, max1, min2, max2,...]``. If no bounding box is supplied, this will be the same size
                           as the input image. If a bounding box is used, the output image will be cropped to this size.
-                          Default: None.
+                          Default: ``None`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/train/metrics/perplexity.py

@@ -34,7 +34,7 @@ class Perplexity(Metric):
 
     Args:
         ignore_label (Union[int, None]): Index of an invalid label to be ignored when counting. If set to `None`,
-                it will include all entries. Default: None.
+                it will include all entries. Default: ``None`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/train/metrics/precision.py

@@ -36,7 +36,7 @@ class Precision(EvaluationBase):
         In the multi-label cases, the elements of :math:`y` and :math:`y_{pred}` must be 0 or 1.
 
     Args:
-        eval_type (str): 'classification' or 'multilabel' are supported. Default: 'classification'.
+        eval_type (str): ``'classification'`` or ``'multilabel'`` are supported. Default: ``'classification'`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -140,7 +140,7 @@ class Precision(EvaluationBase):
         Computes the precision.
 
         Args:
-            average (bool): Specify whether calculate the average precision. Default: False.
+            average (bool): Specify whether calculate the average precision. Default: ``False`` .
 
         Returns:
             numpy.float64, the computed result.

mindspore/train/metrics/recall.py

@@ -36,8 +36,7 @@ class Recall(EvaluationBase):
         In the multi-label cases, the elements of :math:`y` and :math:`y_{pred}` must be 0 or 1.
 
     Args:
-        eval_type (str): 'classification' or 'multilabel' are supported. Default: 'classification'.
-            Default: 'classification'.
+        eval_type (str): ``'classification'`` or ``'multilabel'`` are supported. Default: ``'classification'`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -140,7 +139,7 @@ class Recall(EvaluationBase):
         Computes the recall.
 
         Args:
-            average (bool): Specify whether calculate the average recall. Default: False.
+            average (bool): Specify whether calculate the average recall. Default: ``False`` .
 
         Returns:
             numpy.float64, the computed result.

mindspore/train/metrics/roc.py

@@ -28,10 +28,10 @@ class ROC(Metric):
 
     Args:
         class_num (int): The number of classes. It is not necessary to provide this argument under the binary
-                            classification scenario. Default: None.
+                            classification scenario. Default: ``None`` .
         pos_label (int): Determine the integer of positive class. For binary problems, it is translated to 1 by default.
                             For multiclass problems, this argument should not be set, as it will
-                            iteratively changed in the range [0,num_classes-1]. Default: None.
+                            iteratively changed in the range [0, num_classes-1]. Default: ``None`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -151,10 +151,10 @@ class ROC(Metric):
                 and :math:`C` is the number of categories.
             y (Union[Tensor, list, np.ndarray]): values of integers.
             class_num (int): Integer with the number of classes. For the problem of binary classification, it is not
-                necessary to provide this argument. Default: None.
-            pos_label (int): Determine the integer of positive class. Default: None. For binary problems, it is
+                necessary to provide this argument. Default: ``None``.
+            pos_label (int): Determine the integer of positive class. Default: ``None``. For binary problems, it is
                 translated to 1. For multiclass problems, this argument should not be set, as it is iteratively changed
-                in the range [0,num_classes-1]. Default: None.
+                in the range [0,num_classes-1]. Default: ``None``.
             sample_weights (Union[None, np.ndarray]): If sample_weights is None, the weight value is 1.
                 If sample_weights is ndarray, the weight value is the ndarray value.
         """
@@ -172,8 +172,8 @@ class ROC(Metric):
             - **fpr** (np.array) - False positive rate. In binary classification case, a fpr numpy array under different
               thresholds will be returned, otherwise in multiclass case, a list of
               fpr numpy arrays will be returned and each element represents one category.
-            - **tpr** (np.array) - True positive rates. n binary classification case, a tps numpy array under different
-              thresholds will be returned, otherwise in multiclass case, a list of tps numpy arrays
+            - **tpr** (np.array) - True positive rates. n binary classification case, a tpr numpy array under different
+              thresholds will be returned, otherwise in multiclass case, a list of tpr numpy arrays
               will be returned and each element represents one category.
             - **thresholds** (np.array) - Thresholds used for computing fpr and tpr.
 

mindspore/train/metrics/root_mean_square_surface_distance.py

@@ -49,11 +49,12 @@ class RootMeanSquareDistance(Metric):
 
     Args:
         distance_metric (string): Three measurement methods are supported:
-                "euclidean", "chessboard" or "taxicab". Default: "euclidean".
+                ``"euclidean"`` (Euclidean Distance) ,  ``"chessboard"`` (Chessboard Distance, Chebyshev Distance)
+                or  ``"taxicab"`` (Taxicab Distance, Manhattan Distance). 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,
                 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.
+                :math:`RmsSurDis(y\_pred \leftrightarrow y)` will be returned. Default: ``False`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -175,7 +176,7 @@ class RootMeanSquareDistance(Metric):
         if residual_mean_square_distance.shape == (0,):
             return np.inf
 
-        rms_surface_distance = (residual_mean_square_distance**2).mean()
+        rms_surface_distance = (residual_mean_square_distance ** 2).mean()
 
         if not self.symmetric:
             return rms_surface_distance
@@ -184,7 +185,7 @@ class RootMeanSquareDistance(Metric):
         if contrary_residual_mean_square_distance.shape == (0,):
             return np.inf
 
-        contrary_rms_surface_distance = (contrary_residual_mean_square_distance**2).mean()
+        contrary_rms_surface_distance = (contrary_residual_mean_square_distance ** 2).mean()
 
         rms_distance = np.sqrt(np.mean((rms_surface_distance, contrary_rms_surface_distance)))
         return rms_distance

mindspore/train/metrics/topk.py

@@ -114,13 +114,14 @@ class TopKCategoricalAccuracy(Metric):
 class Top1CategoricalAccuracy(TopKCategoricalAccuracy):
     """
     Calculates the top-1 categorical accuracy. This class is a specialized class for TopKCategoricalAccuracy.
-    Refer to :class:`TopKCategoricalAccuracy` for more details.
+    Refer to :class:`mindspore.train.TopKCategoricalAccuracy` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor
         >>> from mindspore.train import Top1CategoricalAccuracy
         >>>
@@ -141,19 +142,21 @@ class Top1CategoricalAccuracy(TopKCategoricalAccuracy):
 class Top5CategoricalAccuracy(TopKCategoricalAccuracy):
     """
     Calculates the top-5 categorical accuracy. This class is a specialized class for TopKCategoricalAccuracy.
-    Refer to :class:`TopKCategoricalAccuracy` for more details.
+    Refer to :class:`mindspore.train.TopKCategoricalAccuracy` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn, Tensor
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import Top5CategoricalAccuracy
         >>>
         >>> 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.Top5CategoricalAccuracy()
+        >>> topk = Top5CategoricalAccuracy()
         >>> topk.clear()
         >>> topk.update(x, y)
         >>> output = topk.eval()