您现在的位置是：首页 > 技术教程正文

【商业挖掘】关联规则——Apriori算法(最全~)

admin 阅读： 2024-03-23

后台-插件-广告管理-内容页头部广告（手机）

一、关联规则挖掘

1. 定义：参考百度百科即可：

“假设是项的集合。给定一个交易数据库D，其中每个事务(Transaction)t是I的非空子集，即，每一个交易都与一个唯一的标识符TID(Transaction ID)对应。关联规则在D中的支持度(support)是D中事务同时包含X、Y的百分比，即概率；置信度(confidence)是D中事务已经包含X的情况下，包含Y的百分比，即条件概率。如果满足最小支持度阈值和最小置信度阈值，则认为关联规则是有趣的。这些阈值是根据挖掘需要人为设定。” ——引用百度百科词条解释

百度百科或者一些教材说的太专业了反而很难理解，不妨看下面的个人观点大白话解释：

关联规则提出的背景是购物篮分析，A顾客会买零食、面包、牛奶，不同客户会有不同的消费，那每一个顾客的消费集合就构成了一个事务（消费-支付事务），那这个事务集就上上面说的“唯一标识符TID”；那问题是，每种商品被不同顾客购买了多少次呢？那么这个次数就是“支持频数”，那被所有顾客购买的概率就是“支持度Sup”；那问题又来了，X商品和Y商品之间的被购买关系是怎样的呢？比如消费者买了面包，还可能会买面包伴侣（牛奶等），那面包和牛奶就构成了关联，那这个关联的置信度又是多少呢？就是消费者买了面包，再去买牛奶的概率是多少呢？反之亦言。那这个条件概率，就是上面提到的置信度。

2. 作用：可以揭示数据集的内在的、重要的特性。是很多重要数据挖掘任务的基础关联、相关和因果分析的基本方式。在序列、结构（e.g.子图）模式分析；时空、多媒体、时序和流数据中的模式分析；分类：关联分类；聚类分析：基于频繁模式的聚类；数据仓库：冰山方体计算等各类数据挖掘工作中发挥着基础性作用。

        说的又很奇奇怪怪的，关联规则的挖掘到底有什么用？还是可以回到上面的购物篮分析，比如啊，我们分析了面包和牛奶的关联规则之后，如果满足支持度、置信度要求，那么我们就可以把这两个商品放在一块儿（可能会增加购买），或者在做Promotion打造时可以辅助策略制定等等。事实上，从商业视角来说，他就是对People、Place、Promotion、Price策略制定的综合考量因子（4ps战略）。
        在和复旦大佬学长交流之后，他提到了异常检测，虽然我也不太明白什么道理。但是结合财会视角来看，这个关联规则或许还能够对企业行为进行监测。

        那对于网页开发来说，点击哪些模块儿？链接？先后顺序？等都是可以考量的点。

———“个人角度，如果有错误请予以斧正！！！”

3. 挖掘的步骤：①找出频繁项集；②由频繁项集，找出满足minsup和minconfi的关联规则。

如果一个Goodlist由100个商品，如果想要遍历循环，那得到的频繁项集有2^100-1个

↓
引出Apriori算法

二、Apriori-关联规则算法

Apriori算法利用频繁项集性质的先验知识（prior knowledge），通过逐层搜索的迭代方法，即将k-项集用于探察(k+1)-项集，来穷尽数据集中的所有频繁项集。

步骤：先找到频繁1-项集集合L1,然后用L1找到频繁2-项集集合L2，接着用L2找L3，直到找不到频繁k-项集，找每个Lk需要一次数据库扫描。最后得到所有满足最小支持的频繁项集合，再进行关联规则输出。

关于Apriori的解释，CSDN中有非常多的前辈给出了自己非常完备的解释，对其优缺点也进行了深入剖析，我在这里就不做过多解释，向大家推我认为非常非常好的三篇文章链接：

这一篇生动有趣，适合年轻人来看！（点击本文字即可）

这一篇有博主手写的解释！适合小白理解Apriori的步骤！

这一篇也不错噢！

三、Apriori算法分解—Python大白话式实现

我看了CSDN中很多博主分享的代码，发现很多博主代码趋同（可能复制粘贴），或者直接调用的外部开源的库来实现的，还有的博主自己撰写的，但是用了很多可能不懂的函数来做的，甚至还有的就直接在一个函数里面嵌套多个函数来传递参数实现，读起来感觉，对小白非常不友好。

