python – Pandas groupby.size vs series.value_counts vs collections.Counter with multiple series

有许多问题(1,2,3)涉及单个系列中的计数值.

但是,关于计算两个或更多系列组合的最佳方法的问题较少.提出了解决方案(1,2),但没有讨论何时以及为何应该使用每个解决方案.

以下是三种潜在方法的基准测试.我有两个具体问题：

>为什么石斑鱼比计数更有效？我预计数量会更高效,因为它在C中实现.即使柱数从2增加到4,石斑鱼的优越性能仍然存在.
>为什么value_counter表现得如此糟糕？这是由于从列表构建列表或系列的成本吗？

我理解输出是不同的,这也应该告知选择.例如,对于连续的numpy数组和字典理解,按count计数更有效：

x, z = grouper(df), count(df)
%timeit x[x.values > 10]                        # 749µs
%timeit {k: v for k, v in z.items() if v > 10}  # 9.37ms

然而,我的问题的重点是在系列与字典中建立可比较结果的表现.我的C知识是有限的,但我会感谢任何可以指出这些方法的基础逻辑的答案.

基准代码

import pandas as pd
import numpy as np
from collections import Counter

np.random.seed(0)

m, n = 1000, 100000

df = pd.DataFrame({'A': np.random.randint(0, m, n),
                   'B': np.random.randint(0, m, n)})

def grouper(df):
    return df.groupby(['A', 'B'], sort=False).size()

def value_counter(df):
    return pd.Series(list(zip(df.A, df.B))).value_counts(sort=False)

def count(df):
    return Counter(zip(df.A.values, df.B.values))

x = value_counter(df).to_dict()
y = grouper(df).to_dict()
z = count(df)

assert (x == y) & (y == z), "Dictionary mismatch!"

for m, n in [(100, 10000), (1000, 10000), (100, 100000), (1000, 100000)]:

    df = pd.DataFrame({'A': np.random.randint(0, m, n),
                       'B': np.random.randint(0, m, n)})

    print(m, n)

    %timeit grouper(df)
    %timeit value_counter(df)
    %timeit count(df)

基准测试结果

在python 3.6.2上运行,pandas为0.20.3,numpy为1.13.1

机器规格：Windows 7 64位,双核2.5 GHz,4GB RAM.

键：g =石斑鱼,v = value_counter,c = count.

m           n        g        v       c
100     10000     2.91    18.30    8.41
1000    10000     4.10    27.20    6.98[1]
100    100000    17.90   130.00   84.50
1000   100000    43.90   309.00   93.50

1这不是拼写错误.

解决方法:

zip中实际上有一些隐藏的开销(df.A.values,df.B.values).这里的关键归结为以与Python对象完全不同的方式存储在内存中的numpy数组.

numpy数组(例如np.arange(10))基本上存储为连续的内存块,而不是单独的Python对象.相反,python列表(例如list(range(10))作为指向各个Python对象(即整数0-9)的指针存储在内存中.这种差异是为什么numpy数组在内存中比Python等效列表更小的基础,以及为什么你可以在numpy数组上执行更快的计算.

因此,当Counter消耗zip时,需要将关联的元组创建为Python对象.这意味着Python需要从numpy数据中提取元组值,并在内存中创建相应的Python对象.这有明显的开销,这就是为什么在将纯Python函数与numpy数据组合时要非常小心的原因.您可能经常看到的这个陷阱的基本示例是在numpy数组上使用内置Python和：sum(np.arange(10 ** 5))实际上比纯Python总和慢一点(范围(10) ** 5)),两者当然明显慢于np.sum(np.arange(10 ** 5)).

有关此主题的更深入讨论,请参见this video.

作为特定于此问题的示例,请观察以下时序,比较Counter on zipped numpy数组与相应的压缩python列表的性能.

In [2]: a = np.random.randint(10**4, size=10**6)
   ...: b = np.random.randint(10**4, size=10**6)
   ...: a_list = a.tolist()
   ...: b_list = b.tolist()

In [3]: %timeit Counter(zip(a, b))
455 ms ± 4.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [4]: %timeit Counter(zip(a_list, b_list))
334 ms ± 4.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

这两个时间之间的差异使您可以合理估计前面讨论的开销.

但这并不是故事的结局.在pandas中构造groupby对象也涉及一些开销,至少与此问题有关,因为有一些groupby元数据并不是为了获得大小而非严格必要的,而Counter会做你关心的一个单一事物.通常这个开销远低于与Counter相关的开销,但是从一些快速实验中我发现,当你的大多数组只包含单个元素时,你可以从Counter中获得略微更好的性能.

考虑以下时序(使用@ BallpointBen的sort = False建议),其沿着几个大组的频谱进行 – < - >许多小团体：

def grouper(df):
    return df.groupby(['A', 'B'], sort=False).size()

def count(df):
    return Counter(zip(df.A.values, df.B.values))

for m, n in [(10, 10**6), (10**3, 10**6), (10**7, 10**6)]:

    df = pd.DataFrame({'A': np.random.randint(0, m, n),
                       'B': np.random.randint(0, m, n)})

    print(m, n)

    %timeit grouper(df)
    %timeit count(df)

这给了我下表：

m       grouper   counter
10      62.9 ms    315 ms
10**3    191 ms    535 ms
10**7    514 ms    459 ms

当然,来自Counter的任何收益都可以通过转换回系列来抵消,如果这是您想要的最终对象.