mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/train/metrics/accuracy.py

@@ -45,11 +45,11 @@ class Accuracy(EvaluationBase):
         >>> 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)
+        >>> y_pred = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
+        >>> y_true = Tensor(np.array([1, 0, 1]), mindspore.float32)
         >>> metric = Accuracy('classification')
         >>> metric.clear()
-        >>> metric.update(x, y)
+        >>> metric.update(y_pred, y_true)
         >>> accuracy = metric.eval()
         >>> print(accuracy)
         0.6666666666666666

mindspore/train/metrics/confusion_matrix.py

@@ -23,15 +23,15 @@ from mindspore.train.metrics.metric import Metric, rearrange_inputs
 
 class ConfusionMatrix(Metric):
     """
-    Computes the confusion matrix, which is commonly used to evaluate the performance of classification models,
+    Computes the Confusion Matrix, which is commonly used to evaluate the performance of classification models,
     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',
+    If you only need Confusion Matrix, use this class. If you want to calculate other metrics, such as 'PPV',
     'TPR', 'TNR', etc., use class :class:`mindspore.train.ConfusionMatrixMetric` .
 
     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"`` : No Normalization is used. Default: ``None``.
             - ``"target"`` : Normalization based on target value.
@@ -78,7 +78,7 @@ class ConfusionMatrix(Metric):
     @rearrange_inputs
     def update(self, *inputs):
         """
-        Update state with y_pred and y.
+        Update state with `y_pred` and `y`.
 
         Args:
             inputs(tuple): Input `y_pred` and `y`. `y_pred` and `y` are a `Tensor`, list or numpy.ndarray.
@@ -88,7 +88,7 @@ class ConfusionMatrix(Metric):
 
         Raises:
             ValueError: If the number of inputs is not 2.
-            ValueError: If the dim of y_pred and y are not equal.
+            ValueError: If the dims of `y_pred` and `y` are not equal.
         """
         if len(inputs) != 2:
             raise ValueError("For 'ConfusionMatrix.update', it needs 2 inputs (predicted value, true value), "
@@ -151,8 +151,8 @@ class ConfusionMatrixMetric(Metric):
     batch, class channel and iteration are collected. All metrics supported by the interface are listed in comments
     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 :class:`mindspore.train.ConfusionMatrix` .
+    - 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 :class:`mindspore.train.ConfusionMatrix` .
 
     Args:
         skip_channel (bool): Whether to skip the measurement calculation on the first channel of the predicted output.
@@ -163,9 +163,9 @@ class ConfusionMatrixMetric(Metric):
                            "threat score", "accuracy", "balanced accuracy", "f1 score",
                            "matthews correlation coefficient", "fowlkes mallows index", "informedness", "markedness"].
                            Default: ``"sensitivity"`` .
-        calculation_method (bool): If true, the measurement for each sample will be calculated first.
+        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:
                         ["none", "mean", "sum", "mean_batch", "sum_batch", "mean_channel", "sum_channel"].

mindspore/train/metrics/error.py

@@ -25,7 +25,7 @@ class MAE(Metric):
     Calculates the mean absolute error(MAE).
 
     Creates a criterion that measures the MAE between each element
-    in the input: :math:`x` and the target: :math:`y`.
+    in the input: :math:`y\_pred` and the target: :math:`y`.
 
     .. math::
         \text{MAE} = \frac{\sum_{i=1}^n \|{y\_pred}_i - y_i\|}{n}
@@ -142,8 +142,8 @@ class MSE(Metric):
         Updates the internal evaluation result :math:`y_{pred}` and :math:`y`.
 
         Args:
-            inputs: Input `y_pred` and `y` for calculating the MSE where the shape of
-                `y_pred` and `y` are both N-D and the shape should be the same.
+            inputs: Input :math:`y_pred` and :math:`y` for calculating the MSE where the shape of
+                :math:`y_pred` and :math:`y` are both N-D and the shape should be the same.
 
         Raises:
             ValueError: If the number of inputs is not 2.

mindspore/train/metrics/hausdorff_distance.py

@@ -84,7 +84,7 @@ class HausdorffDistance(Metric):
     :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:
+        distance_metric (str): 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
@@ -270,9 +270,9 @@ class HausdorffDistance(Metric):
 
         Raises:
             ValueError: If the number of the inputs is not 3.
-            TypeError: If the data type of label_idx is not int or float.
-            ValueError: If the value of label_idx is not in y_pred or y.
-            ValueError: If y_pred and y have different shapes.
+            TypeError: If the data type of `label_idx` is not int or float.
+            ValueError: If the value of `label_idx` is not in `y_pred` or `y`.
+            ValueError: If `y_pred` and `y` have different shapes.
         """
         self._is_update = True
 

mindspore/train/metrics/mean_surface_distance.py

@@ -49,7 +49,7 @@ class MeanSurfaceDistance(Metric):
         \left | S(B) \right |}
 
     Args:
-        distance_metric (string): Three measurement methods are supported: ``"euclidean"`` (Euclidean Distance) ,
+        distance_metric (str): 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.
@@ -125,8 +125,8 @@ class MeanSurfaceDistance(Metric):
         Raises:
             ValueError: If the number of the inputs is not 3.
             TypeError: If the data type of label_idx is not int or float.