那在这里，我就分享一些很简单的代码来实现。包括数据导入、数据处理、调用、关联规则挖掘等完整的分析流程。我看了一下这个应该是全站流程最全面的代码了。

——当然简单就意味着代码很长，有些地方处理的比较粗糙

步骤1：外部库调用❀

只用到了 pandas itertools 和自带的time

import pandas as pd #数据导入用
import itertools as it #子集生成用
import time #输出程序员运行时间用

步骤2：数据导入❀

因为是全函数编写，最终的数据导入在代码最后，所以直接拿出来看

if __name__ == '__main__':
# 数据导入
data = pd.read_excel("D:\OneDrive\桌面\测试数据.xlsx", index_col=0, header=0)
data = data.applymap(lambda x: str(x).strip()) # 删除导入时可能存在的空格值，比如：“面包”成了“ 面包”
# 数据格式转换
data = data.values # 改为元组型数据，便于list输出
data = data.tolist() # 输出为客户*商品集合
# 设定支持度和置信度
minsup,minconfi=map(eval,input("请输入支持度和置信度：").split(" "))
start = time.time()
Find_rule_apriori(data,minsup,minconfi)
end=time.time()
print('Running time: {0} Seconds'.format(end - start))

步骤3：数据处理❀

很多博主在数据导入阶段说明不清，不知道最终的导入格式，这里我把测试数据截图放出来仅供大家参考，助于后续程序的理解：

那在Panda导入中会出现一个问题就是，空白格会被默认为None值，输出出来就是“non”：

那么为了处理“nan”值，而常规的pandas的其他功能应该是不能直接删去的，多数还是填充。因此我编写了以下“白话for循环”的Non_deal()函数:

def Non_deal(df):
list_data = []
rows = len(df)
for i in range(0,rows):
list = df[i]
list_con = []
cols = len(list)
for j in range(0,cols):
if list[j]!="nan":
list_con.append(list[j])
#如果用remove法需要倒序去除，否则无法去除干净（因为每一次去除会导致len-1）
list_data.append(list_con)
return list_data

输出结果为: 可以看到non值都被删去了。注意remove的使用，我这里处理比较粗糙，为了用Append多加了一个中间列表List_con，虽然用remove会更快。

步骤4：输出所有Goodlist❀

事实上也就是备选频繁1项集，这个函数不太重要，后续调用也完全可以替代别的方式，编写的目的是我思考时的便利逻辑过程的一种方式而已。

#目的是得到备选1-项集
def Good_list(df): #将单个商品集合出来
list_all=[]
list_in=Non_deal(df)
for i in range(0,len(list_in)):
for j in range(0,len(list_in[i])):
list_m=[]
list_m.append(str(list_in[i][j]))
list_all.append(str(list_m))
list_all=list(set(list_all))
for i in range(0,len(list_all)):
list_all[i]=eval(list_all[i])
return list_all

步骤5：项集重组❀

因为Apriori是通过满足支持度阈值的频繁k项集得到备选频繁k+1项集合，因此这一个函数的目的便是进行项集重组，升阶化的过程。注意，这个不是放在最前面的逻辑，而是预先编写。为了后面直接调用的准备工作。可以发现也都是for循环，连while等等都不带的。由于我们导入数据就选择的是列表格式，因此我们后续工作也就都利用list来完成，那么list就需要一直for循环调用，不像dict中直接for item in dict等等方便清晰，前面也说了，细节处理还是较粗糙。

#目的是进行k-1-频繁项集合的重组为k项目集合
def creat_connect(list_c,n): ##实现集合内的重组，例如2-项集合重组为3-项集
new_list=[]
for i in range(0,len(list_c)):
list_a = []
for j in range(i+1,len(list_c)):
list_b = list_c[i]
list_d = []
for k in range(0,n):
list_d.append(list_c[j][k])
list_a = list_b+list_d
list_a=list(set(list_a))
list_a.sort()
new_list.append(str(list_a))
new_list=list(set(new_list))
New_list=[]
for i in range(0,len(new_list)):
new_list[i]=eval(new_list[i])
new_list[i].sort()
if len(new_list[i])==n+1:
New_list.append(new_list[i])
return New_list

步骤6：支持度扫描与输出 ❀

