我一直在比较 numpy 与 Python 列表理解在将随机数数组相乘时的相对效率。 (Python 3.4/Spyder、Windows 和 Ubuntu)。

正如人们所期望的那样，对于除最小数组之外的所有数组，numpy 的性能迅速优于列表理解，并且随着数组长度的增加，您将获得预期的 S 型曲线性能。但是 S 形曲线远非光滑，这让我很费解。

显然，对于较短的数组长度，存在一定量的量化噪声，但我得到了意想不到的噪声结果，尤其是在 Windows 下。这些数字是各种阵列长度的 100 次运行的平均值，因此应该消除任何 transient 效应(我会这么想)。

Numpy and Python list performance comparison

下图显示了使用 numpy 与列表理解相乘的不同长度数组的比率。

Array Length    Windows     Ubuntu
           1        0.2        0.4
           2        2.0        0.6
           5        1.0        0.5
          10        3.0        1.0
          20        0.3        0.8
          50        3.5        1.9
         100        3.5        1.9
         200       10.0        3.0
         500        4.6        6.0
       1,000       13.6        6.9
       2,000        9.2        8.2
       5,000       14.6       10.4
      10,000       12.1       11.1
      20,000       12.9       11.6
      50,000       13.4       11.4
     100,000       13.4       12.0
     200,000       12.8       12.4
     500,000       13.0       12.3
   1,000,000       13.3       12.4
   2,000,000       13.6       12.0
   5,000,000       13.6       11.9

所以我想我的问题是任何人都可以解释为什么结果，特别是在 Windows 下如此嘈杂。我已经多次运行测试，但结果似乎总是完全一样。

更新。在 Reblochon Masque 的建议下，我禁用了抓取收集。这在一定程度上使 Windows 性能变得平滑，但曲线仍然是凹凸不平的。

Numpy and Python list performance comparison
(Updated to remove garbage collection)

Array Length    Windows     Ubuntu
           1        0.1        0.3
           2        0.6        0.4
           5        0.3        0.4
          10        0.5        0.5
          20        0.6        0.5
          50        0.8        0.7
         100        1.6        1.1
         200        1.3        1.7
         500        3.7        3.2
       1,000        3.9        4.8
       2,000        6.5        6.6
       5,000       11.5        9.2
      10,000       10.8       10.7
      20,000       12.1       11.4
      50,000       13.3       12.4
     100,000       13.5       12.6
     200,000       12.8       12.6
     500,000       12.9       12.3
   1,000,000       13.3       12.3
   2,000,000       13.6       12.0
   5,000,000       13.6       11.8

更新

在@Sid 的建议下，我将其限制在每台机器上的单个内核上运行。曲线稍微平滑一些(尤其是 Linux 曲线)，但仍然存在拐点和一些噪音，尤其是在 Windows 下。

(这实际上是我最初要发布的词形变化，因为它们始终出现在相同的地方。)

Numpy and Python list performance comparison
(Garbage collection disabled and running on 1 CPU)

Array Length    Windows     Ubuntu
           1        0.3        0.3
           2        0.0        0.4
           5        0.5        0.4
          10        0.6        0.5
          20        0.3        0.5
          50        0.9        0.7
         100        1.0        1.1
         200        2.8        1.7
         500        3.7        3.3
       1,000        3.3        4.7
       2,000        6.5        6.7
       5,000       11.0        9.6
      10,000       11.0       11.1
      20,000       12.7       11.8
      50,000       12.9       12.8
     100,000       14.3       13.0
     200,000       12.6       13.1
     500,000       12.6       12.6
   1,000,000       13.0       12.6
   2,000,000       13.4       12.4
   5,000,000       13.6       12.2

最佳答案

垃圾收集器解释了大部分内容。其余的可能是基于您机器上运行的其他程序的波动。 如何关闭大多数东西并运行最低限度并测试它。由于您使用的是日期时间(这是实际耗时)，因此还必须考虑任何处理器上下文切换。

您也可以尝试运行它，同时使用 unix 调用将它附加到处理器，这可能有助于进一步平滑它。在 Ubuntu 上可以这样做:https://askubuntu.com/a/483827

对于 Windows 处理器关联可以这样设置:http://www.addictivetips.com/windows-tips/how-to-set-processor-affinity-to-an-application-in-windows/

关于python - 为什么numpy的效率不成比例，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36428059/