主页 / coding / 问题 / 78893734
Accepted
Mikhail Genkin
Asked: 2024-08-21 01:27:36 +0800 CST

sklearn.metrics.accuracy_score 非常慢

  • 772

我需要测量我的模型对二元分类（0 和 1 输出）的预测准确度。我正在用许多不同的阈值测试我的模型，我的测试数据集非常大（5000 万到 1 亿个示例），所以我需要一种快速的方法来计算模型的准确度。我正在优化我的代码，并注意到计算准确度的标准函数比直接计算慢约 50 倍。最小示例：

from sklearn.metrics import accuracy_score
import numpy as np
import timeit
a=np.random.randint(0,2,1000000)
b=np.random.randint(0,2,1000000)
%timeit accuracy_score(a,b)
# 46.7 ms ± 390 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit (a==b).sum()/a.size
# 713 µs ± 7.22 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

我是不是漏掉了什么？看起来 accuracy_score 是衡量准确度的标准方法。为什么它这么慢？底层没有 C 优化？

python

2 个回答

  1. accuracy_score 从源代码中可以看出，它比比较代码片段执行的工作多得多。它也不是直接用 C 编写的，只是通过 NumPy 间接利用了基于 C 的优化。

    您未考虑的操作包括：

    • 输入类型验证
    • 数组长度验证
    • 支持多种数组格式（NumPy、Python 列表等）
    • 支持多标签分类
    (a==b).sum()/a.size

    您的比较代码（上文）应该总是更快，因为它不太安全，也不太灵活。有时我们会做出这样的权衡。

    • 1
  2. Best Answer

    出现这种情况的原因有两个。部分原因是accuracy_score()需要进行更多验证以确保其计算出的答案有意义。然而，另一部分原因是部分验证似乎没有得到尽可能有效的实施。

    为了解释我为什么这么想，我将展示一些分析数据。我使用line profiler和以下 Jupyter 命令获取了这些数据：

    from sklearn.metrics import accuracy_score
from sklearn.metrics._classification import _check_targets
from sklearn.utils.multiclass import type_of_target
%load_ext line_profiler
%lprun -f accuracy_score.__wrapped__ -f _check_targets -f type_of_target [accuracy_score(a,b) for i in range(10)]

    关于此的一些说明：

    • 该-f选项控制要跟踪哪些函数。我之所以跟踪，accuracy_score.__wrapped__是因为accuracy_score()有一个装饰器。其他函数是accuracy_score()调用的函数；我们将深入讨论这一点。
    • [accuracy_score(a,b) for i in range(10)]是我们正在运行的代码。

    这是的结果accuracy_score：

    Timer unit: 1e-09 s

Total time: 0.813048 s
File: /home/jupyter-njodell/.local/lib/python3.10/site-packages/sklearn/metrics/_classification.py
Function: accuracy_score at line 137

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   146                                           def accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None):
   ...
   211                                           
   212                                               # Compute accuracy for each possible representation
   213        10  791633889.0    8e+07     97.4      y_type, y_true, y_pred = _check_targets(y_true, y_pred)
   214        10     856305.0  85630.5      0.1      check_consistent_length(y_true, y_pred, sample_weight)
   215        10      11260.0   1126.0      0.0      if y_type.startswith("multilabel"):
   216                                                   differing_labels = count_nonzero(y_true - y_pred, axis=1)
   217                                                   score = differing_labels == 0
   218                                               else:
   219        10   14279630.0    1e+06      1.8          score = y_true == y_pred
   220                                           
   221        10    6267160.0 626716.0      0.8      return _weighted_sum(score, sample_weight, normalize)

    请注意，其 97% 的时间都花在了 内部_check_targets()。让我们跟踪一下该函数：

    Timer unit: 1e-09 s