-            ValueError: If the value of label_idx is not in y_pred or y.
-            ValueError: If y_pred and y have different shapes.
+            ValueError: If the value of label_idx is not in `y_pred` or `y`.
+            ValueError: If `y_pred` and `y` have different shapes.
         """
         if len(inputs) != 3:
             raise ValueError("For 'MeanSurfaceDistance.update', it needs 3 inputs (predicted value, true value, "

mindspore/train/metrics/metric.py

@@ -197,10 +197,6 @@ class Metric(metaclass=ABCMeta):
 
         Note:
             All subclasses must override this interface.
-
-        Tutorial Examples:
-            - `Evaluation Metrics - Customized Metrics
-              <https://mindspore.cn/docs/en/master/model_train/train_process/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define clear function to use this base class')
 
@@ -211,10 +207,6 @@ class Metric(metaclass=ABCMeta):
 
         Note:
             All subclasses must override this interface.
-
-        Tutorial Examples:
-            - `Evaluation Metrics - Customized Metrics
-              <https://mindspore.cn/docs/en/master/model_train/train_process/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define eval function to use this base class')
 
@@ -228,10 +220,6 @@ 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/docs/en/master/model_train/train_process/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define update function to use this base class')
 

mindspore/train/metrics/occlusion_sensitivity.py

@@ -36,12 +36,14 @@ class OcclusionSensitivity(Metric):
     most important for a network's classification.
 
     Occlusion sensitivity refers to how the predicted probability changes with the change of the occluded
-    part of an image. The higher the value in the output image is, the greater the decline of certainty, indicating
+    part of an image. The higher the value in the output image is, the greater the certainty decline
+    of the category after masking, indicating
     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`` .
+        margin (Union[int, Sequence]): Create a cuboid / cube size of pixel points
+                                       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:

mindspore/train/metrics/precision.py

@@ -32,11 +32,9 @@ class Precision(EvaluationBase):
     .. math::
         \text{precision} = \frac{\text{true_positive}}{\text{true_positive} + \text{false_positive}}
 
-    Note:
-        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. See the update method below
+            for what it does. Default: ``'classification'`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -76,17 +74,20 @@ class Precision(EvaluationBase):
     @rearrange_inputs
     def update(self, *inputs):
         """
-        Updates the internal evaluation result with `y_pred` and `y`.
+        Updates the internal evaluation result with :math:`y_pred` and :math:`y`.
+        In the multi-label cases, the elements of
+        :math:`y` and :math:`y_pred` must be 0 or 1.
 
         Args:
-            inputs: Input `y_pred` and `y`. `y_pred` and `y` are Tensor, list or numpy.ndarray.
-                For 'classification' evaluation type, `y_pred` is in most cases (not strictly) a list
+            inputs: Input :math:`y_pred` and :math:`y`. :math:`y_pred` and :math:`y`
+                are Tensor, list or numpy.ndarray.
+                For 'classification' evaluation type, :math:`y_pred` is in most cases (not strictly) 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. Shape of `y` can be :math:`(N, C)` with values 0 and 1 if one-hot
+                is the number of categories. Shape of :math:`y` can be :math:`(N, C)` with values 0 and 1 if one-hot
                 encoding is used or the shape is :math:`(N,)` with integer values if index of category is used.
-                For 'multilabel' evaluation type, `y_pred` and `y` can only be one-hot encoding with
-                values 0 or 1. Indices with 1 indicate positive category. The shape of `y_pred` and `y`
+                For 'multilabel' evaluation type, :math:`y_pred` and :math:`y` can only be one-hot encoding with
+                values 0 or 1. Indices with 1 indicate positive category. The shape of :math:`y_pred` and :math:`y`
                 are both :math:`(N, C)`.
 
         Raises:

mindspore/train/metrics/recall.py

@@ -36,7 +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'`` .
+        eval_type (str): ``'classification'`` or ``'multilabel'`` is supported. Default: ``'classification'`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -79,15 +79,15 @@ class Recall(EvaluationBase):
 
         Args:
             inputs: Input `y_pred` and `y`. `y_pred` and `y` are a `Tensor`, a list or an array.
-                For 'classification' evaluation type, `y_pred` is in most cases (not strictly) 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. Shape of `y` can be :math:`(N, C)` with values 0 and 1 if one-hot
-                encoding is used or the shape is :math:`(N,)` with integer values if index of category is used.
-                For 'multilabel' evaluation type, `y_pred` and `y` can only be one-hot encoding with
-                values 0 or 1. Indices with 1 indicate positive category. The shape of `y_pred` and `y`
-                are both :math:`(N, C)`.
 
+                - For 'classification' scenario, `y_pred` is in most cases (not strictly) 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. Shape of `y` can be :math:`(N, C)` with values 0 and 1 if one-hot
+                  encoding is used or the shape is :math:`(N,)` with integer values if index of category is used.
+                - For 'multilabel' scenario, `y_pred` and `y` can only be one-hot encoding with
+                  values 0 or 1. Indices with 1 indicate positive category. The shape of `y_pred` and `y`
+                  are both :math:`(N, C)`.
 
         Raises:
             ValueError: If the number of inputs is not 2.

mindspore/train/metrics/root_mean_square_surface_distance.py

@@ -48,11 +48,11 @@ class RootMeanSquareDistance(Metric):
         \right | + \left | S(B) \right |}}
 
     Args:
-        distance_metric (string): Three measurement methods are supported:
+        distance_metric (str): 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 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`` .