apriori和关联规则算法

问题的背景：

超市的会员卡记录了大量的用户购买数据，通过分析这些数据可以帮助商店分析用户的购买行为。从大规模数据集中寻找物品间的隐含关系被称为关联规则分析（association analysis）或关联规则学习（association rule learning）。举个例子说就是发现用户购买了一件商品（如帽子）后，会购买另一件商品（如围巾）的概率。关联规则分析需要从大规模的商品数据中，发现和统计各种商品的组合（频繁项集发现）是一个非常费时费力的事情，这个也是关联规则分析的主要问题。为了解决这个问题提出了apriori算法，也叫先验算法。

1993年,R.Agrawal等人首次提出了挖掘顾客交易数据中项目集间的关联规则问题，其核心是基于两阶段频繁集思想的递推算法。该关联规则在分类上属于单维、单层及布尔关联规则，典型的算法是Aprior算法。

Aprior算法将发现关联规则的过程分为两个步骤：第一步通过迭代，检索出事务数据库中的所有频繁项集，即支持度不低于用户设定的阈值的项集；第二步利用频繁项集构造出满足用户最小信任度的规则。其中，挖掘或识别出所有频繁项集是该算法的核心，占整个计算量的大部分。

问题定义：

关联规则分析是为了在大规模数据集中寻找有趣关系的任务。这些关系分为两种，频繁项集和关联规则。

频繁项集（frequent item sets）是经常出现在一块的物品的集合，关联规则（association rules）暗示两种物品之间可能存在很强的关系。

apriori算法就是为了发现频繁项集。频繁项集发现后再进行关联规则分析，需要用到条件概型。

需要思考的问题：

1、频繁项集，频繁如何定义，也就是说怎样才算频繁？

2、应该如何去定义商品间的购买关系，也就是凭什么说他们存在某个关系？

3、如何去过滤掉一些不需要的商品关系，筛选出想要的商品关系？

第一个问题会在讲apriori算法原理的时候解决。

第二个问题需要用到条件概型

，其中P(AB)是A商品和B商品同时出现的概率，P(B)是B商品出现的概率，P(A|B)是在B商品出现的情况下出现A商品的概率。在关联规则分析中，我们将P(AB)称为A和B同时出现的的支持度，P(B)称为B出现的支持度。P(A|B)指定是购买B再购买A的可信度。

apriori原理：

如下图对于{0,1,2,3}的组合如下共有15种，即2的N次方减1种，其中N为商品种数。因此计算所有组合的次数时间复杂度是很大的。

如何降低复杂度呢？

研究人员发现了一种所谓的Apriori原理，如果某个项集是频繁的，那么它的所有子集也是频繁的。逆否命题是，如果某个项集不是频繁的，那么包含这个项集的项集也不是频繁的。这个原理可作为减枝的依据，例如{0}不是频繁的，那么包含0的所有项集都不是频繁的，包含0的项集出现次数就不用统计了。

第一个问题的解决方法：

频繁项集的频繁是自定义的，根据实验场景定义一个次数，低于这个次数的项集就可以减枝减掉。

算法图例说明

为了便于计算，下面的支持度用项集出现次数来代替。

假设有一个数据库D，其中有4个事务记录，分别表示为：

TID Items

T1 I1,I3,I4

T2 I2,I3,I5

T3 I1,I2,I3,I5

T4 I2,I5

TID	Items
T1	I1,I3,I4
T2	I2,I3,I5
T3	I1,I2,I3,I5
T4	I2,I5

这里预定最小支持度minSupport=2,下面用图例说明算法运行的过程：

TID Items

T1 I1,I3,I4

T2 I2,I3,I5

T3 I1,I2,I3,I5

T4 I2,I5

TID	Items
T1	I1,I3,I4
T2	I2,I3,I5
T3	I1,I2,I3,I5
T4	I2,I5

扫描D，对每个候选项进行支持度计数得到表C1:

项集支持度计数

{I1} 2

{I2} 3

{I3} 3

{I4} 1

{I5} 3

项集	支持度计数
{I1}	2
{I2}	3
{I3}	3
{I4}	1
{I5}	3

比较候选项支持度计数与最小支持度minSupport，产生1维最大项目集L1：

项集支持度计数

{I1} 2

{I2} 3

{I3} 3

{I5} 3

项集	支持度计数
{I1}	2
{I2}	3
{I3}	3
{I5}	3

由L1产生候选项集C2：

项集

{I1,I2}

{I1,I3}

{I1,I5}

{I2,I3}

{I2,I5}

{I3,I5}

项集
{I1,I2}
{I1,I3}
{I1,I5}
{I2,I3}
{I2,I5}
{I3,I5}

