关联规则挖掘（Apriori算法和FP-Growth算法）

一、关联规则概述
1.关联规则分析用于在一个数据集中找出各种数据项之间的关联关系，广泛用于购物篮数据、个性化推荐、预警、时尚穿搭、生物信息学、医疗诊断、网页挖掘和科学数据分析中
2.关联规则分析又称购物篮分析，最早是为了发现超市销售数据库中不同商品之间的关联关系。
3.常用的关联规则分析算法

二、几个概念
1.项目：一个字段，比如一次交易订单中的一个商品
2.项集：包含若干个项目的集合，项目数量为k，则称为k项集
3.事务：一次交易中所有项目的集合
4.关联规则的表示形式：
（1）支持度：支持度为某项集在数据集中出现的频率。即项集在记录中出现的次数，除以数据集中所有记录的数量。
（2）置信度：关联规则{AB}中，置信度为A与B同时出现的次数，除以A出现的次数。
（3）提升度：关联规则{AB}中，提升度为{AB}的置信度，除以B的支持度。
5.频繁项集：满足最小支持度阈值与最小置信度阈值的项集称为频繁项集
（1）频繁项集具有强关联规则
6.闭项集：对于项集X来说，若数据集中不存在与项集X相同支持度的项集Y，那么项集X可称为闭项集X
7.频繁闭项集：对于频繁项集X来说，若数据集中不存在与频繁项集X相同支持度的频繁项集Y，那么频繁项集X可称为频繁闭项集X
8.极大项集：若项集X包含的项目数量最多，那么称项集X为极大项集。
9.极大频繁项集：若频繁项集X包含的项目数量最多，那么称项集X为极大频繁项集。
三、Apriori算法：通过限制候选产生发现频繁项集
1.定义
1994年，Rakesh Agrawal和Ramakrishnan Srikant 在Fast algorithms for mining association rules in large databases一文中正式提出Apriori算法用于挖掘数据库中频繁项集，是布尔关联规则挖掘频繁项集的原创性算法，通过限制候选集产生发现频繁项集。Apriori算法使用一种称为逐层搜索的迭代方法，其中k项集用于探索（k+1）项集。具体过程描述如下：首先扫描数据库，累计每个项的计数，并收集满足最小支持度的项找出频繁1项集记为L1，然后使用L1找出频繁2项集的集合L2，使用L2找出L3，迭代直到无法再找到频繁k项集为止，找出每个Lk需要一次完整的数据库扫描。
逐层搜索图例

2.先验性质：
（1）如果项集L1不是频繁项集，那么项集L1的超项集L2也不可能是频繁项集
（2）如果项集L5是频繁项集，那么频繁项集L5的派生项集L4和L1一定是频繁项集
3.Apriori算法的步骤
（1）找出所有支持度大于等于最小支持度阈值的频繁项集。
（2）由频繁模式生成满足可信度阈值的关联规则。
4.连接+剪枝

（1）C：候选集
（2）L：频繁项集的集合
5.由频繁项集产生关联规则
（1）例子

置信区间与置信度的关系：当样本量给定时，置信区间的宽度随着置信水平的增大而增大；当置信水平固定时，置信区间的宽度随样本量的增大而减小，也就是说，较大的样本所提供的有关总体的信息要比较小的样本多。
置信度与精度的关系：当样本量给定时，误差范围随着置信度的增大而增大，即精度随置信度的增加而减小；当置信度固定时，误差范围随着样本量的增大而减小。因此，可通过增加样本量来提高精度。
给定的置信度在医学领域应该约高越好，理应在99%以上。
6.总结Apriori算法的一般过程
(1) 收集数据：使用任意方法。
(2) 准备数据：任何数据类型都可以，因为我们只保存集合。
(3) 分析数据：使用任意方法。
(4) 训练算法：使用Apriori算法来找到频繁项集。
(5) 测试算法：不需要测试过程。
(6) 使用算法：用于发现频繁项集以及物品之间的关联规则。
7.Apriori算法的优缺点
优点：易编码实现。
缺点：在大数据集上可能较慢。
适用数据类型：数值型或者标称型数据。
8.解决方法
（1）缩小产生的候选集
（2）改进对候选集支持度计算方法
四、FP-Growth算法：使用FP-growth算法来高效发现频繁项集
FP-growth算法只需要对数据库进行两次扫描，而Apriori算法对于每个潜在的频繁项集都会扫描数据集判定给定模式是否频繁，因此FP-growth算法的速度要比Apriori算法快。在小规模数据集上，这不是什么问题，但当处理更大数据集时，就会产生较大问题。FP-growth只会扫描数据集两次，它发现频繁项集的基本过程如下：
(1) 构建FP树
(2) 从FP树中挖掘频繁项集
1.定义：频繁模式增长（FP-growth）是一种基于Apriori的改进算法，优点是不产生候选频繁项集
2.算法原理：它采用分治策略（Divide and Conquer），在经过第一遍扫描之后，把代表频繁项集的数据库压缩进一棵频繁模式树（FP-tree），同时依然保留其中的关联信息，然后将FP-tree分化成一些条件库，每个库和一个长度为1的项集相关，再对这些条件库分别进行递归挖掘（降低了I/O开销）。
3.例子
（1）构造FP-tree

