Каков рекомендуемый способ вычисления взвешенной суммы выбранных столбцов фрейма данных pandas?

Например, я хотел бы вычислить взвешенную сумму столбцов «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.}

Я сам придумал некоторые варианты (см. Ниже), но все они выглядят немного сложными. Разве для этого базового варианта использования нет прямой операции pandas? Что-то вроде 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

Я упустил вариант?


python pandas dot-product
person normanius    schedule 30.12.2018    source источник
comment
Не намного лучше, чем ваш третий вариант, но ... df.mul(w).sum(axis=1)   -  person ayhan    schedule 30.12.2018
comment
Можете ли вы поделиться тем, что вам не нравится в ваших трех решениях вашей проблемы?   -  person jorijnsmit    schedule 30.12.2018
comment
Вы могли сделать: df.loc[:, w].dot(pd.Series(w))   -  person Dani Mesejo    schedule 30.12.2018
comment
@jorijnsmit Интересно, не упустил ли я лучший вариант. Взвешенные комбинации набора столбцов являются обычными, и по опыту pandas обычно предлагает простые решения для таких общих задач. Я также могу представить, что мои три предложения не эквивалентны с точки зрения затрат. Наконец, я не нашел удовлетворительного ответа на SO, который решает мою проблему, поэтому я собрал свое текущее понимание и попросил разъяснений. Может кому еще от этого будет польза.   -  person normanius    schedule 30.12.2018

Ответы (4)


arrow_upward
4
arrow_downward

Вы можете использовать Series, как в первом примере, просто затем используйте переиндексирование:

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
person Dani Mesejo    schedule 30.12.2018
comment
Согласно моему тесту (см. мой ответ), ваше решение является самым быстрым для невыровненных векторов веса w. Поэтому я принял ваш ответ. - person normanius; 15.03.2021

arrow_upward
3
arrow_downward

Вот вариант без создания pd.Series < / а>:

(df.loc[:,w.keys()] * list(w.values())).sum(axis=1)
0    2000.0
1    4000.0
2    6000.0
person yatu    schedule 30.12.2018
comment
Судя по тому, что я искал, порядок сохраняется и в более старых версиях. - person yatu; 30.12.2018
comment
Хороший ответ тогда +1! - person Dani Mesejo; 30.12.2018
comment
Вы также можете: df.loc[:, w].dot(pd.Series(w)) - person Dani Mesejo; 30.12.2018
comment
Спасибо @DanielMesejo :) - person yatu; 30.12.2018

arrow_upward
2
arrow_downward

Я снова наткнулся на свой вопрос и сравнил доступные ответы.

Наблюдение: целесообразно сначала заполнить неполный вектор веса нулями, а не сначала захватывать представление по столбцам, а затем умножать полученный подкадр точками.

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).

person normanius    schedule 15.03.2021

arrow_upward
1
arrow_downward

Использование 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
person BENY    schedule 30.12.2018