计算熊猫数据框选定列的加权和的推荐方法是什么？答案

【问题标题】：What is the recommended way to compute a weighted sum of selected columns of a pandas dataframe?计算熊猫数据框选定列的加权和的推荐方法是什么？
【发布时间】：2018-12-30 18:51:49
【问题描述】：

例如，我想计算以下矩阵的“a”和“c”列的加权和，权重在字典 w 中定义。

df = pd.DataFrame({'a': [1,2,3], 
                   'b': [10,20,30], 
                   'c': [100,200,300],
                   'd': [1000,2000,3000]})
w = {'a': 1000., 'c': 10.}

我自己想出了一些选项（见下文），但看起来都有些复杂。这个基本用例没有直接的熊猫操作吗？ df.wsum(w) 之类的东西？

我试过pd.DataFrame.dot，但它引发了一个值错误：

df.dot(pd.Series(w))
# This raises an exception:
# "ValueError: matrices are not aligned"

可以通过为每一列指定权重来避免异常，但这不是我想要的。

w = {'a': 1000., 'b': 0., 'c': 10., 'd': 0. }
df.dot(pd.Series(w)) # This works

如何仅计算列子集的点积？或者，可以在应用点操作之前选择感兴趣的列，或者利用 pandas/numpy 在计算（逐行）总和时忽略 nans 的事实（见下文）。

以下是我自己发现的三种方法：

w = {'a': 1000., 'c': 10.}

# 1) Create a complete lookup W.
W = { c: 0. for c in df.columns }
W.update(w)
ret = df.dot(pd.Series(W))

# 2) Select columns of interest before applying the dot product.
ret = df[list(w.keys())].dot(pd.Series(w))

# 3) Exploit the handling of NaNs when computing the (row-wise) sum
ret = (df * pd.Series(w)).sum(axis=1)
# (df * pd.Series(w)) contains columns full of nans

我错过了一个选项吗？

【问题讨论】：

并不比你的第三个选项好多少，但是...df.mul(w).sum(axis=1)
您能分享一下您对当前解决问题的三个解决方案的不满意之处吗？
你可以这样做：df.loc[:, w].dot(pd.Series(w))
@jorijnsmit 我想知道我是否错过了最佳选择。一组列的加权组合很常见，根据经验，pandas 通常为此类常见任务提供简单的解决方案。我也可以想象我的三个建议在成本方面是不等价的。最后，我在 SO 上没有找到满意的答案来解决我的问题，这就是为什么我收集了我目前的理解并要求澄清的原因。也许其他人会从中受益。

标签： python pandas dot-product

【解决方案1】：

您可以像在第一个示例中一样使用系列，之后只需使用 reindex：

import pandas as pd

df = pd.DataFrame({'a': [1,2,3],
                   'b': [10,20,30],
                   'c': [100,200,300],
                   'd': [1000,2000,3000]})

w = {'a': 1000., 'c': 10.}
print(df.dot(pd.Series(w).reindex(df.columns, fill_value=0)))

输出

0    2000.0
1    4000.0
2    6000.0
dtype: float64

【讨论】：

根据我的基准（参见my answer），对于未对齐的权重向量w，您的解决方案是最快的。因此我接受了你的回答。

【解决方案2】：

这是一个无需创建pd.Series 的选项：

(df.loc[:,w.keys()] * list(w.values())).sum(axis=1)
0    2000.0
1    4000.0
2    6000.0

【讨论】：

从我搜索的内容来看，旧版本中也保留了顺序
好的答案然后+1！
你也可以这样做：df.loc[:, w].dot(pd.Series(w))
谢谢@DanielMesejo :)

【解决方案3】：

我又一次偶然发现了自己的问题，并对可用的答案进行了基准测试。

观察：首先用零填充不完整的权重向量是值得的，而不是先捕获列上的视图，然后再对生成的子帧进行点乘。

import pandas as pd
import numpy as np

def benchmark(n_rows, n_cols, n_ws):
    print("n_rows:%d, n_cols:%d, n_ws:%d" % (n_rows, n_cols, n_ws))
    df = pd.DataFrame(np.random.randn(n_rows, n_cols), 
                      columns=range(n_cols))
    w = dict(zip(np.random.choice(np.arange(n_cols), n_ws), 
                 np.random.randn(n_ws)))
    w0 = pd.Series(w).reindex(df.columns, fill_value=0).values

    # Method 0 (aligned vector w0, reference!)
    def fun0(df, w0): return df.values.dot(w0)
    # Method 1 (reindex)
    def fun1(df, w): return df.dot(pd.Series(w).reindex(df.columns, fill_value=0))
    # Method 2 (column view)
    def fun2(df, w): return (df.loc[:,w.keys()] * list(w.values())).sum(axis=1)
    # Method 3 (column view, faster)
    def fun3(df, w): return df.loc[:, w].dot(pd.Series(w))
    # Method 4 (column view, numpy)
    def fun4(df, w): return df[list(w.keys())].values.dot(list(w.values()))

    # Assert equivalence
    np.testing.assert_array_almost_equal(fun0(df,w0), fun1(df,w), decimal=10)
    np.testing.assert_array_almost_equal(fun0(df,w0), fun2(df,w), decimal=10)
    np.testing.assert_array_almost_equal(fun0(df,w0), fun3(df,w), decimal=10)
    np.testing.assert_array_almost_equal(fun0(df,w0), fun4(df,w), decimal=10)

    print("fun0:", end=" ")
    %timeit fun0(df, w0)
    print("fun1:", end=" ")
    %timeit fun1(df, w)
    print("fun2:", end=" ")
    %timeit fun2(df, w)
    print("fun3:", end=" ")
    %timeit fun3(df, w)
    print("fun4:", end=" ")
    %timeit fun4(df, w)

benchmark(n_rows = 200000, n_cols = 11, n_ws = 3)
benchmark(n_rows = 200000, n_cols = 11, n_ws = 9)
benchmark(n_rows = 200000, n_cols = 31, n_ws = 5)

输出（fun0() 是使用零填充向量w0 的引用）：

n_rows:200000, n_cols:11, n_ws:3
fun1: 1.98 ms ± 86.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun2: 9.66 ms ± 32.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun3: 2.68 ms ± 90.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun4: 2.2 ms ± 45.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

n_rows:200000, n_cols:11, n_ws:9
fun1: 1.85 ms ± 28.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
fun2: 11.7 ms ± 54.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun3: 3.7 ms ± 84.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun4: 3.17 ms ± 29.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

n_rows:200000, n_cols:31, n_ws:5
fun1: 3.08 ms ± 42.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun2: 13.1 ms ± 260 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
fun3: 5.48 ms ± 57 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
fun4: 4.98 ms ± 49.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

我已经使用 pandas 1.2.3、numpy 1.20.1 和 Python 3.9.0 进行了测试。在 MacBookPro（2015 年末）上。（旧的 Python 版本也有类似的结果）。

【讨论】：

【解决方案4】：

将numpy dot 与值一起使用

df[list(w.keys())].values.dot(list(w.values()))
array([2000., 4000., 6000.])

修正了你的错误

df.mul( pd.Series(w),1).sum(axis=1)
0    2000.0
1    4000.0
2    6000.0
dtype: float64

【讨论】：