（2）创建项表头，使每个项目通过节点链指向它在树种的位置

（3）FP-tree挖掘
I.从项头表开始挖掘，由频率低的结点开始
II.根据FP-tree得出各个项目（节点）的条件模式基（节点为叶子的生成子树）
例如：I5的条件模式基{I2，I1：1}，{I2，I1，I3：1}
III.根据各个节点的条件模式基构造条件FP树（所有祖宗节点计数均变为叶子节点计数，再删除低于支持度的结点）
例如：结点I4的条件模式基{I2，I1：1}，{I2：1}，则结点I4的条件FP树如下图所示：

关于结点I4的频繁项集为{I2，I4}

FP- growth方法将发现长频繁模式的问题转换成在较小的条件数据库中递归地搜索一些较短模式，然后连接后缀。它使用最不频繁的项作后缀，提供了较好的选择性。该方法显著地降低了搜索开销。
对FP-groith方法的性能研究表明:对于挖掘长的频繁模式和短的频繁模式，它都是有效的和可伸缩的，并且大约比Apriori 算法快一个数量级。
4.FP-growth算法优缺点
优点：一般要快于Apriori。
缺点：实现比较困难，在某些数据集上性能会下降。
适用数据类型：标称型数据。
5.总结FP-growth的一般流程
(1) 收集数据：使用任意方法。
(2) 准备数据：由于存储的是集合，所以需要离散数据。如果要处理连续数据，需要将它们量化为离散值。
(3) 分析数据：使用任意方法。
(4) 训练算法：构建一个FP树，并对树进行挖据。
(5) 测试算法：没有测试过程。
(6) 使用算法：可用于识别经常出现的元素项，从而用于制定决策、推荐元素或进行预测等应用中。
五、基于Python实现Apriori算法
Python代码如下：