这里就回归了逻辑线条，这里提供两种方法，一种是输出counts一种是输出rates，即支持频数和支持度的两种衡量办法，这里仅供大家挑选，两个函数没什么区别。本find_rule函数用的是counts函数，如果要换记得调整为rates。

#输出每个k-项频繁集的候选集的比率
def sup_rate(df,data):
m = len(data) # 事务总数
item_set_list = []
for i in range(0,len(df)):
n=0
list_n=[]
for j in range(0,len(data)):
if (set(df[i]) <= set(data[j]))==True:
n+=1
list_n.append(df[i])
list_n.append(round(n/m,2))
item_set_list.append(list_n)
return item_set_list
#输出每个k-项频繁集的候选集的个数，上有比率写法，两者无本质区别，都可以使用
def sup_counts(df,data): #输出每个1-项频繁集的候选集的次数
item_set_list = []
for i in range(0,len(df)):
n=0
list_n=[]
for j in range(0,len(data)):
if (set(df[i]) <= set(data[j]))==True:
n+=1
list_n.append(df[i])
list_n.append(n)
item_set_list.append(list_n)
return item_set_list

步骤7：根据最小支持度阈值进行减枝叶❀

其他博主文章也说过，Apriori算法的核心就是通过剪枝来减少扫描难度。因为非频繁项集的超级也一定不频繁。

#得到满足最小支持度阈值的关联规则（find——rule of min-sup-rate item）
def sup_satisfy_item(data,min_suprate):
n = len(data) # 事务总数
Good_list1=Good_list(data)
m = len(Good_list1) # 商品总数
dt = sup_counts(Good_list1, data)
All_freitem_list=[]
for k in range(1,m):
dt.sort()
k_apriori=[]
for j in range(0,len(dt)):
if dt[j][-1] >= min_suprate*n: ##减枝过程
k_apriori.append(dt[j][0])
k_apriori.sort()
dt=sup_counts(creat_connect(k_apriori,k),data)
if len(k_apriori)!=0:
All_freitem_list.append(k_apriori)
else:
break
return All_freitem_list

步骤8：对每一个频繁项集进行子集拆分计算confi和rule挖掘❀

这个函数也是一个中间函数，预备工作而已。注意条件（前提是频繁项集，如果不是的话，数量可能非常多，很难挖掘）这也是身边其他人或者大家可能会犯的错误，为啥不通过Good_list清单来生成所有的1/2/3/.../k项备选频繁集，再来扫描其每一个的支持度呢？那如果是这么想的，就忽略了Apriori算法的核心了。具体是什么可以返回自行理解。

——好吧我承认 /(ㄒoㄒ)/~~：事实上Good_list()函数的编写，就是我按照上述逻辑来编写的

def Ksubset_get(df): #获得非空子集（前提条件是频繁项集，否则数量太多，很难挖掘）
n =len(df)
k =len(df[0])
All_nzsubset=[]
for num in range(n):
for i in it.combinations(df,num+1): #调用it.combination 函数
All_nzsubset.append(list(i))
return All_nzsubset

步骤9：Find_rule❀

最后一步了！！直接进行规则输出就好了，这一步非常非常非常的复杂，因为用的是list不是dict，可能在某些处理上不得不加入很多中间list来进行暂存以便后续调用。但其实我后面想了一下，用dict也很复杂，简单不到哪里去的感觉。（主要是没写）

def Find_rule_apriori(data,min_suprate,min_confi):
a=len(data) #事务总数
Sup_satisfy_item=sup_satisfy_item(data,min_suprate) #获得满足支持度的频繁项集，第一项为频繁1项集合的集合，以此类推。
l=len(Sup_satisfy_item) #获得频繁项集集合的集合长度
for i in range(1,l): #无需对频繁1项集合找寻关联规则，直接从频繁二项集的集合进行扫寻循环
Sup_satisfy_itemi=Sup_satisfy_item[i] #得到一个频繁i+1项集合的列表的列表
m=len(Sup_satisfy_itemi)
for j in range(0,m): #为对每一个频繁项集进行扫寻，因此需要再做一次for循环
Prule = Sup_satisfy_itemi[j]
list1=[]
list1.append(Prule)
item_counts1 = sup_counts(list1,data)[0][-1] #首先需要得到这一个频繁项集的支持度，或者计算频数也可以
list1.clear()
prerule_find = Ksubset_get(Prule) #得到这一个频繁项集集合的所有非空集合，方便进行关联规则的重组
prerule_find.remove(prerule_find[-1]) #删除全集
q = len(prerule_find) #得到排除全集后的关联重组列表的长度，以便进行for循环
for z in range(0,q):
list2=[]
list2.append(prerule_find[z])
item_counts2 = sup_counts(list2,data)[0][-1] #得到每一个关联重组后项集的支持度（或频数）
list2.clear()
if item_counts2 > 0:
Confi_item = item_counts1/item_counts2 #得到置信度
if Confi_item >= min_confi: #置信度减除
n=len(prerule_find[z])
list3 = Prule[:]
for o in range(0, n):
list3.remove(str(prerule_find[z][o]))
print("{0} ==> {1},sup={2},confi={3}".format(prerule_find[z],list3,round(item_counts1/a,2),round(Confi_item,2)))

