py2.7《机器学习实战》使用Apriori算法进行关联分析

一、关联分析

关联分析的主要样例就是：啤酒->尿布。

一、

（1）频繁项集：经常出现在一起的物品的集合

（2）关联规则：两种物品之间有很强的联系

二、

（1）支持度：数据集中包含该项集的记录的所占比例，书中给出了：{豆奶}=4/5 ，所以豆奶的支持度为4/5； {豆奶，尿布} = 3/5 ， 所以后者为3/5；

（2）可信度/置信度 ： 是针对关联规则的一种操作，书中： {尿布}->{啤酒} ，Confidence = 支持度（{尿布，葡萄酒}）/支持度（{尿布}）。从图中可以得到他们各自的支持度，

相除得到0.75，这就意味着包含着“尿布”的所有记录，我们的规则对其中的75%都适用

二、适用Apriori算法发现频繁集

1.生成候选项集：

#-*- coding:utf-8 -*-
def loadData():
return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

def createC1(dataSet):
C1 = []
for transaction in dataSet: #遍历数据集，把一项元素提取出来
for item in transaction:
if not [item] in C1:
C1.append([item])
C1.sort()#所有候选项的集合
return map(frozenset,C1) #有序再做一次去重，并且冻结列表方便当做字典使用

def scanD(D,Ck,minSupport): #数据集，候选集列表Ck，最小支持度
ssCnt = {}#空字典
for tid in D: #遍历交易记录和候选集
for can in Ck:
if can.issubset(tid):#issubset:测试can中的每个元素是否都在交易记录中
# has_key：判断键是否在字典中，这里的键为key，就是指C1中的候选项
if not ssCnt.has_key(can):ssCnt[can] = 1 #不存在度计做1
else:ssCnt[can]+=1#如果存在度增加
numItems = float(len(D)) #总度数
retList = [] #满足最小支持度的加入retList
supportData = {}#频繁集的列表
for key in ssCnt: #计算支持度
support = ssCnt[key]/numItems #支持度 = 度/总数
if support >= minSupport:#如果满足，把该点加入
retList.insert(0,key)#这里是用了插入头部的方法，其实并不需要如此
supportData[key] = support
return retList,supportData

运行代码：

#-*- coding:utf-8 -*-
import apriori
dataSet = apriori.loadData()
print dataSet #输出数据集
C1 = apriori.createC1(dataSet) #构建候选项集合
print "Ck的值为" , C1 #查看候选项集
D = map(set,dataSet)#构建集合表示的数据集D
print "数据集列表为 " , D
L1,suppData0 = apriori.scanD(D,C1,0.5) #这里假设0.5为最小支持度水平
print L1 #满足最小支持度的列表
print suppData0 #查看数据集的频繁度

效果：

[[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
Ck的值为 [frozenset([1]), frozenset([2]), frozenset([3]), frozenset([4]), frozenset([5])]
数据集列表为  [set([1, 3, 4]), set([2, 3, 5]), set([1, 2, 3, 5]), set([2, 5])]
[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
{frozenset([4]): 0.25, frozenset([5]): 0.75, frozenset([2]): 0.75, frozenset([3]): 0.75, frozenset([1]): 0.5}

2.组织完整的apriori算法

def aprioriGen(Lk,k): #构建一个由k个项组成的候选集列表
retList = []
lenLK = len(Lk)#Lk元素数目
for i in range(lenLK):
for j in range(i+1,lenLK):#比较Lk里的每个元素和其他元素
L1 = list(Lk[i])[:k-2];L2=list(Lk[j])[:k-2]
if L1==L2 : #如果两个集合前面k-2个元素都相等，那么合成为一个大小为k的集合
retList.append(Lk[i]|Lk[j]) #并集
return retList

def apriori(dataSet,minSupport=0.5):
C1 = createC1(dataSet)
D = map(set,dataSet)
L1,supportData = scanD(D,C1,minSupport)
L = [L1]
k = 2
while(len(L[k-2])>0):
Ck = aprioriGen(L[k-2],k)
Lk,supK = scanD(D,Ck,minSupport) #基于CK创建LK，相当于不断添加元素，不要的扔掉
supportData.update(supK)
L.append(Lk)
k+=1
return L,supportData

测试：

#-*- coding:utf-8 -*-
import apriori
dataSet = apriori.loadData()
L,suppData = apriori.apriori(dataSet)
print L #L包含最小支持度为0.5的频繁项集列表

3.关联规则生成函数

#生成候选规则集合和对规则集合进行评估
def generateRules(L,supportData,minConf=0.7): #频繁项集列表，包含频繁项集支持数据的字典，最小可信度阈值
bigRuleList = [] #将满足的规则可信度列表存入列表
#另外两个参数是apriori的输出
for i in range(1,len(L)):
for freqSet in L[i]:#遍历L中的每一个频繁项集，创建只含有一个元素集合的H1列表，
H1 = [frozenset([item]) for item in freqSet]
#{0,1,2} ---> H1= [{0},{1},{2}]
if (i>1):#频繁集项大于2，合并，
rulesFromConseq(freqSet,H1,supportData,bigRuleList,minConf)
else:#如果只有2项就直接计算
calcConf(freqSet,H1,supportData,bigRuleList,minConf)
return bigRuleList

def calcConf(freqSet,H,supportData,brl,minConf = 0.7):
prunedH = []
for conseq in H :
conf = supportData[freqSet]/supportData[freqSet-conseq]
if conf >= minConf:
print freqSet-conseq,'---->',conseq,'conf:',conf
brl.append((freqSet,conseq,conf))
prunedH.append((conseq))
return prunedH

def rulesFromConseq(freqSet,H,supportData,brl,minConf):
m = len(H[0])
if (len(freqSet)>(m+1)):
Hmp1 = aprioriGen(H,m+1)
Hmp1 = calcConf(freqSet,Hmp1,supportData,brl,minConf)
if (len(Hmp1)>1):
rulesFromConseq(freqSet,Hmp1,supportData,brl,minConf)