#-*- coding: utf-8 -*-
import os
import time
#python进度条库
from tqdm import tqdmbegin_time =time.time()
def load_data(path):#根据路径加载数据集ans=[]#将数据保存到该数组if path.split(".")[-1]==("xls" or "xlsx"):#若路径为药方.xlsfrom xlrd import open_workbook# import xlwtworkbook=open_workbook(path)sheet=workbook.sheet_by_index(0)#读取第一个sheetfor i in range(1,sheet.nrows):#忽视header,从第二行开始读数据,第一列为处方ID,第二列为药品清单temp=sheet.row_values(i)[1].split(";")[:-1]#取该行数据的第二列并以“;”分割为数组if len(temp)==0: continuetemp=[j.split(":")[0] for j in temp]#将药品后跟着的药品用量去掉temp=list(set(temp))#去重，排序temp.sort()ans.append(temp)#将处理好的数据添加到数组elif path.split(".")[-1]=="csv":import csvwith open(path,"r") as f:reader=csv.reader(f)for row in reader:row=list(set(row))#去重，排序row.sort()ans.append(row)#将添加好的数据添加到数组return ans#返回处理好的数据集，为二维数组def save_rule(rule,path):#保存结果到txt文件with open(path,"w") as f:f.write("index  confidence"+"   rules\n")index=1for item in rule:s=" {:<4d}  {:.3f}        {}=>{}\n".format(index,item[2],str(list(item[0])),str(list(item[1])))index+=1f.write(s)f.close()print("result saved,path is:{}".format(path))class Apriori():def create_c1(self,dataset):#遍历整个数据集生成c1候选集c1=set()for i in dataset:for j in i:item = frozenset([j])c1.add(item)return c1def create_ck(self,Lk_1,size):#通过频繁项集Lk-1创建ck候选项集Ck = set()l = len(Lk_1)lk_list = list(Lk_1)for i in range(l):for j in range(i+1, l):#两次遍历Lk-1，找出前n-1个元素相同的项l1 = list(lk_list[i])l2 = list(lk_list[j])l1.sort()l2.sort()if l1[0:size-2] == l2[0:size-2]:#只有最后一项不同时，生成下一候选项Ck_item = lk_list[i] | lk_list[j]if self.has_infrequent_subset(Ck_item, Lk_1):#检查该候选项的子集是否都在Lk-1中Ck.add(Ck_item)return Ckdef has_infrequent_subset(self,Ck_item, Lk_1):#检查候选项Ck_item的子集是否都在Lk-1中for item in Ck_item: sub_Ck = Ck_item - frozenset([item])if sub_Ck not in Lk_1:return Falsereturn Truedef generate_lk_by_ck(self,data_set,ck,min_support,support_data):#通过候选项ck生成lk，并将各频繁项的支持度保存到support_data字典中item_count={}#用于标记各候选项在数据集出现的次数Lk = set()for t in tqdm(data_set):#遍历数据集for item in ck:#检查候选集ck中的每一项是否出现在事务t中if item.issubset(t):if item not in item_count:item_count[item] = 1else:item_count[item] += 1t_num = float(len(data_set))for item in item_count:#将满足支持度的候选项添加到频繁项集中if item_count[item] >= min_support:Lk.add(item)support_data[item] = item_count[item]return Lkdef generate_L(self,data_set, min_support):#用于生成所有频繁项集的主函数，k为最大频繁项的大小support_data = {} #用于保存各频繁项的支持度C1 = self.create_c1(data_set) #生成C1L1 = self.generate_lk_by_ck(data_set, C1, min_support, support_data)#根据C1生成L1Lksub1 = L1.copy() #初始时Lk-1=L1L = []L.append(Lksub1)i=2while(True):Ci = self.create_ck(Lksub1, i)  #根据Lk-1生成CkLi = self.generate_lk_by_ck(data_set, Ci, min_support, support_data) #根据Ck生成Lkif len(Li)==0:breakLksub1 = Li.copy()  #下次迭代时Lk-1=LkL.append(Lksub1)i+=1for i in range(len(L)):print("frequent item {}：{}".format(i+1,len(L[i])))return L, support_datadef generate_R(self,dataset, min_support, min_conf):L,support_data=self.generate_L(dataset,min_support)#根据频繁项集和支持度生成关联规则rule_list = []#保存满足置信度的规则sub_set_list = []#该数组保存检查过的频繁项for i in range(0, len(L)):for freq_set in L[i]:#遍历Lkfor sub_set in sub_set_list:#sub_set_list中保存的是L1到Lk-1if sub_set.issubset(freq_set):#检查sub_set是否是freq_set的子集#检查置信度是否满足要求，是则添加到规则conf = support_data[freq_set] / support_data[freq_set - sub_set]big_rule = (freq_set - sub_set, sub_set, conf)if conf >= min_conf and big_rule not in rule_list:rule_list.append(big_rule)sub_set_list.append(freq_set)rule_list = sorted(rule_list,key=lambda x:(x[2]),reverse=True)return rule_listif __name__=="__main__":##configfilename="groceries.csv"min_support=25#最小支持度min_conf=0.7#最小置信度#获取当前路径current_path=os.getcwd()#若找不到次路径，添加log文件if not os.path.exists(current_path+"/log"):os.mkdir("log")#数据集存放路径path=current_path+"/dataset/"+filename#结果存放路径save_path=current_path+"/log/"+filename.split(".")[0]+"_apriori.txt"#加载数据data=load_data(path)print(data)# #调用写好的Apriori类apriori=Apriori()rule_list=apriori.generate_R(data,min_support=15,min_conf=0.7)save_rule(rule_list,save_path)
end_time = time.time()
run_time = end_time-begin_time
print ('该循环程序运行时间：{:.2f}s'.format(run_time)) #该循环程序运行时间：

输出结果：

最后结果：

六、基于Python实现FP-Growth算法
Python代码如下：