扫描D，对每个候选项集进行支持度计数:

项集支持度计数

{I1,I2} 1

{I1,I3} 2

{I1,I5} 1

{I2,I3} 2

{I2,I5} 3

{I3,I5} 2

项集	支持度计数
{I1,I2}	1
{I1,I3}	2
{I1,I5}	1
{I2,I3}	2
{I2,I5}	3
{I3,I5}	2

比较候选项支持度计数与最小支持度minSupport，产生2维最大项目集L2：

项集支持度计数

{I1,I3} 2

{I2,I3} 2

{I2,I5} 3

{I3,I5} 2

项集	支持度计数
{I1,I3}	2
{I2,I3}	2
{I2,I5}	3
{I3,I5}	2

由L2产生候选项集C3：

项集

{I2,I3,I5}

项集
{I2,I3,I5}

扫描D，对每个候选项集进行支持度计数:

项集支持度计数

{I2,I3,I5} 2

项集	支持度计数
{I2,I3,I5}	2

比较候选项支持度计数与最小支持度minSupport，产生3维最大项目集L3：

项集支持度计数

{I2,I3,I5} 2

项集	支持度计数
{I2,I3,I5}	2

算法终止。

从频繁项中挖掘关联规则：

关联规则挖掘也可以进行减枝，例如012->3，可信度可用如下公式计算为，

对于以012->3为根节点的所有节点，例如03->12，可信度可用如下公式计算为

观察发现分子是一样的，分母由于子节点是父节点的子集，所以对应的概率更大，上面的例子P(12) >= P(012)。

所以可以得出如果某条规则不满足最小可信度，那么该规则的所有子集也不会满足最小可信度要求。

在ipython和python3.4环境下进行的实验，代码如下：

例子数据

def loadDataSet():return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
def loadDataSet2():return [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]]

"""
创建集合大小为1的项集
"""
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)#use frozen set so we#can use it as a key in a dict
"""
计算指定项集的支持度
D是数据集合，Ck是要求支持度的项集，minSupport是最小支持度
"""
def scanD(D, Ck, minSupport):ssCnt = {}for tid in D:for can in Ck:if can.issubset(tid):if not ssCnt.get(can): ssCnt[can]=1else: ssCnt[can] += 1numItems = float(len(D))retList = []supportData = {}for key in ssCnt:support = ssCnt[key]/numItemsif support >= minSupport:retList.insert(0,key)supportData[key] = supportreturn retList, supportData
"""
生成集合大小比原来的大一的项集
"""
def aprioriGen(Lk, k): #creates CkretList = []lenLk = len(Lk)# 如果Lk只有一项，则retList为[]for i in range(lenLk):for j in range(i+1, lenLk):# 为了每次添加的都是单个项构成的集合，所以Lk中项的大小是k-1，那么前k-2项相同，才能使合并后只比原来多一项。L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]L1.sort(); L2.sort()if L1==L2: #if first k-2 elements are equalretList.append(Lk[i] | Lk[j]) #set unionreturn retList
"""
求出数据集合中，支持度大于最小支持度的所有项集
"""
def apriori(dataSet, minSupport = 0.5):C1 = createC1(dataSet)# 转化为list类型重要C1 = list(C1)D = map(set, dataSet)# 转化为list类型重要D = list(D)
#     print(D)
#     print(C1)L1, supportData = scanD(D, C1, minSupport)
#     print(L1)L = [L1]k = 2while (len(L[k-2]) > 0):Ck = aprioriGen(L[k-2], k)Lk, supK = scanD(D, Ck, minSupport)#scan DB to get LksupportData.update(supK)L.append(Lk)k += 1return L, supportData
"""
计算 freqSet-conseq -> conseq 的可信度， conseq是H中的元素
"""
def calcConf(freqSet, H, supportData, brl, minConf=0.7):prunedH = [] #create new list to returnfor conseq in H:conf = supportData[freqSet]/supportData[freqSet-conseq] #calc confidenceif conf >= minConf: print(freqSet-conseq,'-->',conseq,'conf:',conf)brl.append((freqSet-conseq, conseq, conf))prunedH.append(conseq)return prunedH
"""
# 1个元素的集合 -> (len(freqSet) - 1) 元素的集合
# 2个元素的集合 -> (len(freqSet) - 2) 元素的集合
# ...
"""
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):print("H:", H)m = len(H[0])if (len(freqSet) > (m + 1)): #try further mergingHmp1 = aprioriGen(H, m+1)#create Hm+1 new candidates
#         print("Hmp1:",Hmp1)Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
#         print("Hmp1:",Hmp1)if (len(Hmp1) > 1):    #need at least two sets to mergerulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
"""
两个元素的集合求关联规则
三个元素的集合求关联规则
...
"""
def generateRules(L, supportData, minConf=0.7):  #supportData is a dict coming from scanDbigRuleList = []for i in range(1, len(L)):#only get the sets with two or more itemsprint(L[i])for freqSet in L[i]:H1 = [frozenset([item]) for item in freqSet]print(H1)if (i > 1):rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)else:calcConf(freqSet, H1, supportData, bigRuleList, minConf)return bigRuleList

