本文主要介绍了数据挖掘Apriori算法的详细说明和Python实现代码的分享。本文首先详细介绍Apriori算法，然后给出Python实现代码，有需要的朋友可以参考一下。
关联规则挖掘是数据挖掘中最活跃的研究方法之一，可以用来发现事物之间的关系。最早的目的是发现超市交易数据库中不同商品之间的关系。(啤酒和尿布)
基本概念
1.支持度的定义：support (x-y)=| x cross Y|/N=集合x和集合Y中的项目同时出现在一条记录中的次数/数据记录数。比如：support({ beer}-{diapers})=啤酒和尿布同时出现的次数/数据记录数=3/5=60%。
2.置信度的定义：置信度(x-y)=| x交叉Y|/|X|=集合X和集合Y中的项目同时出现在一条记录中的次数/集合X的出现次数例如：置信度({ beer}-{diapers})=啤酒和尿布同时出现的次数/啤酒出现的次数=3/3=100%；置信度({尿布}-{啤酒})=啤酒和尿布同时出现的次数/尿布出现的次数=3/4=75%
同时满足最小支持度阈值(min_sup)和最小置信度阈值(min_conf)的规则称为强规则，如果项集满足最小支持度，则称为频繁项集。
"如何从大型数据库中挖掘关联规则？"挖掘关联规则是一个两步过程：
1.找出所有频繁项集：根据定义，这些项集的频率至少与预定义的最小支持计数一样高。
2.从频繁项集生成强关联规则：根据定义，这些规则必须满足最小支持度和最小置信度。
Apriori定律
为了减少频繁项集的生成时间，我们应该尽快消除一些完全不可能成为频繁项集的集合。先验两定律做到了这一点。
Apriori定律1:如果一个集合是频繁项集，那么它的所有子集都是频繁项集。例如，假设集合{A，B}是一个频繁项集，即A和B在一条记录中同时出现的次数大于等于min_support，那么它的子集{a}和{b}出现的次数一定大于等于min_support，即它的所有子集都是频繁项集。
Apriori定律2:如果一个集合不是频繁项集，那么它的所有超集都不是频繁项集。例如，如果集合{A}不是频繁项集，即A的出现次数小于min_support，则它的任何超集(如{A，B})都必须小于min_support，因此它的超集也不能是频繁项集。
上图演示了Apriori算法的流程。注意，从二级频繁项集生成三级候选项集时，没有{牛奶，面包，啤酒}。那是因为{面包，啤酒}不是两级频繁项集。这里使用了先验定理。最后，生成三级频繁项集后，没有更高级别的候选项集，整个算法结束，{牛奶，面包，尿布}为最大频繁子集。
Python实现代码：
复制代码如下：
跳到内容
注册在此存储库中注册
探索
特征
企业
博客
Star 0 Fork 0太子龙旭/datamining
分支：主数据挖掘/apriori/apriori.py
hackerxutaizilongxu 20天前的备份
1名投稿人
156行(140 sloc) 6.302 kb原始故障历史记录
#-*-编码：UTF-8 -*-
# -导入-
# -
类先验(对象):
def __init__(self，filename，min_support，item_start，item_end):
self.filename=文件名
Self.min_support=min_support #最小支持
self.min_confidence=50
Self.line _ num=0 #项目的行数
Self.item_start=item_start #取哪一行物品？
self.item_end=item_end
self . location=[[I]for I in range(self . item _ end-self . item _ start 1)]
self.support=self.sut(自我定位)
Self.num=list(已排序(set ([j for I in self。I])) #记录项中j的位置
Self.pre_support=[] #保存以前的支持，位置，编号
self.pre_location=[]
self.pre_num=[]
Self.item_name=[] # item name
self.find_item_name()
self.loop()
self.confidence_sup()
定义交易行(自身，行):
'提取出需要的项'
返回[I . strip()for I in line。分裂(“”)如果我][自我。item _ start-1:自我。item _ end]
定义查找项目名称(自身):
'根据第一行抽取'项目名称'
用打开(self.filename，' r ')作为女：
对于索引，枚举(F.readlines())中的行：
如果索引==0:
自我。item _ name=self。交易_行(行)
破裂
定义sut(自身，位置):
'''
输入[[1,2,3],[2,3,4],[1,3,5].]
输出每个位置集的支持[123435234.]
'''
用打开(self.filename，' r ')作为女：
support=[0] * len(位置)
对于索引，枚举(F.readlines())中的行：
如果索引==0:继续
# 提取每信息
item_line=self.deal_line(line)
对于index_num我在枚举（位置):
标志=0
对于我中的j:
if item_line[j]！='T ':
标志=1
破裂
如果没有标记：
support[index_num]=1
self.line_num=index #一共多少行，出去第一行的项目名称
返回支持
定义选择（自身，c):
'返回位置'
stack=[]
对于自我定位中的我：
对于自我编号中的j:
如果j在我中：
如果len(i)==c:
堆栈。追加
否则：
stack.append([j] i)
# 多重列表去重
导入itertools
s=已排序([在堆栈中为我排序(一))
location=list(s for s，_ in itertools.groupby(s))
返回位置
定义删除位置(自身、支持、位置):
'清除不满足条件的候选集'
# 小于最小支持度的剔除
对于索引，我在列举（支持):
如果我自我。line _ num * self。min _ support/100:
support[index]=0
#先验第二条规则，剔除
对于索引，j在列举(位置):
sub _ location=[j[:index _ loc]j[index _ loc 1:]for index _ loc in range(len(j))]
标志=0
对于子位置中的k:
如果k不在自己的位置：
标志=1
破裂
如果标志：
support[index]=0
# 删除没用的位置
location=[i for i，j in zip(location，support) if j！=0]
支持=[我为我在支持如果我！=0]
返回支持，位置
定义循环（自身):
s级频繁项级的迭代'
s=2
虽然正确：
打印'-'*80
打印“那个”，s - 1，”循环"
打印"位置",自身位置
打印"支持",自助
打印"编号",自身编号
打印'-'*80
# 生成下一级候选集
位置=自我选择
support=self.sut(位置)
支持，位置=self.del_location(支持，位置)
num=列表(已排序(set([j for i in location for j in i]))
s=1
如果位置和支持以及编号：
self.pre_num=self.num
自我。pre _ location=自身。位置
self.pre_support=自我支持
自我编号=数字
自我定位=位置
自我支持=支持
否则：
破裂
def置信度_sup(自我):
'计算"信心"
如果sum(self.pre_support)==0:
打印"最小支持错误"#第一次迭代即失败
否则：
对于索引位置，枚举中的每个位置(自我定位):
del _ num=[each _ location[:index]each _ location[index 1:]for index in range(len(each _ location))]#生成上一级频繁项级
del _ num=[I for I in del _ num if I in self。前置_位置]#删除不存在上一级频繁项级子集
del _ support=[self。pre _ support【自己。前置_位置。index(I)]for I in del _ num if I in self。前置_位置]#从上一级支持度查找
#打印删除编号
#打印自助服务[索引_位置]
# print del_support
对于索引，我在枚举(del_num): #计算每个关联规则支持度和自信度
index_support=0
如果len(自养)!=1:
index_support=索引
支持=浮动(自我。支持[index _ location])/self。行编号* 100 #支持度
s=[j for index_item，j in enumerate(self。item _ name)if index _ item in I]
if del_support[index]:
置信度=float(self。support[index _ location])/del _ support[index]* 100
如果自信self.min _自信：
打印','。加入，'-'，自我。item _ name[each _ location[index]]，' min_support:'，str(support) '% '，' min_confidence:'，str(confidence) '% '
def main():
c=Apriori('basket.txt '，14，3，13)
d=先验(' simple.txt '，50，2，6)
if __name__=='__main__ ':
主()
############################################################################
状态应用程序接口培训商店博客关于
2014 GitHub公司。条款隐私安全联系人
Apriori算法
先验（文件名，最小支持，项目开始，项目结束)
参数说明
文件名：(路径)文件名
min_support:最小支持度
项目_开始：项目起始位置
项目_结束：项目结束位置
使用例子：
复制代码代码如下：
导入先验
c=先验. Apriori('basket.txt '，11，3，13)
输出：
复制代码代码如下：
-
一环路
位置[[0]、[1]、[2]、[3]、[4]、[5]、[6]、[7]、[8]、[9]、[10]]
支持[299,183,177,303,204,302,293,287,184,292,276]
数字[0,1,2,3,4,5,6,7,8,9,10]
-
-
二环路
位置[[0,9],[3,5],[3,6],[5,6],[7,10]]
支持[145,173,167,170,144]
数字[0,3,5,6,7,9,10]
-
-
三环路
位置[[3,5,6]]
支持[146]
数字[3,5,6]
-
冷冻餐、啤酒、罐装饮料最低支持度：14.6%最低信任度：0.253863863867
罐装啤酒、啤酒和冷冻餐最低支持度：14.6%最低信心度：0.253863863867
罐装啤酒、冷冻餐、啤酒最低支持度：14.6%最低信任度：0.253863863837
-
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。