#-*- coding: utf-8 -*-
import os
import time
from tqdm import tqdm
begin_time =time.time()
#第一次扫描数据集
def load_data(path):#根据路径加载数据集ans=[]#将数据保存到该数组if path.split(".")[-1]==("xls" or "xlsx"):#若路径为药方.xlsfrom xlrd import open_workbookimport xlwtworkbook=open_workbook(path)sheet=workbook.sheet_by_index(0)#读取第一个sheetfor i in range(1,sheet.nrows):#忽视header,从第二行开始读数据,第一列为处方ID,第二列为药品清单temp=sheet.row_values(i)[1].split(";")[:-1]#取该行数据的第二列并以“;”分割为数组if len(temp)==0: continuetemp=[j.split(":")[0] for j in temp]#将药品后跟着的药品用量去掉temp=list(set(temp))#去重，排序temp.sort()ans.append(temp)#将处理好的数据添加到数组elif path.split(".")[-1]=="csv":import csvwith open(path,"r") as f:reader=csv.reader(f)for row in reader:row=list(set(row))#去重，排序row.sort()ans.append(row)#将添加好的数据添加到数组return ans#返回处理好的数据集，为二维数组def save_rule(rule,path):#保存结果到txt文件with open(path,"w") as f:f.write("index  confidence"+"   rules\n")index=1for item in rule:s=" {:<4d}  {:.3f}        {}=>{}\n".format(index,item[2],str(list(item[0])),str(list(item[1])))index+=1f.write(s)f.close()print("result saved,path is:{}".format(path))class Node:def __init__(self, node_name,count,parentNode):self.name = node_nameself.count = countself.nodeLink = None#根据nideLink可以找到整棵树中所有nodename一样的节点self.parent = parentNode#父亲节点self.children = {}#子节点{节点名字:节点地址}class Fp_growth():#更新头结点def update_header(self,node, targetNode):#更新headertable中的node节点形成的链表while node.nodeLink != None:node = node.nodeLinknode.nodeLink = targetNode#更新树的分支def update_fptree(self,items, node, headerTable):#用于更新fptreeif items[0] in node.children:# 判断items的第一个结点是否已作为子结点node.children[items[0]].count+=1else:# 创建新的分支node.children[items[0]] = Node(items[0],1,node)# 更新相应频繁项集的链表，往后添加if headerTable[items[0]][1] == None:headerTable[items[0]][1] = node.children[items[0]]else:self.update_header(headerTable[items[0]][1], node.children[items[0]])# 递归if len(items) > 1:self.update_fptree(items[1:], node.children[items[0]], headerTable)#创建树def create_fptree(self,data_set, min_support,flag=False):#建树主函数'''根据data_set创建fp树header_table结构为{"nodename":[num,node],..} 根据node.nodelink可以找到整个树中的所有nodename'''item_count = {}#统计各项出现次数for t in data_set:#第一次遍历，得到频繁一项集for item in t:if item not in item_count:item_count[item]=1else:item_count[item]+=1headerTable={}for k in item_count:#剔除不满足最小支持度的项if item_count[k] >= min_support:headerTable[k]=item_count[k]freqItemSet = set(headerTable.keys())#满足最小支持度的频繁项集if len(freqItemSet) == 0:return None, Nonefor k in headerTable:headerTable[k] = [headerTable[k], None] # element: [count, node]tree_header = Node('head node',1,None)if flag:ite=tqdm(data_set)else:ite=data_setfor t in ite:#第二次遍历，建树localD = {}for item in t:if item in freqItemSet: # 过滤，只取该样本中满足最小支持度的频繁项localD[item] = headerTable[item][0] # element : countif len(localD) > 0:# 根据全局频数从大到小对单样本排序order_item = [v[0] for v in sorted(localD.items(), key=lambda x:x[1], reverse=True)]# 用过滤且排序后的样本更新树self.update_fptree(order_item, tree_header, headerTable)return tree_header, headerTabledef find_path(self,node, nodepath):'''递归将node的父节点添加到路径'''if node.parent != None:nodepath.append(node.parent.name)self.find_path(node.parent, nodepath)#找出条件模式基def find_cond_pattern_base(self,node_name, headerTable):'''根据节点名字，找出所有条件模式基'''treeNode = headerTable[node_name][1]cond_pat_base = {}#保存所有条件模式基while treeNode != None:nodepath = []self.find_path(treeNode, nodepath)if len(nodepath) > 1:cond_pat_base[frozenset(nodepath[:-1])] = treeNode.count treeNode = treeNode.nodeLink return cond_pat_base#条件树def create_cond_fptree(self,headerTable, min_support, temp, freq_items,support_data):# 最开始的频繁项集是headerTable中的各元素freqs = [v[0] for v in sorted(headerTable.items(), key=lambda p:p[1][0])] # 根据频繁项的总频次排序for freq in freqs: # 对每个频繁项freq_set = temp.copy()freq_set.add(freq)freq_items.add(frozenset(freq_set))if frozenset(freq_set) not in support_data:#检查该频繁项是否在support_data中support_data[frozenset(freq_set)]=headerTable[freq][0]else:support_data[frozenset(freq_set)]+=headerTable[freq][0]cond_pat_base = self.find_cond_pattern_base(freq, headerTable)#寻找到所有条件模式基cond_pat_dataset=[]#将条件模式基字典转化为数组for item in cond_pat_base:item_temp=list(item)item_temp.sort()for i in range(cond_pat_base[item]):cond_pat_dataset.append(item_temp)#创建条件模式树cond_tree, cur_headtable = self.create_fptree(cond_pat_dataset, min_support)if cur_headtable != None:self.create_cond_fptree(cur_headtable, min_support, freq_set, freq_items,support_data) # 递归挖掘条件FP树#根据条件树，挖掘频繁项def generate_L(self,data_set,min_support):freqItemSet=set()support_data={}tree_header,headerTable=self.create_fptree(data_set,min_support,flag=True)#创建数据集的fptree#创建各频繁一项的fptree，并挖掘频繁项并保存支持度计数self.create_cond_fptree(headerTable, min_support, set(), freqItemSet,support_data)max_l=0for i in freqItemSet:#将频繁项根据大小保存到指定的容器L中if len(i)>max_l:max_l=len(i)L=[set() for _ in range(max_l)]for i in freqItemSet:L[len(i)-1].add(i)for i in range(len(L)):print("frequent item {}:{}".format(i+1,len(L[i]))) return L,support_data #挖掘关联规则def generate_R(self,data_set, min_support, min_conf):L,support_data=self.generate_L(data_set,min_support)rule_list = []sub_set_list = []for i in range(0, len(L)):for freq_set in L[i]:for sub_set in sub_set_list:if sub_set.issubset(freq_set) and freq_set-sub_set in support_data:#and freq_set-sub_set in support_dataconf = support_data[freq_set] / support_data[freq_set - sub_set]big_rule = (freq_set - sub_set, sub_set, conf)if conf >= min_conf and big_rule not in rule_list:# print freq_set-sub_set, " => ", sub_set, "conf: ", confrule_list.append(big_rule)sub_set_list.append(freq_set)rule_list = sorted(rule_list,key=lambda x:(x[2]),reverse=True)return rule_listif __name__=="__main__":#configfilename="groceries.csv"min_support=25#最小支持度min_conf=0.7#最小置信度spend_time=[]current_path=os.getcwd()if not os.path.exists(current_path+"/log"):os.mkdir("log")path=current_path+"/dataset/"+filenamesave_path=current_path+"/log/"+filename.split(".")[0]+"_fpgrowth.txt"#加载数据集data_set=load_data(path)# print(data_set)#调用Fp_growth算法fp=Fp_growth()#生成关联规则rule_list = fp.generate_R(data_set, min_support, min_conf)#保存文件save_rule(rule_list,save_path)
end_time = time.time()
run_time = end_time-begin_time
print ('该循环程序运行时间：{:.2f}s'.format(run_time)) #该循环程序运行时间：