Total time: 0.791422 s
File: /home/jupyter-njodell/.local/lib/python3.10/site-packages/sklearn/metrics/_classification.py
Function: _check_targets at line 58

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    58                                           def _check_targets(y_true, y_pred):
    59                                               """Check that y_true and y_pred belong to the same classification task.
    60                                           
    61                                               This converts multiclass or binary types to a common shape, and raises a
    62                                               ValueError for a mix of multilabel and multiclass targets, a mix of
    63                                               multilabel formats, for the presence of continuous-valued or multioutput
    64                                               targets, or for targets of different lengths.
    65                                           
    66                                               Column vectors are squeezed to 1d, while multilabel formats are returned
    67                                               as CSR sparse label indicators.
    ...
    84                                               """
    85        10     586514.0  58651.4      0.1      check_consistent_length(y_true, y_pred)
    86        10  192463822.0    2e+07     24.3      type_true = type_of_target(y_true, input_name="y_true")
    87        10  172566835.0    2e+07     21.8      type_pred = type_of_target(y_pred, input_name="y_pred")
    88                                           
    89        10      11888.0   1188.8      0.0      y_type = {type_true, type_pred}
    90        10      15326.0   1532.6      0.0      if y_type == {"binary", "multiclass"}:
    91                                                   y_type = {"multiclass"}
    92                                           
    93        10      11207.0   1120.7      0.0      if len(y_type) > 1:
    94                                                   raise ValueError(
    95                                                       "Classification metrics can't handle a mix of {0} and {1} targets".format(
    96                                                           type_true, type_pred
    97                                                       )
    98                                                   )
    99                                           
   100                                               # We can't have more than one value on y_type => The set is no more needed
   101        10      18352.0   1835.2      0.0      y_type = y_type.pop()
   102                                           
   103                                               # No metrics support "multiclass-multioutput" format
   104        10       7047.0    704.7      0.0      if y_type not in ["binary", "multiclass", "multilabel-indicator"]:
   105                                                   raise ValueError("{0} is not supported".format(y_type))
   106                                           
   107        10       4171.0    417.1      0.0      if y_type in ["binary", "multiclass"]:
   108        10      91096.0   9109.6      0.0          xp, _ = get_namespace(y_true, y_pred)
   109        10     930291.0  93029.1      0.1          y_true = column_or_1d(y_true)
   110        10     498877.0  49887.7      0.1          y_pred = column_or_1d(y_pred)
   111        10       4883.0    488.3      0.0          if y_type == "binary":
   112        10       2488.0    248.8      0.0              try:
   113        10  424147403.0    4e+07     53.6                  unique_values = _union1d(y_true, y_pred, xp)
   114                                                       except TypeError as e:
   115                                                           # We expect y_true and y_pred to be of the same data type.
   116                                                           # If `y_true` was provided to the classifier as strings,
   117                                                           # `y_pred` given by the classifier will also be encoded with
   118                                                           # strings. So we raise a meaningful error
   119                                                           raise TypeError(
   120                                                               "Labels in y_true and y_pred should be of the same type. "
   121                                                               f"Got y_true={xp.unique(y_true)} and "
   122                                                               f"y_pred={xp.unique(y_pred)}. Make sure that the "
   123                                                               "predictions provided by the classifier coincides with "
   124                                                               "the true labels."
   125                                                           ) from e
   126        10      24858.0   2485.8      0.0              if unique_values.shape[0] > 2:
   127                                                           y_type = "multiclass"
   128                                           
   129        10      31701.0   3170.1      0.0      if y_type.startswith("multilabel"):
   130                                                   y_true = csr_matrix(y_true)
   131                                                   y_pred = csr_matrix(y_pred)
   132                                                   y_type = "multilabel-indicator"
   133                                           
   134        10       4790.0    479.0      0.0      return y_type, y_true, y_pred

    此函数中时间有两个主要用途：

    • type_of_target()针对 y_true 和 y_pred 都调用。这占了所用时间的 24.3% + 21.8% = 46.1%。
    • _union1d()被调用来获取 y_true 和 y_pred 中不同类别的数量。这占了所用时间的 53.6%。

    这两个功能的作用是什么？

    在 中type_of_target()，大部分时间都花在这一行上：

    Total time: 0.364502 s
File: /home/jupyter-njodell/.local/lib/python3.10/site-packages/sklearn/utils/multiclass.py
Function: type_of_target at line 228

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   228                                           def type_of_target(y, input_name=""):
   ...
   [... snip many lines of code ...]
   ...
   395        20  361088394.0    2e+07     99.1      if xp.unique_values(y).shape[0] > 2 or (y.ndim == 2 and len(first_row) > 1):
   396                                                   # [1, 2, 3] or [[1., 2., 3]] or [[1, 2]]
   397                                                   return "multiclass" + suffix

    _union1d取两个 NumPy 数组的并集。它调用np.union1d，其实现如下：

    def union1d(ar1, ar2):
    return unique(np.concatenate((ar1, ar2), axis=None))

    总而言之，对于二元分类，accuracy_score96％的计算时间用于计算以下三件事之一：

    • np.unique(y_true)
    • np.unique(y_pred)
    • np.unique(np.concatenate([y_true, y_pred]))

    然而，第三件事可以通过前两件事推算出来。

    具体来说，这三个操作可以重写为：

    y_true_unique = np.unique(y_true)
y_pred_unique = np.unique(y_pred)
combined_unqiue = np.unique(np.concatenate([y_true_unique, y_pred_unique]))

    在不同类别的数量远小于训练示例的数量的情况下（我认为这适用于大多数机器学习问题），第二种形式将快约 50%，因为np.concatenate([y_true_unique, y_pred_unique])会比小得多np.concatenate([y_true, y_pred])。

    实际上进行这种优化并提交 scikit-learn PR 留给读者作为练习。:)

    • 1

相关问题