Numpy：创建具有指数衰减的正弦波

Question

我是一个 Numpy 新手。

我想创建一个包含一百万个数字的数组，它的正弦波的幅度呈指数衰减。

换句话说，我希望每个单元格n 的值为sin(n) * 2 ** (-n * factor)。

最有效的方法是什么？

Answer 1

Numpy 有自己的sin 函数，可以高效地完成你想做的任务。效率低下的主要原因是求幂2 ** (-n * factor)。

但是，numpy 在其exp 函数中确实具有有效的幂运算。所以我们可以将基数转换为e 以使用exp 通过使用

exp(-n * factor * log(2))

log 是另一个 numpy 函数，使用基数 e。您可以通过在 numpy 在其矢量化中设置的循环之外进行尽可能多的计算来进一步加快代码速度。换句话说，你首先设置了标量

newfactor = -np.log(2) * factor

并使用x = np.linspace(0, 10, 1000000) 或类似的东西设置您的x 数组。然后你的 y 数组是用

创建的

y = np.sin(x) * np.exp(newfactor * x)

现在y 是一个数组，其中所有计算值对应于x 数组中的值。

Numpy 自己进行循环，对于当前技术来说非常有效。我的实验表明，以这种方式进行幂运算所需的时间不到 np.power(2, -factor * x) 或 2 ** (-x * factor) 或 np.exp2(-x * factor) 所用时间的 1/5。查看整个表达式，对于x 一个长度为一百万的数组，我的代码总共需要29.2 ms 来执行。 @ComplicatedPhenomenon 的代码，看起来确实不错，总共需要 81.3 ms 执行，几乎是原来的 3 倍。 （感谢@ComplicatedPhenomenon 指出我的代码中的一个错误——我已经纠正了它，现在它似乎运行良好。）

Answer 2

你可以使用 Numexpr

Numpy 对 sin(array), exp(array),.. 等简单操作有高效的实现。问题是每个表达式 (sin(n); -n * factor, 2 ** previous_Temp_array) 都是使用临时数组独立完成的。这会导致相当高的内存占用，并对性能产生负面影响。

代码

import numpy as np
import numexpr as ne

def orig(n_max,factor):
    n=np.arange(n_max)
    return np.sin(n) * 2 ** (-n * factor)

#Rory Daulton's solution
def mod(n_max,factor):
    n=np.arange(n_max)
    newfactor = -np.log(2) * factor
    return np.sin(n) * np.exp(newfactor * n)

def mod_2(n_max,factor):
    n=np.arange(n_max)
    return ne.evaluate("sin(n) * 2**(-n * factor)")

#Rory Daulton's solution using Numexpr
def mod_3(n_max,factor):
    n=np.arange(n_max)
    newfactor = -np.log(2) * factor
    return ne.evaluate("sin(n) * exp(newfactor * n)")

时间

%timeit res=orig(1e6,0.5)
81 ms ± 4.75 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit res=mod(1e6,0.5)
46.3 ms ± 5.29 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit res=mod_2(1e6,0.5)
16 ms ± 214 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit res=mod_3(1e6,0.5)
11.1 ms ± 48.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)