输出结果：

最后结果：

七、结论与建议
（一）结果分析
本例探究了顾客在杂货店购买商品时是否存在关联规则的情况，基于groceries.csv数据集，并将最小支持度设置为25，最小置信度设置为0.7。使用Apriori算法进行关联规则分析，输出了300条关联规则，其中当客户购买[‘root vegetables’, ‘whipped/sour cream’, ‘flour’]这三种商品时购买[‘whole milk’]的置信度是1；使用FP-growth算法进行关联规则分析，输出了36条关联规则，其中当客户购买[‘citrus fruit’, ‘whole milk’, ‘tropical fruit’, ‘root vegetables’]这三种商品时购买[‘other vegetables’]的置信度是0.886 ；店家可以根据分析情况摆放商品，将置信度高的商品摆放一起可以增加客户的购买力。
（二）结果比较

由图可知，FP-growth算法比Apriori算法快一个数量级，在空间复杂度方面也比Apriori也有数量级级别的优化。
我们发现Apriori算法的频繁项集的方式是：先产生低阶频繁项集（从1开始的）的，再由低阶频繁项集产生高阶候选项集，高阶候选项集经过支持度的度量筛选产生，最后生成同阶频繁项集。这是不断重复的“产生-测试”的过程。而FP-growth算法采用是完全不同的方式，算法的第一个核心是压缩数据集，采用的是FP_tree这样的一个数据结构来完全表示了所有的事务，第二个核心是采用了“分而治之”的思想，用递归的方式将挖掘频繁项集一步步分成各自的子问题来解决。对比于Apriori算法，FP-growth算法的特点是只需要扫描两次数据集和无需产生候选项集。
关联规则挖掘是个值得深入研究的研究。本文通过对经典算法的研究，实现对经典算法的初步实现。但是还有许多值得深入研究的地方：
（1）数据挖掘的基本问题在于数据的处理，数据结构的优化和挖掘算法效率的提高，是今后不断需要努力的地方。
（2）采用多层关联规则和多维关联规则分析技术挖掘更多的潜在信息。

