主页 / coding / 问题 / 79013954
Accepted
belamy
Asked: 2024-09-23 17:14:13 +0800 CST

如何通过将前一个单元格与固定因子相乘来将 v 列中的值相加，然后添加另一列的当前单元格

  • 772

从“pd.DataFrame” df 开始：〜

         n    v
    0    1  0.0
    1    2  0.0
    2    3  0.0
    3    4  0.0
    4    5  0.0
    5    6  0.0

我想将“v”列中的值相加，即通过将“v”列的前一个单元格与固定因子相乘来生成“v”列中的一个单元格，然后添加“n”列的当前单元格值。（请参阅下面的示例计算表）

    ## sample calculation table :~
    n   v[i]      n  + v[i-1] * fixed factor 
    1   1.0     = 1  + 0.0    * 0.5
    2   2.5     = 2  + 1.0    * 0.5   
    3   4.25    = 3  + 2.5    * 0.5
    4   6.125   = 4  + 4.25   * 0.5
    5   8.0625  = 5  + 6.125  * 0.5
    6  10.03125 = 6  + 8.063  * 0.5

通过逐行迭代来完成此操作（参见下面的 for 循环）。

然而，我认为矢量化方法（例如 cumsum 和 shift）可能更有效，但不知道如何实现；因为 cumsum 通过乘法变得复杂，从空列 v 开始，并且需要引用列的前一个单元格。

想知道如何使用矢量化方法来实现这一点吗？

重现我的代码：

    df = pd.DataFrame({'n':[1,2,3,4,5,6]})
    df['v'] = 0.0

    def fnv(nu, vu):
        return nu + vu * 0.5

    for i in range(0, df.shape[0]):
        df.v.at[i] = fnv(df.n.at[i], df.v.at[i-1] if i>0 else 0.0)

    df (RESULTS) :~
         n      v
    0    1   1.00
    1    2   2.50
    2    3   4.25
    3    4   6.12
    4    5   8.06
    5    6  10.03
python

3 个回答

  1. 递归计算不可矢量化，为了提高性能使用numba：

    from numba import jit

@jit(nopython=True)
def f(a, N):
    d = np.empty(a.shape)
    d[0] = 0
    for i in range(0, a.shape[0]):
        d[i] = a[i] + d[i-1] * N 
    return d

df['v'] = f(df['n'].to_numpy(), 0.5)
print (df)
   n          v
0  1   1.000000
1  2   2.500000
2  3   4.250000
3  4   6.125000
4  5   8.062500
5  6  10.031250
6  7  12.015625

    解决方案比较，在真实数据中最佳测试：

    df = pd.DataFrame({'n':range(1, 1000)})


In [22]: %timeit df['v1'] = f(df['n'].to_numpy(), 0.5)
69.8 µs ± 373 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
#https://stackoverflow.com/a/79013999/2901002 
In [23]: %timeit df['v2'] = fnv(df['n'].to_numpy())
158 µs ± 2.27 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

    df = pd.DataFrame({'n':range(1, 10000)})


In [25]: %timeit df['v1'] = f(df['n'].to_numpy(), 0.5)
107 µs ± 554 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [26]: %timeit df['v2'] = fnv(df['n'].to_numpy())
860 µs ± 38.7 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
    • 2
  2. Best Answer

    由于n是变量，您无法轻松地对其进行矢量化（您可以使用矩阵运算，参见下文，但这将占用 O(n^2) 空间）。

    一个好的权衡可能是使用numba来加快操作：

    from numba import jit

@jit(nopython=True)
def fnv(n, factor=0.5):
    out = []
    prev = 0
    for x in n:
        out.append(x + prev*factor)
        prev = out[-1]
    return out

df['v'] = fnv(df['n'].to_numpy())

    输出：

       n         v
0  1   1.00000
1  2   2.50000
2  3   4.25000
3  4   6.12500
4  5   8.06250
5  6  10.03125

    矢量化方法

    您可以使用方阵进行矢量化：

    x = np.arange(len(df))
tmp = x[:, None]-x
df['v'] = np.nansum(np.where(tmp>=0, 0.5**tmp, np.nan) * df['n'].to_numpy(),
                    axis=1)

    中间体：

    # tmp
[[ 0 -1 -2 -3 -4 -5]
 [ 1  0 -1 -2 -3 -4]
 [ 2  1  0 -1 -2 -3]
 [ 3  2  1  0 -1 -2]
 [ 4  3  2  1  0 -1]
 [ 5  4  3  2  1  0]]

# tmp >= 0
[[ True False False False False False]
 [ True  True False False False False]
 [ True  True  True False False False]
 [ True  True  True  True False False]
 [ True  True  True  True  True False]
 [ True  True  True  True  True  True]]

# np.where(tmp>=0, 0.5**tmp, np.nan) * df['n'].to_numpy()
[[1.          nan     nan     nan     nan     nan]
 [0.5     2.          nan     nan     nan     nan]
 [0.25    1.      3.          nan     nan     nan]
 [0.125   0.5     1.5     4.          nan     nan]
 [0.0625  0.25    0.75    2.      5.          nan]
 [0.03125 0.125   0.375   1.      2.5     6.     ]]
    • 2

  3. 你可以用 0.5 幂的核对列进行卷积，如果达到机器精度，则截断：

    import numpy as np

a = np.array([1,2,3,4,5,6])

factor = 0.5

kernel = factor ** (np.arange( a.size ) )
kernel = kernel[~np.isclose(kernel, 0)]

out = np.convolve(a, kernel)[ :a.size ]

out
Out[]: array([ 1.,  2.5,  4.25,  6.125,  8.0625, 10.03125])

    你需要将卷积变成一个pandas函数，但它应该很快，而不需要numba

    • 2

相关问题