输出结果：可以看到，整个程序的运行速度还是比较快的，加入更多的good和tid之后个人认为还是可以保持较快的输出速度。

四、Apriori代码——全部呈上~

import pandas as pd
import numpy as np
import itertools as it
import time
# 去除集合矩阵（i，j）None值，便于计数以及算法，常规的pandas是用来数据清洗和数据填充的，没办法解决这种问题
def Non_deal(df):
list_data = []
rows = len(df)
for i in range(0,rows):
list = df[i]
list_con = []
cols = len(list)
for j in range(0,cols):
if list[j]!="nan":
list_con.append(list[j]) #如果用remove法需要倒序去除，否则无法去除干净（因为每一次去除会导致len-1）
list_data.append(list_con)
return list_data
#目的是得到备选1-项集
def Good_list(df): #将单个商品集合出来
list_all=[]
list_in=Non_deal(df)
for i in range(0,len(list_in)):
for j in range(0,len(list_in[i])):
list_m=[]
list_m.append(str(list_in[i][j]))
list_all.append(str(list_m))
list_all=list(set(list_all))
for i in range(0,len(list_all)):
list_all[i]=eval(list_all[i])
return list_all
#目的是进行k-1-频繁项集合的重组为k项目集合
def creat_connect(list_c,n): ##实现集合内的重组，例如2-项集合重组为3-项集
new_list=[]
for i in range(0,len(list_c)):
list_a = []
for j in range(i+1,len(list_c)):
list_b = list_c[i]
list_d = []
for k in range(0,n):
list_d.append(list_c[j][k])
list_a = list_b+list_d
list_a=list(set(list_a))
list_a.sort()
new_list.append(str(list_a))
new_list=list(set(new_list))
New_list=[]
for i in range(0,len(new_list)):
new_list[i]=eval(new_list[i])
new_list[i].sort()
if len(new_list[i])==n+1:
New_list.append(new_list[i])
return New_list
#输出每个k-项频繁集的候选集的比率
def sup_rate(df,data):
m = len(data) # 事务总数
item_set_list = []
for i in range(0,len(df)):
n=0
list_n=[]
for j in range(0,len(data)):
if (set(df[i]) <= set(data[j]))==True:
n+=1
list_n.append(df[i])
list_n.append(round(n/m,2))
item_set_list.append(list_n)
return item_set_list
#输出每个k-项频繁集的候选集的个数，上有比率写法，两者无本质区别，都可以使用
def sup_counts(df,data): #输出每个1-项频繁集的候选集的次数
item_set_list = []
for i in range(0,len(df)):
n=0
list_n=[]
for j in range(0,len(data)):
if (set(df[i]) <= set(data[j]))==True:
n+=1
list_n.append(df[i])
list_n.append(n)
item_set_list.append(list_n)
return item_set_list
#得到满足最小支持度阈值的关联规则（find——rule of min-sup-rate item）
def sup_satisfy_item(data,min_suprate):
n = len(data) # 事务总数
Good_list1=Good_list(data)
m = len(Good_list1) # 商品总数
dt = sup_counts(Good_list1, data)
All_freitem_list=[]
for k in range(1,m):
dt.sort()
k_apriori=[]
for j in range(0,len(dt)):
if dt[j][-1] >= min_suprate*n: ##减枝过程
k_apriori.append(dt[j][0])
k_apriori.sort()
dt=sup_counts(creat_connect(k_apriori,k),data)
if len(k_apriori)!=0:
All_freitem_list.append(k_apriori)
else:
break
return All_freitem_list
def Ksubset_get(df): #获得非空子集（前提条件是频繁项集，否则数量太多，很难挖掘）
n =len(df)
k =len(df[0])
All_nzsubset=[]
for num in range(n):
for i in it.combinations(df,num+1): #调用it.combination 函数
All_nzsubset.append(list(i))
return All_nzsubset
def Find_rule_apriori(data,min_suprate,min_confi):
a=len(data) #事务总数
Sup_satisfy_item=sup_satisfy_item(data,min_suprate) #获得满足支持度的频繁项集，第一项为频繁1项集合的集合，以此类推。
l=len(Sup_satisfy_item) #获得频繁项集集合的集合长度
for i in range(1,l): #无需对频繁1项集合找寻关联规则，直接从频繁二项集的集合进行扫寻循环
Sup_satisfy_itemi=Sup_satisfy_item[i] #得到一个频繁i+1项集合的列表的列表
m=len(Sup_satisfy_itemi)
for j in range(0,m): #为对每一个频繁项集进行扫寻，因此需要再做一次for循环
Prule = Sup_satisfy_itemi[j]
list1=[]
list1.append(Prule)
item_counts1 = sup_counts(list1,data)[0][-1] #首先需要得到这一个频繁项集的支持度，或者计算频数也可以
list1.clear()
prerule_find = Ksubset_get(Prule) #得到这一个频繁项集集合的所有非空集合，方便进行关联规则的重组
prerule_find.remove(prerule_find[-1]) #删除全集
q = len(prerule_find) #得到排除全集后的关联重组列表的长度，以便进行for循环
for z in range(0,q):
list2=[]
list2.append(prerule_find[z])
item_counts2 = sup_counts(list2,data)[0][-1] #得到每一个关联重组后项集的支持度（或频数）
list2.clear()
if item_counts2 > 0:
Confi_item = item_counts1/item_counts2 #得到置信度
if Confi_item >= min_confi: #置信度减除
n=len(prerule_find[z])
list3 = Prule[:]
for o in range(0, n):
list3.remove(str(prerule_find[z][o]))
print("{0} ==> {1},sup={2},confi={3}".format(prerule_find[z],list3,round(item_counts1/a,2),round(Confi_item,2)))
if __name__ == '__main__':
# 数据导入
data = pd.read_excel("D:\OneDrive\桌面\测试数据.xlsx", index_col=0, header=0)
print(data)
data = data.applymap(lambda x: str(x).strip()) # 删除导入时可能存在的空格值，比如：“面包”成了“ 面包”
# 数据格式转换
data = data.values # 改为元组型数据，便于list输出
data = data.tolist() # 输出为客户*商品集合
print(Non_deal(data))
# 设定支持度和置信度
minsup,minconfi=map(eval,input("请输入支持度和置信度：").split(" "))
start = time.time()
Find_rule_apriori(data,minsup,minconfi)
end=time.time()
print('Running time: {0} Seconds'.format(end - start))

五、总结

① 非常感谢我们老师的指导和激励呜呜呜，上课一直被点名。

② Apriori算法真的很难写出来，写的很痛苦的家人们一定不要放弃！心态要好，希望这篇文章能够帮到你们一些，给到你们一些“我踩过的坑不要踩”的建议。

③ 个人一直以来就喜欢分享，看以前的文章也可以发现，什么聚类分析、模糊聚类（传递闭包矩阵算法等等）都是个人编写的大白话函数，所以撰写本文的初衷就是个人的分享~

④ K-means算法本人由于之前学习数学建模的时候太懒了，就没有撰写。

⑤ 如果大家复制了我的函数，希望能够在代码段中标明了引用。

⑥ 本文在细节的处理非常粗糙，希望大家在编写过程中能够予以改进，期待和各位交流（改进了一定要记得和我分享分享呜呜呜）

⑦ 这是一个学习锻炼的过程，非计科、信管等专业，但也要强化这种语言能力~特别是商科！

标签:

声明

1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，请转载时务必注明文章作者和来源，不尊重原创的行为我们将追究责任；3.作者投稿可能会经我们编辑修改或补充。

在线投稿：投稿站长QQ：1888636

后台-插件-广告管理-内容页尾部广告（手机）