进行apriori算法项集为1的测试，如果可行再应用到递推中

# 加载数据
dataSet=loadDataSet()
dataSet

# 获取集合大小为1的所有项集
C1=createC1(dataSet)
# print(len(C1))
# TypeError: object of type 'map' has no len()
C1 = list(C1)
C1

# 将数据类型转换为集合
D=map(set, dataSet)
# print(len(D))
D = list(D)
D

# 求集合大小为1的项集的支持度，返回留下支持度大于最小支持度的项集和它们的支持度
L1, suppData0 = scanD(D, C1, 0.5)
print(L1)
print(suppData0)

测试priori算法

L1, suppData0 = apriori(dataSet)
print(L1)
print()
print(suppData0)

L1, suppData0 = apriori(dataSet, minSupport=0.7)
print(L1)
print()
print(suppData0)

测试关联规则

L, suppData = apriori(dataSet, minSupport=0.5)
print(L)
print()
print(suppData)

rules = generateRules(L, suppData, minConf=0.7)

rules = generateRules(L, suppData, minConf=0.5)
rules

缺点：

每次增加频繁项集的大小，Apriori算法都会重新扫描整个数据集合。

当数据集很大时，这会显著降低频繁项集的发现速度。

参考自：

https://zh.wikipedia.org/wiki/%E5%85%88%E9%AA%8C%E7%AE%97%E6%B3%95

《机器学习实战》

apriori和关联规则算法相关推荐

Python --深入浅出Apriori关联分析算法（二） Apriori关联规则实战
上一篇我们讲了关联分析的几个概念,支持度,置信度,提升度.以及如何利用Apriori算法高效地根据物品的支持度找出所有物品的频繁项集. Python --深入浅出Apriori关联分析算法(一) 这次 ...
sparkmllib关联规则算法（FPGrowth,Apriori）
关联规则算法的思想就是找频繁项集,通过频繁项集找强关联. 介绍下基本概念: 对于A->B 1.置信度:P(B|A),在A发生的事件中同时发生B的概率 p(AB)/P(A) 例如购物篮分析:牛奶 ...
python实现关联算法_关联规则算法Apriori学习及Python实现
关联规则算法Apriori以及FP-growth学习最近选择了关联规则算法进行学习,目标是先学习Apriori算法,再转FP-growth算法,因为Spark-mllib库支持的关联算法是FP,随笔 ...
关联规则算法——Apriori算法
1.关联规则的名词解释项集:数据库中的数据项构成的非空集合事务:一个事务包含了一个或多个项集支持度:包含项集x的事务数量与全部事务数量的百分比置信度:同时包含数据项x和数据项y的事务数量与事务 ...
利用python实现Apriori关联规则算法
关联规则大家可能听说过用于宣传数据挖掘的一个案例:啤酒和尿布:据说是沃尔玛超市在分析顾客的购买记录时,发现许多客户购买啤酒的同时也会购买婴儿尿布,于是超市调整了啤酒和尿布的货架摆放,让这两个品类摆放 ...
python实现关联算法_python实现关联规则算法Apriori代码示例
本篇文章小编给大家分享一下python实现关联规则算法Apriori代码示例,文章代码介绍的很详细,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看. 首先导入包含apriori ...
数据挖掘笔记(5)-关联规则算法Apriori
1.关联规则概念如果去超市买东西,我们会发现购买了牛奶的客户很可能会去购买面包,那么"牛奶=>面包"就称之为关联规则,其中牛奶是前项,面包是后项,它们都是项集(单项集). ...
使用Apriori关联规则算法实现购物篮分析
Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集,而且算法已经被广泛的应用到商业,网络安全等各个领域. 购物篮分析是通过发视频顾 ...
python 关联规则包,python 实现关联规则算法Apriori的示例
首先导入包含apriori算法的mlxtend库, pip install mlxtend 调用apriori进行关联规则分析,具体代码如下,其中数据集选取本博客 "机器学习算法--关联规则 ...

apriori和关联规则算法

算法图例说明

apriori和关联规则算法相关推荐

最新文章

热门文章