python – Pandas的性能与np.vectorize相对应,可以从现有列创建新列
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python – Pandas的性能与np.vectorize相对应,可以从现有列创建新列，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6175字，纯文字阅读大概需要9分钟。
内容图文
我正在使用Pandas数据帧,并希望创建一个新列作为现有列的函数.我没有看到df.apply()和np.vectorize()之间的速度差异的很好的讨论,所以我想我会在这里问.
Pandas apply()函数很慢.根据我的测量结果(在下面的一些实验中显示),使用np.vectorize()比使用DataFrame函数apply()快25倍(或更多),至少在我的2016 MacBook Pro上使用.这是预期的结果,为什么？
例如,假设我有以下具有N行的数据帧：
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
如果np.vectorize()通常总是比df.apply()快,那么为什么np.vectorize()没有提到更多？我只看到与df.apply()相关的StackOverflow帖子,例如：
pandas create new column based on values from other columns
How do I use Pandas ‘apply’ function to multiple columns?
How to apply a function to two columns of Pandas dataframe
解决方法:
我将首先说Pandas和NumPy数组的强大功能来源于数值数组上的高性能矢量化计算.1矢量化计算的整个要点是通过将计算移动到高度优化的C代码并使用连续的方法来避免Python级循环记忆块
Python级循环
现在我们可以看看一些时间.下面是所有Python级循环,它们生成pd.Series,np.ndarray或包含相同值的列表对象.为了在数据帧中分配系列,结果是可比较的.
# 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
一些要点：
>基于元组的方法(前4个)是比基于pd.Series的方法(后3个)更有效的因素.
> np.vectorize,list comprehension zip和map方法,即前3个,都具有大致相同的性能.这是因为它们使用元组并绕过pd.DataFrame.itertuples中的一些Pandas开销.
>使用raw = True与pd.DataFrame.apply相比没有显着提高速度.此选项将NumPy数组提供给自定义函数而不是pd.Series对象.
pd.DataFrame.apply：只是另一个循环
要准确查看Pandas传递的对象,您可以简单地修改您的功能：
def foo(row):
print(type(row))
assert False # because you only need to see this once
df.apply(lambda row: foo(row), axis=1)
输出：< class'pandas.core.series.Series'>.创建,传递和查询Pandas系列对象相对于NumPy数组会带来很大的开销.这应该不足为奇：熊猫系列包含了相当数量的脚手架来保存索引,值,属性等.
使用raw = True再次执行相同的练习,您将看到< class'numpy.ndarray'>.所有这些都在文档中描述,但看到它更有说服力.
np.vectorize：假矢量化
np.vectorize的文档有以下注释：
The vectorized function evaluates
pyfuncover successive tuples of
the input arrays like the python map function, except it uses the
broadcasting rules of numpy.
“广播规则”在这里是无关紧要的,因为输入数组具有相同的尺寸.与地图平行是有启发性的,因为上面的地图版本具有几乎相同的性能. source code显示正在发生的事情：np.vectorize通过np.frompyfunc将输入函数转换为Universal function(“ufunc”).有一些优化,例如缓存,这可以带来一些性能提升.
简而言之,np.vectorize执行Python级循环应该做的事情,但pd.DataFrame.apply增加了一个粗略的开销.你在numba看到的没有JIT编译(见下文).这是just a convenience.
真正的矢量化：你应该使用什么
为什么上述差异不在任何地方？因为真正矢量化计算的性能使它们无关紧要：
%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
是的,这比上述循环解决方案中最快的速度快40倍.这些都是可以接受的.在我看来,第一个是简洁,可读和高效.只看其他方法,例如下面的numba,如果性能至关重要,这是你瓶颈的一部分.
numba.njit：效率更高
当循环被认为是可行的时,它们通常通过具有底层NumPy阵列的numba进行优化,以尽可能多地移动到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)可以为更大的数组提供进一步的提升.
1数字类型包括：int,float,datetime,bool,category.它们排除了对象dtype,并且可以保存在连续的内存块中.
2
与Python相比,NumPy操作的效率至少有两个原因：
> Python中的所有东西都是一个对象.与C不同,这包括数字.因此,Python类型具有本机C类型不存在的开销.
> NumPy方法通常是基于C的.此外,还有优化的算法
尽可能使用.
内容总结
以上是互联网集市为您收集整理的python – Pandas的性能与np.vectorize相对应,可以从现有列创建新列全部内容，希望文章能够帮你解决python – Pandas的性能与np.vectorize相对应,可以从现有列创建新列所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。