如何向量化/优化依赖于先前行的计算

如何解决如何向量化/优化依赖于先前行的计算

我正在研究运行时非常重要并且我们正在处理的数据很大的事情，但是基本上，问题归结为对x已知且x = ax + b的系列x进行优化求解行。例如，开始状态：

a b x
1 2 3
3 1
2 2
4 8
1 9

，结束状态如下：

a b x
1 2 3
3 1 5
2 2 16
4 8 72
1 9 81

因为3 * 1 + 2 = 5、5 * 3 + 1 = 16，等等。

我尝试算出它的数学公式，最后得到了：

b0 = x1
xi = sum(n=0 to i-1)(bn*product(m=n+1 to i-1)(am)

例如，对于第三行，您最终得到：

x3 = a1*a2*b0 + b1*a2 + b2 = 3*1*3 + 2*3 + 1 = 9 + 6 + 1 = 16

但是在计算上，这似乎比仅通过遍历行来计算每个x更糟糕，像这样：

for i in range(2,len(df)):
    df.x[i] = df.x[i-1]*df.a[i-1]+df.b[i-1]

是否有一种更简单的方法来解决我所缺少的问题，或者我只是在处理一个计算量大的操作，而我不得不承担迭代的费用？如果该词不存在，则可以通过cumsum解决bn部分，例如：

df['b_cumsum'] = x1+cumsum(df.b)

但是当我试图包含这些术语时，我最终碰壁了，特别是因为我们最终甚至在每个和项内都需要这么多不同的产品集。

谢谢。

解决方法

当我遇到函数时，我无法向量化，但是它必须高效，我使用numba。这是一个即时编译（JIT）模块。在大多数情况下，这甚至可以比本地pandas方法更快：

from numba import njit

@njit
def calculation(arr):
    result = np.empty(arr.shape[0])
    for idx,row in enumerate(arr):
        if idx == 0:
            result[idx] = row[2]
        else:
            row = arr[idx-1]
            result[idx] = result[idx-1] * row[0] + row[1]
    
    return result

df['x'] = calculation(df.to_numpy())

print(df)

   a  b      x
0  1  2    3.0
1  3  1    5.0
2  2  2   16.0
3  4  8   34.0
4  1  9  144.0

---

注释：要计时的时间。由于它尚未编译，因此不要在第一次运行时进行计时。首先运行一次，然后在第二次运行中计时。

,

您可以先使用a来计算重新缩放的 x ： x '= x / cumprod（ a ）匹配 b '= b / cumprod（ a ）

这可以通过向量化操作完成，也可以从 x '反向转换为 x ：

ab = np.array([[1,2],[3,1],[2,[4,8],[1,9]])

scale = ab.T[0].cumprod()
xp = 3+(ab.T[1]/scale).cumsum()
x = xp*scale
x
array([  5.,16.,34.,144.,153.])