mindspore 2.4.0__cp310-cp310-macosx_11_0_arm64.whl

mindspore/train/metrics/perplexity.py

@@ -0,0 +1,133 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Perplexity"""
+from __future__ import absolute_import
+
+import math
+import numpy as np
+
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs
+
+
+class Perplexity(Metric):
+    r"""
+    Computes perplexity. Perplexity is a measurement about how well a probability distribution or a model predicts a
+    sample. A low perplexity indicates the model can predict the sample well. The function is shown as follows:
+
+    .. math::
+        PP(W)=P(w_{1}w_{2}...w_{N})^{-\frac{1}{N}}=\sqrt[N]{\frac{1}{P(w_{1}w_{2}...w_{N})}}
+
+    Where :math:`w` represents words in corpus. The root sign is the reciprocal of the probability of a sentence,
+    and the better the sentence (with a higher probability), the lower the perplexity.
+
+    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`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> 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 = Perplexity(ignore_label=None)
+        >>> metric.clear()
+        >>> metric.update(x, y)
+        >>> perplexity = metric.eval()
+        >>> print(perplexity)
+        2.231443166940565
+    """
+
+    def __init__(self, ignore_label=None):
+        super(Perplexity, self).__init__()
+
+        if ignore_label is None:
+            self.ignore_label = ignore_label
+        else:
+            self.ignore_label = validator.check_value_type("ignore_label", ignore_label, [int])
+        self.clear()
+
+    def clear(self):
+        """Clears the internal evaluation result."""
+        self._sum_metric = 0.0
+        self._num_inst = 0
+
+    @rearrange_inputs
+    def update(self, *inputs):
+        """
+        Updates the internal evaluation result `preds` and `labels`.
+
+        Args:
+            inputs: Input `preds` and `labels`. `preds` and `labels` are a `Tensor`, list or numpy.ndarray.
+                    `preds` is the predicted values, `labels` is the labels of the data.
+                    The shape of `preds` and `labels` are both :math:`(N, C)`.
+
+        Raises:
+            ValueError: If the number of the inputs is not 2.
+            RuntimeError: If preds and labels have different lengths.
+            RuntimeError: If label shape is not equal to pred shape.
+        """
+        if len(inputs) != 2:
+            raise ValueError("For 'Perplexity.update', it needs 2 inputs (predicted value, label), but got {}."
+                             .format(len(inputs)))
+
+        preds = [self._convert_data(inputs[0])]
+        labels = [self._convert_data(inputs[1])]
+
+        if len(preds) != len(labels):
+            raise RuntimeError("For 'Perplexity.update', predicted value (input[0]) and label (input[1]) should have "
+                               "the same length, but got predicted value length {}, label length {}."
+                               .format(len(preds), len(labels)))
+
+        loss = 0.
+        num = 0
+        for label, pred in zip(labels, preds):
+            if label.size != pred.size / pred.shape[-1]:
+                raise RuntimeError("For 'Perplexity.update', predicted value (input[0]) and label (input[1]) should "
+                                   "have the same shape, but got predicted value shape {}, label shape {}."
+                                   .format(pred.shape, label.shape))
+            label = label.reshape((label.size,))
+            label_expand = label.astype(int)
+            label_expand = np.expand_dims(label_expand, axis=1)
+            first_indices = np.arange(label_expand.shape[0])[:, None]
+            pred = np.squeeze(pred[first_indices, label_expand])
+            if self.ignore_label is not None:
+                ignore = (label == self.ignore_label).astype(pred.dtype)
+                num -= np.sum(ignore)
+                pred = pred * (1 - ignore) + ignore
+            loss -= np.sum(np.log(np.maximum(1e-10, pred)))
+            num += pred.size
+        self._sum_metric += loss
+        self._num_inst += num
+
+    def eval(self):
+        r"""
+        Returns the current evaluation result.
+
+        Returns:
+            numpy.float64. The computed result.
+
+        Raises:
+            RuntimeError: If the sample size is 0.
+        """
+        if self._num_inst == 0:
+            raise RuntimeError("The 'Perplexity' can not be calculated, because the number of samples is 0, please "
+                               "check whether has called update method before calling eval method.")
+
+        return math.exp(self._sum_metric / self._num_inst)

mindspore/train/metrics/precision.py

@@ -0,0 +1,160 @@
+# Copyright 2020-2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Precision."""
+from __future__ import absolute_import
+
+import sys
+import numpy as np
+
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
+
+
+class Precision(EvaluationBase):
+    r"""
+    Calculates precision for classification and multilabel data.
+
+    The precision function creates two local variables, :math:`\text{true_positive}` and
+    :math:`\text{false_positive}`, which are used to compute the precision. The calculation formula is:
+
+    .. 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'`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> 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 = Precision('classification')
+        >>> metric.clear()
+        >>> metric.update(x, y)
+        >>> precision = metric.eval()
+        >>> print(precision)
+        [0.5 1. ]
+
+    """
+    def __init__(self, eval_type='classification'):
+        super(Precision, self).__init__(eval_type)
+        self.eps = sys.float_info.min
+        self.clear()
+
+    def clear(self):
+        """Clears the internal evaluation result."""
+        self._class_num = 0
+        if self._type == "multilabel":
+            self._true_positives = np.empty(0)
+            self._positives = np.empty(0)
+            self._true_positives_average = 0
+            self._positives_average = 0
+        else:
+            self._true_positives = 0
+            self._positives = 0
+
+    @rearrange_inputs
+    def update(self, *inputs):
+        """
+        Updates the internal evaluation result with `y_pred` and `y`.
+
+        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
+                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)`.
+
+        Raises:
+            ValueError: If the number of inputs is not 2.
+        """
+        if len(inputs) != 2:
+            raise ValueError("For 'Precision.update', it needs 2 inputs (predicted value, true value), "
+                             "but got {}.".format(len(inputs)))
+        y_pred = self._convert_data(inputs[0])
+        y = self._convert_data(inputs[1])
+        if self._type == 'classification' and y_pred.ndim == y.ndim and _check_onehot_data(y):
+            y = y.argmax(axis=1)
+        self._check_shape(y_pred, y)
+        self._check_value(y_pred, y)
+
+        if self._class_num == 0:
+            self._class_num = y_pred.shape[1]
+        elif y_pred.shape[1] != self._class_num:
+            raise ValueError("For 'Precision.update', class number not match, last input predicted data contain {} "
+                             "classes, but current predicted data contain {} classes, please check your predicted "
+                             "value(inputs[0])".format(self._class_num, y_pred.shape[1]))
+
+        class_num = self._class_num
+        if self._type == "classification":
+            if y.max() + 1 > class_num:
+                raise ValueError("For 'Precision.update', predicted value (input[0]) should have the same classes "
+                                 "number as true value (input[1]), but got predicted value classes {}, true value "
+                                 "classes {}.".format(class_num, y.max() + 1))
+            y = np.eye(class_num)[y.reshape(-1)]
+            indices = y_pred.argmax(axis=1).reshape(-1)
+            y_pred = np.eye(class_num)[indices]
+        elif self._type == "multilabel":
+            y_pred = y_pred.swapaxes(1, 0).reshape(class_num, -1)
+            y = y.swapaxes(1, 0).reshape(class_num, -1)
+
+        positives = y_pred.sum(axis=0)
+        true_positives = (y * y_pred).sum(axis=0)
+
+        if self._type == "multilabel":
+            self._true_positives_average += np.sum(true_positives / (positives + self.eps))
+            self._positives_average += len(positives)
+            self._true_positives = np.concatenate((self._true_positives, true_positives), axis=0)
+            self._positives = np.concatenate((self._positives, positives), axis=0)
+
+        else:
+            self._true_positives += true_positives
+            self._positives += positives
+
+    def eval(self, average=False):
+        """
+        Computes the precision.
+
+        Args:
+            average (bool): Specify whether calculate the average precision. Default: ``False`` .
+
+        Returns:
+            numpy.float64, the computed result.
+        """
+        if self._class_num == 0:
+            raise RuntimeError("The 'Precision' can not be calculated, because the number of samples is 0, "
+                               "please check whether your inputs (predicted value, true value) are empty, or "
+                               "has called update method before calling eval method.")
+
+        validator.check_value_type("average", average, [bool], self.__class__.__name__)
+        result = self._true_positives / (self._positives + self.eps)
+
+        if average:
+            if self._type == "multilabel":
+                result = self._true_positives_average / (self._positives_average + self.eps)
+            return result.mean()
+        return result

mindspore/train/metrics/recall.py

@@ -0,0 +1,159 @@
+# Copyright 2020-2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Recall."""
+from __future__ import absolute_import
+
+import sys
+import numpy as np
+
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import EvaluationBase, rearrange_inputs, _check_onehot_data
+
+
+class Recall(EvaluationBase):
+    r"""
+    Calculates recall for classification and multilabel data.
+
+    The recall class creates two local variables, :math:`\text{true_positive}` and :math:`\text{false_negative}`,
+    that are used to compute the recall. The calculation formula is:
+
+    .. math::
+        \text{recall} = \frac{\text{true_positive}}{\text{true_positive} + \text{false_negative}}
+
+    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'`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> 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 = Recall('classification')
+        >>> metric.clear()
+        >>> metric.update(x, y)
+        >>> recall = metric.eval()
+        >>> print(recall)
+        [1. 0.5]
+    """
+    def __init__(self, eval_type='classification'):
+        super(Recall, self).__init__(eval_type)
+        self.eps = sys.float_info.min
+        self.clear()
+
+    def clear(self):
+        """Clears the internal evaluation result."""
+        self._class_num = 0
+        if self._type == "multilabel":
+            self._true_positives = np.empty(0)
+            self._actual_positives = np.empty(0)
+            self._true_positives_average = 0
+            self._actual_positives_average = 0
+        else:
+            self._true_positives = 0
+            self._actual_positives = 0
+
+    @rearrange_inputs
+    def update(self, *inputs):
+        """
+        Updates the internal evaluation result with `y_pred` and `y`.
+
+        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)`.
+
+
+        Raises:
+            ValueError: If the number of inputs is not 2.
+        """
+        if len(inputs) != 2:
+            raise ValueError("For 'Recall.update', it needs 2 inputs (predicted value, true value), "
+                             "but got {}.".format(len(inputs)))
+        y_pred = self._convert_data(inputs[0])
+        y = self._convert_data(inputs[1])
+        if self._type == 'classification' and y_pred.ndim == y.ndim and _check_onehot_data(y):
+            y = y.argmax(axis=1)
+        self._check_shape(y_pred, y)
+        self._check_value(y_pred, y)
+
+        if self._class_num == 0:
+            self._class_num = y_pred.shape[1]
+        elif y_pred.shape[1] != self._class_num:
+            raise ValueError("For 'Recall.update', class number not match, last input predicted data contain {} "
+                             "classes, but current predicted data contain {} classes, please check your predicted "
+                             "value(inputs[0]).".format(self._class_num, y_pred.shape[1]))
+
+        class_num = self._class_num
+        if self._type == "classification":
+            if y.max() + 1 > class_num:
+                raise ValueError("For 'Recall.update', predicted value (input[0]) should have the same classes number "
+                                 "as true value (input[1]), but got predicted value classes {}, true value classes {}."
+                                 .format(class_num, y.max() + 1))
+            y = np.eye(class_num)[y.reshape(-1)]
+            indices = y_pred.argmax(axis=1).reshape(-1)
+            y_pred = np.eye(class_num)[indices]
+        elif self._type == "multilabel":
+            y_pred = y_pred.swapaxes(1, 0).reshape(class_num, -1)
+            y = y.swapaxes(1, 0).reshape(class_num, -1)
+
+        actual_positives = y.sum(axis=0)
+        true_positives = (y * y_pred).sum(axis=0)
+
+        if self._type == "multilabel":
+            self._true_positives_average += np.sum(true_positives / (actual_positives + self.eps))
+            self._actual_positives_average += len(actual_positives)
+            self._true_positives = np.concatenate((self._true_positives, true_positives), axis=0)
+            self._actual_positives = np.concatenate((self._actual_positives, actual_positives), axis=0)
+        else:
+            self._true_positives += true_positives
+            self._actual_positives += actual_positives
+
+    def eval(self, average=False):
+        """
+        Computes the recall.
+
+        Args:
+            average (bool): Specify whether calculate the average recall. Default: ``False`` .
+
+        Returns:
+            numpy.float64, the computed result.
+        """
+        if self._class_num == 0:
+            raise RuntimeError("The 'Recall' can not be calculated, because the number of samples is 0, please check "
+                               "whether your inputs (predicted value, true value) are empty, or has called update "
+                               "method before calling eval method.")
+
+        validator.check_value_type("average", average, [bool], self.__class__.__name__)
+        result = self._true_positives / (self._actual_positives + self.eps)
+
+        if average:
+            if self._type == "multilabel":
+                result = self._true_positives_average / (self._actual_positives_average + self.eps)
+            return result.mean()
+        return result

mindspore/train/metrics/roc.py

@@ -0,0 +1,223 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""ROC"""
+from __future__ import absolute_import
+
+import numpy as np
+
+from mindspore import _checkparam as validator
+from mindspore.train.metrics.metric import Metric, rearrange_inputs, _binary_clf_curve
+
+
+class ROC(Metric):
+    """
+    Calculates the ROC curve. It is suitable for solving binary classification and multi classification problems.
+    In the case of multiclass, the values will be calculated based on a one-vs-the-rest approach.
+
+    Args:
+        class_num (int): The number of classes. It is not necessary to provide this argument under the binary
+                            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`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore.train import ROC
+        >>>
+        >>> # 1) binary classification example
+        >>> x = Tensor(np.array([0.28, 0.55, 0.15, 0.05]))
+        >>> y = Tensor(np.array([0, 1, 2, 3]))
+        >>> metric = ROC(pos_label=2)
+        >>> metric.clear()
+        >>> metric.update(x, y)
+        >>> fpr, tpr, thresholds = metric.eval()
+        >>> print(fpr)
+        [0.         0.33333333 0.66666667 0.66666667 1.        ]
+        >>> print(tpr)
+        [0. 0. 0. 1. 1.]
+        >>> print(thresholds)
+        [1.55 0.55 0.28 0.15 0.05]
+        >>>
+        >>> # 2) multiclass classification example
+        >>> 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 = ROC(class_num=4)
+        >>> metric.clear()
+        >>> metric.update(x, y)
+        >>> fpr, tpr, thresholds = metric.eval()
+        >>> print(fpr)
+        [array([0., 0., 0.33333333, 0.66666667, 1.]), array([0., 0.33333333, 0.33333333, 1.]),
+        array([0., 0.33333333, 1.]), array([0., 0., 1.])]
+        >>> print(tpr)
+        [array([0., 1., 1., 1., 1.]), array([0., 0., 1., 1.]), array([0., 1., 1.]), array([0., 1., 1.])]
+        >>> print(thresholds)
+        [array([1.28, 0.28, 0.2, 0.1, 0.05]), array([1.55, 0.55, 0.2, 0.05]), array([1.15, 0.15, 0.05]),
+        array([1.75, 0.75, 0.05])]
+    """
+    def __init__(self, class_num=None, pos_label=None):
+        super().__init__()
+        self.class_num = class_num if class_num is None else validator.check_value_type("class_num", class_num, [int])
+        self.pos_label = pos_label if pos_label is None else validator.check_value_type("pos_label", pos_label, [int])
+        self.clear()
+
+    def clear(self):
+        """Clear the internal evaluation result."""
+        self.y_pred = 0
+        self.y = 0
+        self.sample_weights = None
+        self._is_update = False
+
+    @rearrange_inputs
+    def update(self, *inputs):
+        """
+        Update state with predictions and targets.
+
+        Args:
+            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
+                encoding is used. Shape can also be :math:`(N,)` if category index is used.
+        """
+        if len(inputs) != 2:
+            raise ValueError("For 'ROC.update', it needs 2 inputs (predicted value, true value), but got {}"
+                             .format(len(inputs)))
+        y_pred = self._convert_data(inputs[0])
+        y = self._convert_data(inputs[1])
+
+        y_pred, y, class_num, pos_label = _precision_recall_curve_update(y_pred, y, self.class_num, self.pos_label)
+
+        self.y_pred = y_pred
+        self.y = y
+        self.class_num = class_num
+        self.pos_label = pos_label
+        self._is_update = True
+
+    def _roc_eval(self, y_pred, y, class_num, pos_label, sample_weights=None):
+        """Computes the ROC curve."""
+        if class_num == 1:
+            fps, tps, thresholds = _binary_clf_curve(y_pred, y, sample_weights=sample_weights, pos_label=pos_label)
+            tps = np.squeeze(np.hstack([np.zeros(1, dtype=tps.dtype), tps]))
+            fps = np.squeeze(np.hstack([np.zeros(1, dtype=fps.dtype), fps]))
+            thresholds = np.hstack([thresholds[0][None] + 1, thresholds])
+
+            if fps[-1] <= 0:
+                raise ValueError("For 'ROC.eval', there is no negative samples in true value, "
+                                 "false positive value is meaningless.")
+            fpr = fps / fps[-1]
+
+            if tps[-1] <= 0:
+                raise ValueError("For 'ROC.eval', there is no positive samples in true value, "
+                                 "true positive value is meaningless.")
+            tpr = tps / tps[-1]
+
+            return fpr, tpr, thresholds
+
+        fpr, tpr, thresholds = [], [], []
+        for c in range(class_num):
+            preds_c = y_pred[:, c]
+            res = self._roc(preds_c, y, class_num=1, pos_label=c, sample_weights=sample_weights)
+            fpr.append(res[0])
+            tpr.append(res[1])
+            thresholds.append(res[2])
+
+        return fpr, tpr, thresholds
+
+    def _roc(self, y_pred, y, class_num=None, pos_label=None, sample_weights=None):
+        """
+        Update curve and return the result of the ROC curve.
+
+        Args:
+            y_pred (Union[Tensor, list, np.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 (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
+                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``.
+            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.
+        """
+        y_pred, y, class_num, pos_label = _precision_recall_curve_update(y_pred, y, class_num, pos_label)
+
+        return self._roc_eval(y_pred, y, class_num, pos_label, sample_weights)
+
+    def eval(self):
+        """
+        Computes the ROC curve.
+
+        Returns:
+            A tuple, composed of `fpr`, `tpr`, and `thresholds`.
+
+            - **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 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.
+
+        Raises:
+            RuntimeError: If the update method is not called first, an error will be reported.
+
+        """
+        if self._is_update is False:
+            raise RuntimeError("Please call the 'update' method before calling 'eval' method.")
+
+        y_pred = np.squeeze(self.y_pred)
+        y = np.squeeze(self.y)
+        return self._roc_eval(y_pred, y, self.class_num, self.pos_label)
+
+
+def _precision_recall_curve_update(y_pred, y, class_num, pos_label):
+    """update curve"""
+    if not (len(y_pred.shape) == len(y.shape) or len(y_pred.shape) == len(y.shape) + 1):
+        raise ValueError(f"For 'ROC', predicted value (input[0]) and true value (input[1]) must have same "
+                         f"dimensions, or the dimension of predicted value equal the dimension of true value add "
+                         f"1, but got predicted value ndim: {len(y_pred.shape)}, true value ndim: {len(y.shape)}.")
+
+    # single class evaluation
+    if len(y_pred.shape) == len(y.shape):
+        if class_num is not None and class_num != 1:
+            raise ValueError(f"For 'ROC', when predicted value (input[0]) and true value (input[1]) have the same "
+                             f"shape, the 'class_num' must be 1, but got {class_num}.")
+        class_num = 1
+        if pos_label is None:
+            pos_label = 1
+        y_pred = y_pred.flatten()
+        y = y.flatten()
+
+    # multi class evaluation
+    elif len(y_pred.shape) == len(y.shape) + 1:
+        if pos_label is not None:
+            raise ValueError(f"For 'ROC', when the dimension of predicted value (input[0]) equals the dimension "
+                             f"of true value (input[1]) add 1, the 'pos_label' must be None, "
+                             f"but got {pos_label}.")
+        if class_num != y_pred.shape[1]:
+            raise ValueError("For 'ROC', the 'class_num' must equal the number of classes from predicted value "
+                             "(input[0]), but got 'class_num' {}, the number of classes from predicted value {}."
+                             .format(class_num, y_pred.shape[1]))
+        y_pred = y_pred.transpose(0, 1).reshape(class_num, -1).transpose(0, 1)
+        y = y.flatten()
+
+    return y_pred, y, class_num, pos_label