前言：
“啤酒与尿布”的例子相信很多人都听说过吧，故事是这样的：在一家超市中，人们发现了一个特别有趣的现象，尿布与啤酒这两种风马牛不相及的商品居然摆在一起。但这一奇怪的举措居然使尿布和啤酒的销量大幅增加了。这可不是一个笑话，而是一直被商家所津津乐道的发生在美国沃尔玛连锁超市的真实案例。原来，美国的妇女通常在家照顾孩子，所以她们经常会嘱咐丈夫在下班回家的路上为孩子买尿布，而丈夫在买尿布的同时又会顺手购买自己爱喝的啤酒。这个发现为商家带来了大量的利润，但是如何从浩如烟海却又杂乱无章的数据中，发现啤酒和尿布销售之间的联系呢?这种从大规模的数据中发现物品间隐含关系的方法被称为关联分析，也就是本文要主要研究的一种常用的分析方法，Apriori算法是最著名的关联规则挖掘算法之一。
一、关联分析
关联分析是一种在大规模数据集中寻找有趣关系的任务。这些任务有两种形式：频繁项集和关联规则。频繁项集是经常出现在一块的物品的集合；关联规则暗示的是两种物品之间可能存在很强的关系。可以结合某家店的交易清单来说明这两个概念：
频繁项集指的就是那些经常一起出现的物品集合，比如{啤酒，尿布，饼干}就是频繁项集中的一个例子，而根据上表也可以找到尿布->啤酒这样的关联规则。
而我们是要通过关联分析大规模数据从而发现数据之间存在的有趣关系，那么问题来了，什么样的关系是有趣的呢？而这个有趣又是怎么定义的呢？我们可以通过支持度（support）和可信度（置信度confidence）来定义。一个项集的支持度指的是数据集中包含该项集记录所占的比例，上例中{豆奶}的支持度是2/5,{啤酒，尿布}的支持度是3/5；可信度是针对于像{尿布}->{啤酒}这样的关联规则来定义的，定义为：支持度({尿布，葡萄酒})/支持度（尿布）。
二、Apriori算法原理
上述我们通过支持度和可信度来定义发现数据之间存在的关系。我们知道，在商品列表中，可能存在单一商品组成的频繁项集，当然也存在两个以及两个以上的商品组成的频繁项集。而在计算一个频繁项集的支持度时，通常需要遍历所有的商品列表求得，对于列表数目较少的情况该方法无疑是没问题的，但当列表数目成千上万时，计算量过大，这种方法势必是不适用的。
那么如何解决上述问题呢，Apriori原理可以解决！Apriori原理是说如果某个项集是频繁的，那么它的所有子集势必也是频繁的。这个原理从表面上看没什么大用，但是反过来，如果一个项集是非频繁项集，那么它所对应的超集就全都是非频繁项集。这样在确定了一个项集是非频繁项集了之后，它所对应的超集的支持度我们就可以不去计算了，这在很大程度上避免了项集数目的指数增长，可以更加合理的计算频繁项集。
三、Apriori算法思想
对于Apriori算法，我们使用支持度来作为我们判断频繁项集的标准。Apriori算法的目标是找到最大的K项频繁集。这里有两层意思，首先，我们要找到符合支持度标准的频繁集。但是这样的频繁集可能有很多。第二层意思就是我们要找到最大个数的频繁集。比如我们找到符合支持度的频繁集AB和ABE，那么我们会抛弃AB，只保留ABE，因为AB是2项频繁集，而ABE是3项频繁集。那么具体的，Apriori算法是如何做到挖掘K项频繁集的呢？
Apriori算法采用了迭代的方法，先搜索出候选1项集及对应的支持度，剪枝去掉低于支持度的1项集，得到频繁1项集。然后对剩下的频繁1项集进行连接，得到候选的频繁2项集，筛选去掉低于支持度的候选频繁2项集，得到真正的频繁二项集，以此类推，迭代下去，直到无法找到频繁k+1项集为止，对应的频繁k项集的集合即为算法的输出结果。
可见这个算法还是很简洁的，第i次的迭代过程包括扫描计算候选频繁i项集的支持度，剪枝得到真正频繁i项集和连接生成候选频繁i+1项集三步。
我们下面这个简单的例子看看：
我们的数据集D有4条记录，分别是134,235,1235和25。现在我们用Apriori算法来寻找频繁k项集，最小支持度设置为50%。首先我们生成候选频繁1项集，包括我们所有的5个数据并计算5个数据的支持度，计算完毕后我们进行剪枝，数据4由于支持度只有25%被剪掉。我们最终的频繁1项集为1235，现在我们链接生成候选频繁2项集，包括12,13,15,23,25,35共6组。此时我们的第一轮迭代结束。
进入第二轮迭代，我们扫描数据集计算候选频繁2项集的支持度，接着进行剪枝，由于12和15的支持度只有25%而被筛除，得到真正的频繁2项集，包括13,23,25,35。现在我们链接生成候选频繁3项集,123, 125，135和235共4组，这部分图中没有画出。通过计算候选频繁3项集的支持度，我们发现123,125和135的支持度均为25%，因此接着被剪枝，最终得到的真正频繁3项集为235一组。由于此时我们无法再进行数据连接，进而得到候选频繁4项集，最终的结果即为频繁3三项集235。
四、Apriori算法的实现
参照《机器学习实战》
# -*- coding:utf8 -*-
# import numpy
def loadDataSet():
"""创建一个用于测试的简单的数据集"""
return [[1,3,4,5],[2,3,5,],[1,2,3,4,5],[2,3,4,5]]
def createC1(dataSet):
"""
构建初始候选集的列表，即所有候选集只包含一个元素
C1是大小为1的所有候选集的集合
:param dataSet:
:return:
"""
C1 = []
for transaction in dataSet:
for item in transaction:
if [item] not in C1:
C1.append([item])
C1.sort()
return map(frozenset, C1)
# return [frozenset(var) for var in C1]
def scanD(D, Ck, minSupport):
'''
计算Ck中的项集在数据集合D(记录或者transactions)中的支持度,
返回满足最小支持度的项集的集合，和所有项集支持度信息的字典。
'''
ssCnt = {}
for tid in D: # 对于每一条transaction
for can in Ck: # 对于每一个候选项集can，检查是否是transaction的一部分, 即该候选can是否得到transaction的支持
if can.issubset(tid):
# if not ssCnt.has_key(can): ssCnt[can] += 1
# else : ssCnt[can] += 1
ssCnt[can] = ssCnt.get(can, 0) + 1
numItems = float(len(D))
retList = []
supportData = {}
for key in ssCnt:
support = ssCnt[key] / numItems # 每个项集的支持度
if support >= minSupport: # 将满足最小支持度的项集，加入retList
retList.insert(0, key)
supportData[key] = support # 汇总支持度数据
return retList, supportData
def aprioriGen(Lk, k): # Aprior算法
'''
由初始候选项集的集合Lk生成新的生成候选项集，
k表示生成的新项集中所含有的元素个数；例如：该函数以{0}、{1}、{2}作为输入，会生成{0,1}、{0,2}以及{1,2}
'''
retList = []
lenLk = len(Lk)
for i in range(lenLk):
for j in range(i + 1, lenLk):
L1 = list(Lk[i])[: k - 2];
L2 = list(Lk[j])[: k - 2];
L1.sort();
L2.sort()
if L1 == L2: # 前k-2个元素相同时，将两个集合合并
retList.append(Lk[i] | Lk[j])
return retList
def apriori(dataSet, minSupport=0.5): # dataSet为传入的数据集，minSupport为最小支持度
C1 = createC1(dataSet) # 构建初始候选项集C1
# D = map( set, dataSet ) # 将dataSet集合化，以满足scanD的格式要求
# D=[var for var in map(set,dataSet)]
D = [set(var) for var in dataSet]
L1, suppData = scanD(D, C1, minSupport) # 构建初始的频繁项集，即所有项集只有一个元素
L = [L1] # 最初的L1中的每个项集含有一个元素，新生成的
k = 2 # 项集应该含有2个元素，所以 k=2
while (len(L[k - 2]) > 0):
Ck = aprioriGen(L[k - 2], k)
Lk, supK = scanD(D, Ck, minSupport)
suppData.update(supK) # 将新的项集的支持度数据加入原来的总支持度字典中
L.append(Lk) # 将符合最小支持度要求的项集加入L
k += 1 # 新生成的项集中的元素个数应不断增加
return L, suppData # 返回所有满足条件的频繁项集的列表，和所有候选项集的支持度信息
def calcConf(freqSet, H, supportData, brl, minConf=0.7): # 规则生成与评价
'''
计算规则的可信度，返回满足最小可信度的规则。
freqSet(frozenset):频繁项集
H(frozenset):频繁项集中所有的元素
supportData(dic):频繁项集中所有元素的支持度
brl(tuple):满足可信度条件的关联规则
minConf(float):最小可信度
'''
prunedH = []
for conseq in H:
conf = supportData[freqSet] / supportData[freqSet - conseq]
if conf >= minConf:
print(freqSet - conseq, '-->', conseq, 'conf:', conf)
brl.append((freqSet - conseq, conseq, conf))
prunedH.append(conseq)
return prunedH
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
'''
对频繁项集中元素超过2的项集进行合并。
freqSet(frozenset):频繁项集
H(frozenset):频繁项集中的所有元素，即可以出现在规则右部的元素
supportData(dict):所有项集的支持度信息
brl(tuple):生成的规则
'''
m = len(H[0])
if len(freqSet) > m + 1: # 查看频繁项集是否足够大，以到于移除大小为 m的子集，否则继续生成m+1大小的频繁项集
Hmp1 = aprioriGen(H, m + 1)
Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf) # 对于新生成的m+1大小的频繁项集，计算新生成的关联规则的右则的集合
if len(Hmp1) > 1: # 如果不止一条规则满足要求（新生成的关联规则的右则的集合的大小大于1），进一步递归合并，
# 这样做的结果就是会有“[1|多]->多”(右边只会是“多”，因为合并的本质是频繁子项集变大，
# 而calcConf函数的关联结果的右侧就是频繁子项集）的关联结果
rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
def generateRules(L, supportData, minConf=0.7):
'''
根据频繁项集和最小可信度生成规则。
L(list):存储频繁项集
supportData(dict):存储着所有项集（不仅仅是频繁项集）的支持度
minConf(float):最小可信度
'''
bigRuleList = []
for i in range(1, len(L)):
for freqSet in L[i]: # 对于每一个频繁项集的集合freqSet
H1 = [frozenset([item]) for item in freqSet]
if i > 1: # 如果频繁项集中的元素个数大于2，需要进一步合并，这样做的结果就是会有“[1|多]->多”(右边只会是“多”，
# 因为合并的本质是频繁子项集变大，而calcConf函数的关联结果的右侧就是频繁子项集），的关联结果
rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
else:
calcConf(freqSet, H1, supportData, bigRuleList, minConf)
return bigRuleList
if __name__ == '__main__':
myDat = loadDataSet() # 导入数据集
print(myDat)
C1 = createC1( myDat ) # 构建第一个候选项集列表C1
print(C1)
D = map( set, myDat ) # 构建集合表示的数据集 D，python3中的写法，或者下面那种
# print(D)
# D=[var for var in map(set,myDat)]
# D=[set(var) for var in myDat] #D: [{1, 3, 4}, {2, 3, 5}, {1, 2, 3, 5}, {2, 5}]
L1, suppData = scanD( D, C1, 0.5 ) # 选择出支持度不小于0.5 的项集作为频繁项集
print(u"频繁项集L1：", L1)
print(u"所有候选项集的支持度信息：", suppData)
print("myDat",myDat)
L, suppData = apriori(myDat, 0.5) # 选择频繁项集
print(u"频繁项集L：", L)
print(u"所有候选项集的支持度信息：", suppData)
rules = generateRules(L, suppData, minConf=0.5)
print('rules:\n', rules)
参考书籍：机器学习实战，第11章，利用Apriori算法进行关联分析
参考博客：
【机器学习实战-python3】使用Apriori算法进行关联 分析