Pandas apply与NP.Vectorize从现有列创建新列性能

Question

例如，假设我有以下带有n行的dataframe：

N = 10
A_list = np.random.randint(1, 100, N)
B_list = np.random.randint(1, 100, N)
df = pd.DataFrame({'A': A_list, 'B': B_list})
df.head()
#     A   B
# 0  78  50
# 1  23  91
# 2  55  62
# 3  82  64
# 4  99  80

进一步假设我希望创建一个新列，作为两列a和B的函数。在下面的示例中，我将使用一个简单的函数divide()。要应用该函数，可以使用df.apply()或np.vectorize():

def divide(a, b):
    if b == 0:
        return 0.0
    return float(a)/b

df['result'] = df.apply(lambda row: divide(row['A'], row['B']), axis=1)

df['result2'] = np.vectorize(divide)(df['A'], df['B'])

df.head()
#     A   B    result   result2
# 0  78  50  1.560000  1.560000
# 1  23  91  0.252747  0.252747
# 2  55  62  0.887097  0.887097
# 3  82  64  1.281250  1.281250
# 4  99  80  1.237500  1.237500

如果我将n的实际大小增加到100万或更多，那么我会发现np.vectorize()比df.apply()快25倍或更多。

import pandas as pd
import numpy as np
import time

def divide(a, b):
    if b == 0:
        return 0.0
    return float(a)/b

for N in [1000, 10000, 100000, 1000000, 10000000]:    

    print ''
    A_list = np.random.randint(1, 100, N)
    B_list = np.random.randint(1, 100, N)
    df = pd.DataFrame({'A': A_list, 'B': B_list})

    start_epoch_sec = int(time.time())
    df['result'] = df.apply(lambda row: divide(row['A'], row['B']), axis=1)
    end_epoch_sec = int(time.time())
    result_apply = end_epoch_sec - start_epoch_sec

    start_epoch_sec = int(time.time())
    df['result2'] = np.vectorize(divide)(df['A'], df['B'])
    end_epoch_sec = int(time.time())
    result_vectorize = end_epoch_sec - start_epoch_sec


    print 'N=%d, df.apply: %d sec, np.vectorize: %d sec' % \
            (N, result_apply, result_vectorize)

    # Make sure results from df.apply and np.vectorize match.
    assert(df['result'].equals(df['result2']))

N=1000, df.apply: 0 sec, np.vectorize: 0 sec

N=10000, df.apply: 1 sec, np.vectorize: 0 sec

N=100000, df.apply: 2 sec, np.vectorize: 0 sec

N=1000000, df.apply: 24 sec, np.vectorize: 1 sec

N=10000000, df.apply: 262 sec, np.vectorize: 4 sec

我如何使用Pandas的‘应用’功能多列？

如何将函数应用于Pandas数据帧的两列

Answer 1

我首先要说的是，Pandas和NumPy数组的强大之处来自于对数值数组的html" target="_blank">高性能矢量化计算。¹矢量化计算的全部意义是通过将计算移到高度优化的C代码和利用连续的内存块来避免Python级别的循环。²

现在我们可以看看一些计时。下面是所有Python级循环，它们生成包含相同值的pd.series、np.ndarray或list对象。为了分配给数据帧中的一个系列，结果是可比较的。

# Python 3.6.5, NumPy 1.14.3, Pandas 0.23.0

np.random.seed(0)
N = 10**5

%timeit list(map(divide, df['A'], df['B']))                                   # 43.9 ms
%timeit np.vectorize(divide)(df['A'], df['B'])                                # 48.1 ms
%timeit [divide(a, b) for a, b in zip(df['A'], df['B'])]                      # 49.4 ms
%timeit [divide(a, b) for a, b in df[['A', 'B']].itertuples(index=False)]     # 112 ms
%timeit df.apply(lambda row: divide(*row), axis=1, raw=True)                  # 760 ms
%timeit df.apply(lambda row: divide(row['A'], row['B']), axis=1)              # 4.83 s
%timeit [divide(row['A'], row['B']) for _, row in df[['A', 'B']].iterrows()]  # 11.6 s

一些外卖：

null

def foo(row):
    print(type(row))
    assert False  # because you only need to see this once
df.apply(lambda row: foo(row), axis=1)

输出: 。创建、传递和查询Pandas series对象相对于NumPy数组会带来很大的开销。这并不奇怪：Pandas系列包含了相当多的支架来保存索引、值、属性等。

使用raw=true再次执行相同的练习，您将看到 。这一切在文档中都有描述，但看到它更有说服力。

np.vectorize的文档有以下注意事项：

vectorized函数对输入数组的连续元组求值pyfunc，与python map函数一样，不同的是它使用了numpy的广播规则。

%timeit np.where(df['B'] == 0, 0, df['A'] / df['B'])       # 1.17 ms
%timeit (df['A'] / df['B']).replace([np.inf, -np.inf], 0)  # 1.96 ms

当循环被认为是可行的时，它们通常通过numba进行优化，并使用底层NumPy数组尽可能多地移动到C。

确实，numba将性能提高到微秒级。如果没有一些繁琐的工作，就很难得到比这更有效率的多。

from numba import njit

@njit
def divide(a, b):
    res = np.empty(a.shape)
    for i in range(len(a)):
        if b[i] != 0:
            res[i] = a[i] / b[i]
        else:
            res[i] = 0
    return res

%timeit divide(df['A'].values, df['B'].values)  # 717 µs

使用@njit(parallel=true)可以进一步促进更大的数组。

null