Apriori算法的python实现——机器学习

原始链接：基于Python的机器学习实战：Apriori

原始链接里的代码是在python2下写的，有的地方我看的不是太明白，在这里，我把它修改成能在python3下运行了，还加入了一些方便自己理解的注释。

Apriori算法的pyspark实现：pyspark实现Apriori算法、循环迭代、并行处理

[python]  view plain  copy

1. #coding=utf8  
2. #python3.5  
3. #http://www.cnblogs.com/90zeng/p/apriori.html  
4.   
5. def loadDataSet():  
6.     '''''创建一个用于测试的简单的数据集'''  
7.     return [ [ 1, 3, 4,5 ], [ 2, 3, 5 ], [ 1, 2, 3,4, 5 ], [ 2,3,4, 5 ] ]  
8. def createC1( dataSet ):  
9.     ''''' 
10.         构建初始候选项集的列表，即所有候选项集只包含一个元素， 
11.         C1是大小为1的所有候选项集的集合 
12.     '''  
13.     C1 = []  
14.     for transaction in dataSet:  
15.         for item in transaction:  
16.             if [ item ] not in C1:  
17.                 C1.append( [ item ] )  
18.     C1.sort()  
19.     #return map( frozenset, C1 )  
20.     #return [var for var in map(frozenset,C1)]  
21.     return [frozenset(var) for var in C1]  
22. def scanD( D, Ck, minSupport ):  
23.     ''''' 
24.         计算Ck中的项集在数据集合D(记录或者transactions)中的支持度, 
25.         返回满足最小支持度的项集的集合，和所有项集支持度信息的字典。 
26.     '''  
27.     ssCnt = {}  
28.     for tid in D:                  # 对于每一条transaction  
29.         for can in Ck:             # 对于每一个候选项集can，检查是否是transaction的一部分 # 即该候选can是否得到transaction的支持  
30.             if can.issubset( tid ):  
31.                 ssCnt[ can ] = ssCnt.get( can, 0) + 1  
32.     numItems = float( len( D ) )  
33.     retList = []  
34.     supportData = {}  
35.     for key in ssCnt:  
36.         support = ssCnt[ key ] / numItems                   # 每个项集的支持度  
37.         if support >= minSupport:                           # 将满足最小支持度的项集，加入retList  
38.             retList.insert( 0, key )  
39.         supportData[ key ] = support                        # 汇总支持度数据  
40.     return retList, supportData  
41. def aprioriGen( Lk, k ): # Aprior算法  
42.     ''''' 
43.         由初始候选项集的集合Lk生成新的生成候选项集， 
44.         k表示生成的新项集中所含有的元素个数 
45.     '''  
46.     retList = []  
47.     lenLk = len( Lk )  
48.     for i in range( lenLk ):  
49.         for j in range( i + 1, lenLk ):  
50.             L1 = list( Lk[ i ] )[ : k - 2 ];  
51.             L2 = list( Lk[ j ] )[ : k - 2 ];  
52.             L1.sort();L2.sort()  
53.             if L1 == L2:  
54.                 retList.append( Lk[ i ] | Lk[ j ] )   
55.     return retList  
56. def apriori( dataSet, minSupport = 0.5 ):  
57.     C1 = createC1( dataSet )                                # 构建初始候选项集C1  
58.     #D = map( set, dataSet )                                 # 将dataSet集合化，以满足scanD的格式要求  
59.     #D=[var for var in map(set,dataSet)]  
60.     D=[set(var) for var in dataSet]  
61.     L1, suppData = scanD( D, C1, minSupport )               # 构建初始的频繁项集，即所有项集只有一个元素  
62.     L = [ L1 ]                                              # 最初的L1中的每个项集含有一个元素，新生成的  
63.     k = 2                                                   # 项集应该含有2个元素，所以 k=2  
64.       
65.     while ( len( L[ k - 2 ] ) > 0 ):  
66.         Ck = aprioriGen( L[ k - 2 ], k )  
67.         Lk, supK = scanD( D, Ck, minSupport )  
68.         suppData.update( supK )                             # 将新的项集的支持度数据加入原来的总支持度字典中  
69.         L.append( Lk )                                      # 将符合最小支持度要求的项集加入L  
70.         k += 1                                              # 新生成的项集中的元素个数应不断增加  
71.     return L, suppData                                      # 返回所有满足条件的频繁项集的列表，和所有候选项集的支持度信息   
72. def calcConf( freqSet, H, supportData, brl, minConf=0.7 ):  # 规则生成与评价    
73.     ''''' 
74.         计算规则的可信度，返回满足最小可信度的规则。 
75.         freqSet(frozenset):频繁项集 
76.         H(frozenset):频繁项集中所有的元素 
77.         supportData(dic):频繁项集中所有元素的支持度 
78.         brl(tuple):满足可信度条件的关联规则 
79.         minConf(float):最小可信度 
80.     '''  
81.     prunedH = []  
82.     for conseq in H:  
83.         conf = supportData[ freqSet ] / supportData[ freqSet - conseq ]  
84.         if conf >= minConf:  
85.             print(freqSet - conseq, '-->', conseq, 'conf:', conf)  
86.             brl.append( ( freqSet - conseq, conseq, conf ) )  
87.             prunedH.append( conseq )  
88.     return prunedH  
89.   
90. def rulesFromConseq( freqSet, H, supportData, brl, minConf=0.7 ):  
91.     ''''' 
92.         对频繁项集中元素超过2的项集进行合并。 
93.         freqSet(frozenset):频繁项集 
94.         H(frozenset):频繁项集中的所有元素，即可以出现在规则右部的元素 
95.         supportData(dict):所有项集的支持度信息 
96.         brl(tuple):生成的规则 
97.     '''  
98.     m = len( H[ 0 ] )  
99.     if len( freqSet ) > m + 1: # 查看频繁项集是否足够大，以到于移除大小为 m的子集，否则继续生成m+1大小的频繁项集  
100.         Hmp1 = aprioriGen( H, m + 1 )  
101.         Hmp1 = calcConf( freqSet, Hmp1, supportData, brl, minConf ) #对于新生成的m+1大小的频繁项集，计算新生成的关联规则的右则的集合  
102.         if len( Hmp1 ) > 1: # 如果不止一条规则满足要求（新生成的关联规则的右则的集合的大小大于1），进一步递归合并，  
103.                             #这样做的结果就是会有“[1|多]->多”(右边只会是“多”，因为合并的本质是频繁子项集变大，  
104.                             #而calcConf函数的关联结果的右侧就是频繁子项集）的关联结果  
105.             rulesFromConseq( freqSet, Hmp1, supportData, brl, minConf )  
106.   
107. def generateRules( L, supportData, minConf=0.7 ):  
108.     ''''' 
109.         根据频繁项集和最小可信度生成规则。 
110.         L(list):存储频繁项集 
111.         supportData(dict):存储着所有项集（不仅仅是频繁项集）的支持度 
112.         minConf(float):最小可信度 
113.     '''  
114.     bigRuleList = []  
115.     for i in range( 1, len( L ) ):  
116.         for freqSet in L[ i ]:                                                      # 对于每一个频繁项集的集合freqSet  
117.             H1 = [ frozenset( [ item ] ) for item in freqSet ]  
118.             if i > 1:# 如果频繁项集中的元素个数大于2，需要进一步合并，这样做的结果就是会有“[1|多]->多”(右边只会是“多”，  
119.                      #因为合并的本质是频繁子项集变大，而calcConf函数的关联结果的右侧就是频繁子项集），的关联结果  
120.                 rulesFromConseq( freqSet, H1, supportData, bigRuleList, minConf )  
121.             else:  
122.                 calcConf( freqSet, H1, supportData, bigRuleList, minConf )  
123.     return bigRuleList  
124. if __name__ == '__main__':  
125.     myDat = loadDataSet()                                   # 导入数据集  
126.     #C1 = createC1( myDat )                                  # 构建第一个候选项集列表C1  
127.     #D = map( set, myDat )                                   # 构建集合表示的数据集 D，python3中的写法，或者下面那种  
128.     #D=[var for var in map(set,myDat)]  
129.     #D=[set(var) for var in myDat] #D: [{1, 3, 4}, {2, 3, 5}, {1, 2, 3, 5}, {2, 5}]  
130.     #L, suppData = scanD( D, C1, 0.5 )                       # 选择出支持度不小于0.5 的项集作为频繁项集  
131.     #print(u"频繁项集L：", L)  
132.     #print(u"所有候选项集的支持度信息：", suppData)  
133.     #print("myDat",myDat)  
134.     L, suppData = apriori( myDat, 0.5 )                     # 选择频繁项集  
135.     print(u"频繁项集L：", L)  
136.     print(u"所有候选项集的支持度信息：", suppData)  
137.     rules = generateRules( L, suppData, minConf=0.7 )  
138.     print('rules:\n', rules)