Ⅰ apriori里python调用了哪些库有哪些关键函数
第一，apriori只是一种挖掘算法，没有特定的只能用pyton或者某一种语言；
apriori算法的逻辑流程
首先找出所有的频集，这些项集出现的频繁性至少和预定义的最小支持度一样。然后由频集产生强关联规则，这些规则必须满足最小支持度和最小可信度。然后使用第1步找到的频集产生期望的规则，产生只包含集合的项的所有规则，其中每一条规则的右部只有一项，这里采用的是中规则的定义。一旦这些规则被生成，那么只有那些大于用户给定的最小可信度的规则才被留下来。为了生成所有频集，使用了递归的方法。
（1） L1 = find_frequent_1-itemsets(D);
（2） for (k=2;Lk-1 ≠Φ ;k++) {
（3） Ck = apriori_gen(Lk-1 ,min_sup);
（4） for each transaction t ∈D{//scan D for counts
（5） Ct = subset(Ck,t);//get the subsets of t that are candidates
（6） for each candidate c ∈ Ct
（7） c.count++;
（8）}
（9） Lk ={c ∈ Ck|c.count≥min_sup}
（10）}
（11） return L= ∪ k Lk;
可能产生大量的候选集,以及可能需要重复扫描数据库，是Apriori算法的两大缺点。
从逻辑上看，会用到的库：
字符处理的库
数据库处理的库
集合运算的库
概率期望运算的库（入numpy）
Ⅱ 如何实现apriori算法
java">importjava.util.HashMap;
importjava.util.HashSet;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.Set;
importjava.util.TreeMap;
/**
*<B>关联规则挖掘：Apriori算法</B>
*
*<P>按照Apriori算法的基本思想来实现
*
*@authorking
*@since2013/06/27
*
*/
publicclassApriori{
privateMap<Integer,Set<String>>txDatabase;//事务数据库
privateFloatminSup;//最小支持度
privateFloatminConf;//最小置信度
privateIntegertxDatabaseCount;//事务数据库中的事务数
privateMap<Integer,Set<Set<String>>>freqItemSet;//频繁项集集合
privateMap<Set<String>,Set<Set<String>>>assiciationRules;//频繁关联规则集合
publicApriori(
Map<Integer,Set<String>>txDatabase,
FloatminSup,
FloatminConf){
this.txDatabase=txDatabase;
this.minSup=minSup;
this.minConf=minConf;
this.txDatabaseCount=this.txDatabase.size();
freqItemSet=newTreeMap<Integer,Set<Set<String>>>();
assiciationRules=newHashMap<Set<String>,Set<Set<String>>>();
}
/**
*扫描事务数据库，计算频繁1-项集
*@return
*/
publicMap<Set<String>,Float>getFreq1ItemSet(){
Map<Set<String>,Float>freq1ItemSetMap=newHashMap<Set<String>,Float>();
Map<Set<String>,Integer>candFreq1ItemSet=this.getCandFreq1ItemSet();
Iterator<Map.Entry<Set<String>,Integer>>it=candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()){
Map.Entry<Set<String>,Integer>entry=it.next();
//计算支持度
Floatsupported=newFloat(entry.getValue().toString())/newFloat(txDatabaseCount);
if(supported>=minSup){
freq1ItemSetMap.put(entry.getKey(),supported);
}
}
returnfreq1ItemSetMap;
}
/**
*计算候选频繁1-项集
*@return
*/
publicMap<Set<String>,Integer>getCandFreq1ItemSet(){
Map<Set<String>,Integer>candFreq1ItemSetMap=newHashMap<Set<String>,Integer>();
Iterator<Map.Entry<Integer,Set<String>>>it=txDatabase.entrySet().iterator();
//统计支持数，生成候选频繁1-项集
while(it.hasNext()){
Map.Entry<Integer,Set<String>>entry=it.next();
Set<String>itemSet=entry.getValue();
for(Stringitem:itemSet){
Set<String>key=newHashSet<String>();
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)){
Integervalue=1;
candFreq1ItemSetMap.put(key,value);
}
else{
Integervalue=1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key,value);
}
}
}
returncandFreq1ItemSetMap;
}
/**
*根据频繁(k-1)-项集计算候选频繁k-项集
*
*@paramm其中m=k-1
*@paramfreqMItemSet频繁(k-1)-项集
*@return
*/
publicSet<Set<String>>aprioriGen(intm,Set<Set<String>>freqMItemSet){
Set<Set<String>>candFreqKItemSet=newHashSet<Set<String>>();
Iterator<Set<String>>it=freqMItemSet.iterator();
Set<String>originalItemSet=null;
while(it.hasNext()){
originalItemSet=it.next();
Iterator<Set<String>>itr=this.getIterator(originalItemSet,freqMItemSet);
while(itr.hasNext()){
Set<String>identicalSet=newHashSet<String>();//两个项集相同元素的集合(集合的交运算)
identicalSet.addAll(originalItemSet);
Set<String>set=itr.next();
identicalSet.retainAll(set);//identicalSet中剩下的元素是identicalSet与set集合中公有的元素
if(identicalSet.size()==m-1){//(k-1)-项集中k-2个相同
Set<String>differentSet=newHashSet<String>();//两个项集不同元素的集合(集合的差运算)
differentSet.addAll(originalItemSet);
differentSet.removeAll(set);//因为有k-2个相同，则differentSet中一定剩下一个元素，即differentSet大小为1
differentSet.addAll(set);//构造候选k-项集的一个元素(set大小为k-1,differentSet大小为k)
if(!this.has_infrequent_subset(differentSet,freqMItemSet))
candFreqKItemSet.add(differentSet);//加入候选k-项集集合
}
}
}
returncandFreqKItemSet;
}
/**
*使用先验知识，剪枝。若候选k项集中存在k-1项子集不是频繁k-1项集，则删除该候选k项集
*@paramcandKItemSet
*@paramfreqMItemSet
*@return
*/
privatebooleanhas_infrequent_subset(Set<String>candKItemSet,Set<Set<String>>freqMItemSet){
Set<String>tempSet=newHashSet<String>();
tempSet.addAll(candKItemSet);
Iterator<String>itItem=candKItemSet.iterator();
while(itItem.hasNext()){
Stringitem=itItem.next();
tempSet.remove(item);//该候选去掉一项后变为k-1项集
if(!freqMItemSet.contains(tempSet))//判断k-1项集是否是频繁项集
returntrue;
tempSet.add(item);//恢复
}
returnfalse;
}
/**
*根据一个频繁k-项集的元素(集合)，获取到频繁k-项集的从该元素开始的迭代器实例
*@paramitemSet
*@paramfreqKItemSet频繁k-项集
*@return
*/
privateIterator<Set<String>>getIterator(Set<String>itemSet,Set<Set<String>>freqKItemSet){
Iterator<Set<String>>it=freqKItemSet.iterator();
while(it.hasNext()){
if(itemSet.equals(it.next())){
break;
}
}
returnit;
}
/**
*根据频繁(k-1)-项集，调用aprioriGen方法，计算频繁k-项集
*
*@paramk
*@paramfreqMItemSet频繁(k-1)-项集
*@return
*/
publicMap<Set<String>,Float>getFreqKItemSet(intk,Set<Set<String>>freqMItemSet){
Map<Set<String>,Integer>candFreqKItemSetMap=newHashMap<Set<String>,Integer>();
//调用aprioriGen方法，得到候选频繁k-项集
Set<Set<String>>candFreqKItemSet=this.aprioriGen(k-1,freqMItemSet);
//扫描事务数据库
Iterator<Map.Entry<Integer,Set<String>>>it=txDatabase.entrySet().iterator();
//统计支持数
while(it.hasNext()){
Map.Entry<Integer,Set<String>>entry=it.next();
Iterator<Set<String>>kit=candFreqKItemSet.iterator();
while(kit.hasNext()){
Set<String>kSet=kit.next();
Set<String>set=newHashSet<String>();
set.addAll(kSet);
set.removeAll(entry.getValue());//候选频繁k-项集与事务数据库中元素做差运算
if(set.isEmpty()){//如果拷贝set为空，支持数加1
if(candFreqKItemSetMap.get(kSet)==null){
Integervalue=1;
candFreqKItemSetMap.put(kSet,value);
}
else{
Integervalue=1+candFreqKItemSetMap.get(kSet);
candFreqKItemSetMap.put(kSet,value);
}
}
}
}
Ⅲ 请问你有用maprece实现Apriori算法的代码吗
matlab实现apriori算法源代码 一、实验目的 通过实验，加深数据挖掘中一个重要方法——关联分析的认识，其经典算法为apriori算法，了解影响apriori算法性能的因素，掌握基于apriori算法理论的关联分析的原理和方法。 二、实验内容 对一数据集用apriori算法做关联分析，用matlab实现。 三、方法手段 关联规则挖掘的一个典型例子是购物篮分析。市场分析员要从大量的数据中发现顾客放入其购物篮中的不同商品之间的关系。如果顾客买牛奶，他也购买面包的可能性有多大？ 什么商品组或集合顾客多半会在一次购物时同时购买？例如，买牛奶的顾客有80%也同时买面包，或买铁锤的顾客中有70%的人同时也买铁钉，这就是从购物篮数据中提取的关联规则。分析结果可以帮助经理设计不同的商店布局。一种策略是：经常一块购买的商品可以放近一些，以便进一步刺激这些商品一起销售，例如，如果顾客购买计算机又倾向于同时购买财务软件，那么将硬件摆放离软件陈列近一点，可能有助于增加两者的销售。另一种策略是：将硬件和软件放在商店的两端，可能诱发购买这些商品的顾客一路挑选其他商品。 关联规则是描述数据库中数据项之间存在的潜在关系的规则,形式为 1212 ......mnAAABBB,其中(1,2...,)iAim,(1,2...,)jAjn是数据库中的数据项.数据项之间的关联规则即根据一个事务中某些项的出现,可推导出另一些项在同一事务中也出现。 四、Apriori算法 1.算法描述 Apriori算法的第一步是简单统计所有含一个元素的项集出现的频率,来决定最大的一维项目集。在第k步,分两个阶段,首先用一函数sc_candidate(候选),通过第(k-1)步中生成的最大项目集Lk-1来生成侯选项目集Ck。然后搜索数据库计算侯选项目集Ck的支持度. 为了更快速地计算Ck中项目的支持度, 文中使用函数count_support计算支持度。 Apriori算法描述如下： (1) C1={candidate1-itemsets}; (2) L1={c∈C1|c.count≥minsupport}; (3) for(k=2,Lk-1≠Φ,k++) //直到不能再生成最大项目集为止 (4) Ck=sc_candidate(Lk-1); //生成含k个元素的侯选项目集 (5) for all transactions t∈D //办理处理 (6) Ct=count_support(Ck,t); //包含在事务t中的侯选项目集 (7) for all candidates c∈Ct (8) c.count=c.count+1; (9) next (10) Lk={c∈Ck|c.count≥minsupport}; (11) next (12) resultset=resultset∪Lk 其中, D表示数据库；minsupport表示给定的最小支持度；resultset表示所有最大项目集。 全国注册建筑师、建造师考试备考资料 历年真题 考试心得 模拟试题 Sc_candidate函数 该函数的参数为Lk-1,即: 所有最大k-1维项目集,结果返回含有k个项目的侯选项目集Ck。事实上,Ck是k维最大项目集的超集,通过函数count_support计算项目的支持度,然后生成Lk。 该函数是如何完成这些功能的, 详细说明如下: 首先, 通过对Lk-1自连接操作生成Ck,称join(连接)步,该步可表述为: insert into Ck select P.item1,P.item2,...,P.itemk-1,Q.itemk-1 from Lk-1P,Lk-1Q where P.item1=Q.item1,...,P.itemk-2=Q.itemk-2,P.itemk-1<Q.itemk-1 若用集合表示:Ck={X∪X'|X,X'∈Lk-1,|X∩X'|=k-2} 然后,是prune(修剪)步,即对任意的c,c∈Ck, 删除Ck中所有那些(k-1)维子集不在Lk-1 中的项目集,得到侯选项目集Ck。表述为： for all itemset c∈Ck for all (k-1)维子集s of c if(s不属于Lk-1) then delete c from Ck; 用集合表示:Ck={X∈Ck|X的所有k-1维子集在Lk-1中} 2.Apriori算法的举例 示例说明Apriori算法运作过程，有一数据库D, 其中有四个事务记录, 分别表示为 TID Items T1 I1,I3,I4 T2 I2,I3,I5 T3 I1,I2,I3,I5 T4 I2,I5 在Apriori算法中每一步创建该步的侯选集。统计每个侯选项目集的支持度,并和预定 义的最小支持度比较,来确定该步的最大项目集。 首先统计出一维项目集,即C1.这里预定义最小支持度minsupport=2,侯选项目集中满足最小支持度要求的项目集组合成最大的1-itemsets。为生成最大的2-itemsets,使用了sc_candidate函数中join步,即：L1joinL1，并通过prune步删除那些C2的那些子集不在L1中的项目集。生成了侯选项目集C2。搜索D中4个事务,统计C2中每个侯选项目集的支持度。然后和最小支持度比较,生成L2。侯选项目集C3是由L2生成.要求自连接的两个最大2-itemsets中,第一个项目相同,在L2中满足该条件的有{I2,I3},{I2,I5}.这两个集合经过join步后, 产生集合{I2，I3，I5}.在prune步中,测试{I2，I3，I5}的子集{I3，I5},{I2，I3},{I2，I5}是否在L2中,由L2可以知道{I3,I5},{I2,I3},{I2,I5}本身就是最大2-itemsets.即{I2,I3,I5}的子集都是最大项目集.那么{I2,I3,I5}为侯选3-itemset.然后搜索数据库中所有事务记录,生成最大的3-tiemsets L3。此时, 从L3中不能再生成侯选4-itemset 。Apriori算法结束. 算法的图例说明 五、实验结果 test.txt格式及内容如下： 实验结果如下： 六、实验总结 Apriori算法可以很有效地找出数据集中存在的关联规则且能找出最大项的关联规则，但从以上的算法执行过程可以看到Apriori算法的缺点: 第一,在每一步产生侯选项目集时循环产生的组合过多，没有排除不应该参与组合的元素；第二,每次计算项集的支持度时，都对数据库D中的全部记录进行了一遍扫描比较，如果是一个大型的数据库的话，这种扫描比较会大大增加计算机系统的I/O开销。而这种代价是随着数据库的记录的增加呈现出几何级数的增加。因此人们开始寻求一种能减少这种系统1/O开销的更为快捷的算法。 七、实验程序 function my_apriori(X,minsup) clc; %%%%主函数，输入X数据集，判断产生大于minsup最小支持度的关联规则 %%%%%%%%%%%%%%%%%%%%%%%%%%打开test.txt文件 file = textread('test.txt','%s','delimiter','\n','whitespace',''); [m,n]=size(file); for i=1:m words=strread(file{i},'%s','delimiter',' '); words=words'; X{i}=words; end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% minsup=0.3; %预先定义支持度 [m,N]=size(X); %求X的维数 temp=X{1}; %用已暂存变量存储所有不同项集 for i=2:N temp=union(temp,X{i}); %找出所有不同项（种类） end %%%%%%%%%%%%%%%%%%%%找出k-频繁项 L=Sc_candidate(temp); %找出2-项候选项集 sum=1; %统计满足条件的最多项集 while(~isempty(L{1})) %循环终止条件为第k次频繁项集为空 sum=sum+1; C=count_support(L,X,minsup); %挑选出满足最小支持度的k-频繁项 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sprintf('%s%d%s','满足要求的',sum,'次频繁项集依次为') %显 for i=1:size(C,1) %示 disp(C{i,1}); %部 end %分 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% L=gen_rule(C); %依次产生k-频繁项(依据apriori算法规则） End %%%%%%%%%%%%%%%%%%%%%%%%各个子程序如下 function y=cell_union(X,Y) %实现两cell元组合并功能,由k-1项集增加到k项集函数 [m,n]=size(X); if(~iscellstr(X)) %判断X是否元组 L{1}=X; L{1,2}=Y; else L=X; L{1,n+1}=Y; end y=L; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=count_support(L,X,minsup) %找出符合大于支持度sup的候选集,L为候选集，X为总数据集 X=X';%转置 %%%%%%%%%%%%%%%%%统计频繁项 [m,n]=size(L); [M,N]=size(X); count=zeros(m,1); for i=1:m for j=1:M if(ismember(L{i},X{j})) count(i)=count(i)+1; end end end %%%%%%%%%%%删除数据表中不频繁的项 p=1; C=cell(1); for i=1:m if(count(i)>minsup*M) %小于支持度的项为不频繁数，将删除,大于的保留 C{p}=L{i}; p=p+1; end end y=C'; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=gen_rule(C) %apriori算法规则判断是否产生k-候选项集 if(~isempty(C{1})) %判断C是否为空 [M,N]=size(C); [m,n]=size(C{1}); temp1=C; L=cell(1); for i=1:M temp2{i}=temp1{i}{n}; temp1{i}{n}=[]; end p=1; for i=1:M for j=i+1:M if(isequal(temp1{i},temp1{j})) %判断前k-1项候选集是否相等 L{p}=cell_union(C{i},temp2{j}); %若相等，则增加至k-项集 p=p+1; end end end y=L'; else y=cell(1);%否则y返回空 end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=Sc_candidate(C) %产生2-项候选集函数 C=C'; %转置 [m,n]=size(C); bcount=zeros(m*(m-1)/2,1); L=cell(m*(m-1)/2,1); p=1; for i=1:m-1 %注意 for j=i+1:m L{p}=cell_union(C{i},C{j}); %产生2-项候选集 p=p+1; end end y=L; function y=count_support(L,X,minsup) %找出符合大于支持度sup的候选集,L为候选集，X为总数据集
Ⅳ 关联规则挖掘算法的介绍
学号：17020110019 姓名：高少魁
【嵌牛导读】关联规则挖掘算法是数据挖掘中的一种常用算法，用于发现隐藏在大型数据集中令人感兴趣的频繁出现的模式、关联和相关性。这里将对该算法进行简单的介绍，之后通过Apriori算法作为实例演示算法执行结果。
【嵌牛鼻子】数据挖掘 关联规则挖掘 python
【嵌牛正文】
一、算法原理
1、基本概念
关联规则用于发现隐藏在大型数据集中令人感兴趣的频繁出现的模式、关联和相关性。 而 Apriori算法则是经典的挖掘频繁项集的关联规则算法，它通过层层迭代来寻找频繁项集，最后输出关联规则：首先扫描数据集，得到 1-频繁项集，记为 L1，通过合并 L1得到 2-频繁项集 L2，再通过 L2找到 L3，如此层层迭代，直到找不到频繁项集为止。
在Apriori算法中，定义了如下几个概念：
⚫ 项与项集 ：设 I={i1,i2,…,im}是由 m个不同项构成的集合，其中的每个 ik(k=1,2,…,m)被称为一个项 (Item)，项的集合 I被称为项集和，即项集。在实验中，每一条购物记录可以被看做 一个项集，用户购买的某个商品即为一个项。
⚫ 事务与事务集：神乎事务 T是项集 I的一个子集，而事务的全体被称为事务集。
⚫ 关联规则：形如 A=>B的表达式，其中， A和 B都属于项集 I，且 A与 B不相交。
⚫ 支持度：定义如下 support(A=>B) = P(A B)，即 A和 B所含的项在事务集中同时出现的概率。
⚫ 置信度：定义如下 confidence(A⇒B)=support(A⇒B)/support(A)=P(A B)/P(A)=P(B|A)，即如果事务包含 A，则事务中同时出现 B的概率。
⚫ 频繁项集：如果项集 I的支持度满足事先定义好的最小支持度阈慧液值（即 I的出现频度大于相应的最小出现频度阈值），则 I是频繁项集。
⚫ 强关联规则：满足最小支持度和最小置信度的关联规则，即待挖掘的关联规则。
根据以上概念，要实现关联规则的挖掘，首先要找到所有的频繁项集，之后找出强关联规则（即通过多次扫描数据集，找出频繁集，然后产生关联规则）。
2、挖掘频繁项集
在该步骤中有两个较为重要的部分 ：连接和修剪。连接步骤即使用k-1频繁项集，通过连接得到 k-候选项集，并且只有相差一个项的项集才能进行连接，如 {A,B}和 {B,C}连接成为 {A,B,C}。修剪步骤基于一个性质：一个 k-项集，如果它的一个 k-1项集（子集）不是频繁的，那么它本身也不可能是频繁的。 因此可以基于这个性质，通过判断先验性质来对候选集进行修剪。
3、产生关联规则
经过连接和修剪之后，即找到了所有的频繁项集，此时可以在此基础上产生关联规则，步骤如下
（1）对于每个频繁项集 l，产生 l的所有非空子集（这些非空子集一定是频繁项集）；
（2）对于 l的每一个非空子集 x，计算 confidence(x => (l-x))，如果 confidence(x => (l-x)) confmin，那么规则 x => (l-x)”成立。
二、算法设计
1、数据集
通过语句 import xlrd导入相关的库来进行数据的读取 。数据内容为十条购物记录 ，每条购物记录有若干个商品，表示某个顾客的购买记录 ，如图
对于数据加载部分 使用了 xlrd库中的函数 open_workbook来 打开一个表格文件，使用sheet_by_index函数得到一个工作表， row_values函数即可读取表格中的内容。由于每个购物记录的商品数不一定相同，导致读取的内容含有空格 (’ ’)，因此对数据进行删减以得到紧凑的数据 ，最终读取数据的结果以列表的游碧悉形式返回。
2、连接
对于连接部分，主要目标是根据已有的k-1频繁项集生成 k-候选频繁项集。算法步骤为：首先将项集中的项按照字典顺序排序，之后将 k-1项集中两个项作比较，如果两个项集中前 k-2个项是相同的，则可以通过或运算（|）将它们连接起来。
3、修剪
修剪操作主要使用一个判断函数，通过传入连接操作后的项集和之前的k-1频繁项集，对新的项集中的每一个项的补集进行判断，如果该补集不是 k-1频繁项集的子集，则证明新的项集不满足先验性质，即一个频繁项集的所有非空子集一定是频繁的 ，否则就满足先验形式。返回布尔类型的参数来供调用它的函数作判断。
经过连接和修剪步骤之后，项基要成为频繁项集还必须满足最小支持度的条件，笔者设计了generateFrequentItems函数来对连接、修剪后产生的 k-候选项集进行判断，通过遍历数据集，计算其支持度，满足最小支持度的项集即是 一个频繁项集，可将其返回。
以上，经过不断的遍历、连接、修剪、删除，可将得到的所有结果以列表形式返回。笔者还设计了字典类型的变量 support_data，以得到某个频繁项集及其支持度 。
4、挖掘关联规则
generateRules函数用来挖掘关联规则，通过传入 最小置信度、 频繁项集及其 支持度来生成规则 。根据定理：对于频繁项集 l的每一个非空子集 x，计算 confidence(x => (l-x))，如果 confidence(x => (l-x)) confmin，那么规则 x => (l-x)”成立，因此，该函数重点在扫描频繁项集，得到每一个子集，并计算置信度，当置信度满足条件（即大于等于最小置信度）时，生成一条规则。在函数中，使用了元组来表示一条规则，元组中包含 x、 l-x以及其置信度 ，最后返回生成的所有规则的列表。
三、算法执行结果
设置最大频繁项集数k为 3，最小支持度为 0.2，最小置信度为 0.8 使用 pycharm运行程序 ，得到以下结果：
由图中结果可以看出，对于频繁 1-项集，有五个满足的项集，频繁 2-项集有 6个，频繁 3-项集有 2个，它们都满足支持度大于或等于最小支持度 0.2。根据频繁项集，程序得到的关联规则有三条，即 {面包 }=>{牛奶 }，，{鸡蛋 }=>{牛奶 }，，{面包，苹果 }=>{牛奶 其中，这些规则的置信度都是 1.0，满足大于或等于最小置信度 0.8的条件 。
四、程序源码
Ⅳ 求MapRece实现Apriori代码
Apriori，主体分两步走：
a. 根据 原始数据 得到1 - k项集,再根据support（支持度）得到频繁1项集，频繁2项集，频繁3项集...... 一直到频繁k项集，这一步是运算量最大的，也是hadoop集群的瓶颈。
b. 根据 置信度 confidence ，得到所有强规则。
因为 b 步骤太简单，为了省事，我没写在算法里，算法里只求出了所有频繁集。而这一步骤也分为两步：
a. 迭代得到K项集，具体迭代方法就是将上一次迭代的结果k-1项集和1项集进行组合，从而得到K项集。
b. 根据支持度，得到频繁K项集，不断迭代a,b步骤，直到K为最大为止。
Ⅵ 鐢∕atlab瀹炵幇apriori绠楁硶鍏宠仈瑙勫垯镄勬寲鎺樼▼搴忥纴瀹屾暣链夎︾粏娉ㄨВ
涓嬮溃杩欐垫槸apriori绠楁硶涓鐢2棰戠箒椤归泦镓緆棰戠箒椤归泦镄勭▼搴忥纴绋嫔簭涓链変袱涓闂棰桡细
1銆佷技涔巜hile寰鐜镄凨姘歌繙閮芥槸锲哄畾镄勶纴涔熷氨鏄閮芥槸棰戠箒2椤归泦镄勪釜鏁般傚缑鍒伴戠箒3椤归泦钖嶬镄勪釜鏁颁笉鏄瑕佸彉钖楋纻濡备綍浣撶幇锻锛
2銆佺▼搴忎腑链変袱涓猣or镄勫ぇ寰鐜锛屼絾鏄鍙戠幇缁撴灉鏄鍙瑕佹垒鍒颁竴涓棰戠箒3椤归泦绗浜屼釜for寰鐜灏变细缁撴潫锛屼絾鏄鍏跺疄杩桦簲璇ユ湁鍏跺畠镄勯戠箒3椤归泦銆俧or寰鐜涓嶆槸搴旇ユ棤𨱒′欢镓ц屽埌鍙傛暟k缁撴潫钖楋纻褰撴椂k鍊兼槸15锛屽彲鏄绋嫔簭缁撴潫镄勬椂鍊檌=2锛宩=3,铹跺悗j灏变笉镓ц4浠ュ强涓鐩村埌k镄勯儴鍒嗕简銆傛槸浠涔埚师锲犲憿锛熼夯鐑﹂珮镓嬫寚镣逛竴涓嬨傛ュ晩钬︹
while( k>0)
le=length(candidate{1});
num=2;
nl=0;
for i=1:k-1
for j=i+1:k
x1=candidate{i}; %candidate鍒濆嫔间负棰戠箒2椤归泦锛岃繖涓琛ㄧず棰戠箒椤归泦镄勭琲椤
x2=candidate{j};
c = intersect(x1, x2);
M=0;
r=1;
nn=0;
l1=0;
if (length(c)==le-1) & (sum(c==x1(1:le-1))==le-1)
houxuan=union(x1(1:le),x2(le));
%镙戝壀鏋,鑻ヤ竴涓鍊欓夐”镄勬煇涓狵-1椤瑰瓙闆嗕负闱为戠箒锛屽垯鍓鏋濇帀
sub_set=subset(houxuan);
%鐢熸垚璇ュ欓夐”镄勬墍链块-1椤瑰瓙闆
NN=length(sub_set);
%鍒ゆ柇杩欎簺K-1椤硅嚜宸辨槸钖﹂兘涓洪戠箒镄
while(r & M<NN)
M=M+1;
r=in(sub_set{M},candidate);
end
if M==NN
nl=nl+1;
%鍊欓塳椤归泦
cand{nl}=houxuan;
%璁板綍姣忎釜鍊欓塳椤归泦鍑虹幇镄勬℃暟
le=length(cand{1});
for i=1:m
s=cand{nl};
x=X(i,:);
if sum(x(s))==le
nn=nn+1;
end
end
end
end
%浠庡欓夐泦涓镓鹃戠箒椤归泦
if nn>=th
ll=ll+1;
candmid{nl}=cand{nl};
pfxj(nl).element=cand{nl};
pfxj(nl).time=nn;
disp('寰楀埌镄勯戠箒椤归泦涓:')
result=(candmid{nl});
disp(result);
end
end
end
end
Ⅶ python哪个包实现apriori
要用apriori不需要哪个包，要有一个实现apriori功能的.py文件，将这个文件放置在你要调用的文件相同的地址，然后用fromaprioriimport*来使用。。
apriori.py下载地址：链接：https://pan..com/s/1XpKHfUXGDIXj7CcYJL0anA