在 python pandas 中实现 Apriori 的最佳方法

Question

在 pandas 中实现 Apriori 算法的最佳方法是什么？到目前为止，我一直坚持使用 for 循环转换提取模式。从 for 循环开始的一切都不起作用。在 pandas 中是否有一种矢量化的方式来做到这一点？

import pandas as pd
import numpy as np

trans=pd.read_table('output.txt', header=None,index_col=0)

def apriori(trans, support=4):
    ts=pd.get_dummies(trans.unstack().dropna()).groupby(level=1).sum()
    #user input

    collen, rowlen  =ts.shape

    #max length of items
    tssum=ts.sum(axis=1)
    maxlen=tssum.loc[tssum.idxmax()]

    items=list(ts.columns)

    results=[]
    #loop through items
    for c in  range(1, maxlen):
        #generate patterns
        pattern=[]
        for n in  len(pattern):
            #calculate support
            pattern=['supp']=pattern.sum/rowlen
            #filter by support level
            Condit=pattern['supp']> support
            pattern=pattern[Condit]
            results.append(pattern)
   return results

results =apriori(trans)
print results

当我用支持 3 插入它时

        a  b  c  d  e
0                    
11      1  1  1  0  0
666     1  0  0  1  1
10101   0  1  1  1  0
1010    1  1  1  1  0
414147  0  1  1  0  0
10101   1  1  0  1  0
1242    0  0  0  1  1
101     1  1  1  1  0
411     0  0  1  1  1
444     1  1  1  0  0

它应该输出类似的东西

   Pattern   support
    a         6
    b         7
    c         7
    d         7
    e         3
    a,b       5
    a,c       4
    a,d       4

Answer 1

添加支持、信心和提升计算。

def apriori(data, set_length=2):
    import pandas as pd
    df_supports = []
    dataset_size = len(data)
    for combination_number in range(1, set_length+1):
        for cols in combinations(data.columns, combination_number):
            supports = data[list(cols)].all(axis=1).sum() * 1.0 / dataset_size
            confidenceAB = data[list(cols)].all(axis=1).sum() * 1.0 / len(data[data[cols[0]]==1])
            confidenceBA = data[list(cols)].all(axis=1).sum() * 1.0 / len(data[data[cols[-1]]==1])
            liftAB = confidenceAB * dataset_size / len(data[data[cols[-1]]==1])
            liftBA = confidenceAB * dataset_size / len(data[data[cols[0]]==1])
            df_supports.append([",".join(cols), supports, confidenceAB, confidenceBA, liftAB, liftBA])
    df_supports = pd.DataFrame(df_supports, columns=['Pattern', 'Support', 'ConfidenceAB', 'ConfidenceBA', 'liftAB', 'liftBA'])
    df_supports.sort_values(by='Support', ascending=False)

    return df_supports

Answer 2

假设我明白你的目标，也许

from itertools import combinations
def get_support(df):
    pp = []
    for cnum in range(1, len(df.columns)+1):
        for cols in combinations(df, cnum):
            s = df[list(cols)].all(axis=1).sum()
            pp.append([",".join(cols), s])
    sdf = pd.DataFrame(pp, columns=["Pattern", "Support"])
    return sdf

会让你开始：

>>> s = get_support(df)
>>> s[s.Support >= 3]
   Pattern  Support
0        a        6
1        b        7
2        c        7
3        d        7
4        e        3
5      a,b        5
6      a,c        4
7      a,d        4
9      b,c        6
10     b,d        4
12     c,d        4
14     d,e        3
15   a,b,c        4
16   a,b,d        3
21   b,c,d        3

[15 rows x 2 columns]