关联规则挖掘（Apriori算法和FP-Growth算法）相关推荐

关联规则挖掘Apriori算法的实现
实验名称关联规则挖掘Apriori算法的实现实验目的 1.掌握频繁项目集的生成原理 2.掌握关联规则挖掘的原理 3.掌握在weka中进行关联规则挖掘的具体流程. 实验内容 1.根据给定的事务数据库 ...
使用Apriori算法和FP-growth算法进行关联分析
目录 1. 关联分析 2. Apriori原理 3. 使用Apriori算法来发现频繁集 4. 使用FP-growth算法来高效发现频繁项集 5. 示例:从新闻网站点击流中挖掘新闻报道扩展阅读系列 ...
数据分享|R语言关联规则挖掘apriori算法挖掘评估汽车性能数据
全文链接:http://tecdat.cn/?p=32092 我们一般把一件事情发生,对另一件事情也会产生影响的关系叫做关联.而关联分析就是在大量数据中发现项集之间有趣的关联和相关联系(形如" ...
【数据挖掘】关联规则挖掘 Apriori 算法 ( Apriori 算法过程 | Apriori 算法示例 )
文章目录一. Apriori 算法过程二. Apriori 算法示例参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集与事物 Transaction ...
【数据挖掘】关联规则挖掘 Apriori 算法 ( 关联规则性质 | 非频繁项集超集性质 | 频繁项集子集性质 | 项集与超集支持度性质 )
文章目录一. 非频繁项集超集性质二. 频繁项集子集性质三. 项集与超集支持度性质参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集与事物 Trans ...
【数据挖掘】关联规则挖掘 Apriori 算法 ( 频繁项集 | 非频繁项集 | 强关联规则 | 弱关联规则 | 发现关联规则 )
文章目录一. 频繁项集二. 非频繁项集三. 强关联规则四. 弱关联规则五. 发现关联规则参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集与事物 ...
【数据挖掘】关联规则挖掘 Apriori 算法 ( 关联规则 | 数据项支持度 | 关联规则支持度 )
文章目录一. 关联规则二. 数据项支持度三. 关联规则支持度参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集与事物 Transaction 概念 ...
Frequent Pattern 挖掘之二(FP Growth算法)（转）
FP树构造 FP Growth算法利用了巧妙的数据结构,大大降低了Aproir挖掘算法的代价,他不需要不断得生成候选项目队列和不断得扫描整个数据库进行比对.为了达到这样的效果,它采用了一种简洁的数据结 ...
【数据挖掘】关联规则挖掘 Apriori 算法 ( 置信度 | 置信度示例 )
文章目录一. 置信度二. 置信度示例参考博客 : [数据挖掘]关联规则挖掘 Apriori 算法 ( 关联规则简介 | 数据集与事物 Transaction 概念 | 项 Item 概念 ...

关联规则挖掘（Apriori算法和FP-Growth算法）

关联规则挖掘（Apriori算法和FP-Growth算法）相关推荐

最新文章

热门文章