为什么numpy的效率不会扩大

Question

我一直在比较numpy与Python列表推导的相对效率,将随机数的数组相乘.(Python 3.4/Spyder,Windows和Ubuntu).

正如人们所预料的那样,对于除最小阵列之外的所有阵列,numpy迅速优于列表理解,并且为了增加阵列长度,您将获得预期的Sigmoid曲线以获得性能.但是sigmoid远非光滑,我很难理解.

显然,对于较短的阵列长度存在一定量的量化噪声,但是我得到了意外的噪声结果,特别是在Windows下.这些数字是各种阵列长度的100次运行的平均值,所以应该平滑任何瞬态效应(所以我想到).

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下如此嘈杂.我已多次运行测试,但结果似乎总是完全相同.

UPDATE.在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

UPDATE

在@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

Answer 1

垃圾收集器解释了其中的大部分内容。其余的可能会根据您计算机上运行的其他程序而有所波动。关闭大部分功能并运行最低限度的功能并进行测试怎么样？由于您使用的是日期时间（这是实际经过的时间），因此还必须考虑任何处理器上下文切换。

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

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