apriori _生活经验

apriori算法有哪些优点?Apriori算法使用Apriori性质来生产候选项集的方法，大大压缩了频繁集的大小，取得了很好的性能。

Apriori算法的问题【apriori】不知道你知不知道什么叫泛型，你可以写成List ，然后在while中给transact赋值，比如说transact.setContener(contener)然后，把你需要的字段全部set进去，然后在transList.add(transact) 。ok问题解决。
如果你这都看不懂的话，建议去看看书

数据挖掘中的apriori算法的具体步骤是什么？算法：Apriori
输入：D - 事务数据库；min_sup - 最小支持度计数阈值
输出：L - D中的频繁项集
方法：
L1=find_frequent_1-itemsets(D); // 找出所有频繁1项集
For(k=2;Lk-1!=null;k++){
Ck=apriori_gen(Lk-1); // 产生候选，并剪枝
For each 事务t in D{ // 扫描D进行候选计数
Ct =subset(Ck,t); // 得到t的子集
For each 候选c 属于 Ct
c.count++;
}
Lk={c属于Ck | c.count>=min_sup}
}
Return L=所有的频繁集；

Procedure apriori_gen(Lk-1:frequent(k-1)-itemsets)
For each项集l1属于Lk-1
For each项集 l2属于Lk-1
If((l1[1]=l2[1])&&( l1[2]=l2[2])&&……..
&& (l1[k-2]=l2[k-2])&&(l1[k-1]<l2[k-1])) then{
c=l1连接l2 //连接步：产生候选
if has_infrequent_subset(c,Lk-1) then
delete c; //剪枝步：删除非频繁候选
else add c to Ck;
}
Return Ck;

Procedure has_infrequent_sub(c:candidate k-itemset; Lk-1:frequent(k-1)-itemsets)
For each(k-1)-subset s of c
If s不属于Lk-1 then
Return true;
Return false;

如何提高apriori算法的效率Apriori算法是关联规则挖掘中的经典算法。在Apriori算法中,使用频繁项集的先验知识,逐层搜索的迭代方法,通过扫描数据库,累积每个项的计数,并收集满足最小支持度的项,找每个Lk都需要扫描一次数据库。算法的效率随着数据量的增大,频繁项集的增多,算法的效率就非常的低,本文通过对Apriori算法分析,应用散列、事务压缩、划分、抽样等方法,最大可能的减少数据库扫描的次数,快速发现频繁项集,提高Apriori算法的效率。

apriori算法的伪代码是什么意思？伪代码要出现在程序里面吗？伪代码是一种介于编程语言和自然语言的东东，用于描述算法，目的是既便于阅读，稍加改变后就可直接形成程序代码。看来你初涉数据挖掘但没有计算机基础，伪代码属于基本概念。

什么是数据库?

文章插图

数据库就是储存数据的地方。在电脑中，在内存中，在硬盘中的东西都是存储在数据库中的数据。而这些数据所待的地方就叫做数据库。也可以称为电子化的“文件柜” 。在计算机科学与应用中的数据库意味着今后数据会越来越庞大，也意味着数据在以后的发展中在重多的科学还有应用中要运用到更多的数据。扩展资料：数据库管理系统可以依据它所支持的数据库模型来作分类，例如关系式、XML；或依据所支持的计算机类型来作分类，例如服务器群集、或依据所用查询语言来作分类，例如SQL、XQuery；或依据性能冲量重点来作分类，例如最大规模、最高运行速度的分类方式。不论使用哪种分类方式，一些DBMS能够跨类别，同时支持多种查询语言。早期比较流行的数据库模型有三种，而在当今的互联网中最常见的就是关系型数据库和非关系型数据库。参考资料：百度百科-数据库
数据库是什么意思？

文章插图

数据库，简而言之可视为电子化的文件柜——存储电子文件的处所，用户可以对文件中的数据进行新增、截取、更新、删除等操作。由于资料集中管理，电脑的资源便可由使用者共享，而且资料的保密及处理的一致性更容易达成。数据库将相关数据的集合存储在一起的，这些数据是结构化的，无有害的或不必要的冗余，并为多种应用服务；数据的存储独立于使用它的程序；对数据库插入新数据，修改和检索原有数据均能按一种公用的和可控制的方式进行。扩展资料：数据库一般具备具有存储、截取、安全保障、备份等基础功能的数据库管理系统。数据库管理系统可以依据它所支持的数据库模型来作分类，或依据所支持的计算机类型来作分类，或依据所用查询语言来作分类，或依据性能冲量重点来作分类。而且拥有有数据索引的功能。像是一本书前面几页都有目录，目录也算是索引的一种，只是它的分类较广，例如车牌、身份证字号、条码等，都是一个索引的号码，可以从号码中看出其中的端倪，若是要找的人、车或物品，也只要提供相关的号码，即可迅速查到正确的人事物。参考资料来源：百度百科——数据库
数据库中@代表什么意思

文章插图

数据库中＠代表是局部变量声明。用于存储过程中。格式是＠参数名数据类型［VARYING］［＝内定值］［OUTPUT］。每个参数名前要有一个“＠”符号，每一个存储过程的参数仅为该程序内部使用，参数的类型除了IMAGE外，其他SQL Server所支持的数据类型都可使用。扩展资料：在建立数据库时通过＠设定一个字段参数的默认值。如果＠的字段参数是既有输入又有输出值的，也就是在调用了这个存储过程时，如果所指定的参数值是需要输入的参数，同时也需要在结果中输出的，则该项必须为OUTPUT 。而如果＠的字段参数只是做输出参数用，则可以用CURSOR，同时在使用该参数时，必须指定VARYING和OUTPUT这两个语句。
数据库是干什么用的呢

文章插图

数据库是以一定方式储存在一起、能与多个用户共享、具有尽可能小的冗余度、与应用程序彼此独立的数据集合，可视为电子化的文件柜——存储电子文件的处所，用户可以对文件中的数据进行新增、查询、更新、删除等操作。数据库是存放数据的仓库。它的存储空间很大，可以存放百万条、千万条、上亿条数据。但是数据库并不是随意地将数据进行存放，是有一定的规则的，否则查询的效率会很低。当今世界是一个充满着数据的互联网世界，充斥着大量的数据。即这个互联网世界就是数据世界。数据的来源有很多，比如出行记录、消费记录、浏览的网页、发送的消息等等。除了文本类型的数据，图像、音乐、声音都是数据。扩展资料：数据库发展现状在数据库的发展历史上，数据库先后经历了层次数据库、网状数据库和关系数据库等各个阶段的发展，数据库技术在各个方面的快速的发展。特别是关系型数据库已经成为目前数据库产品中最重要的一员，80年代以来，几乎所有的数据库厂商新出的数据库产品都支持关系型数据库，即使一些非关系数据库产品也几乎都有支持关系数据库的接口。参考资料来源：百度百科-数据参考资料来源：百度百科-数据库
利用Apriori算法产生频繁项集，（min sup=0.6），给出具体计算过程？Apriori算法是一种发现频繁项集的基本算法。算法使用频繁项集性质的先验知识。Apriori算法使用一种称为逐层搜索的迭代方法，其中K项集用于探索(k+1)项集。首先，通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合。该集合记为L1.然后，使用L1找出频繁2项集的集合L2，使用L2找到L3，如此下去，直到不能再找到频繁k项集。Apriori算法的主要步骤如下：(1)扫描事务数据库中的每个事务，产生候选1．项集的集合Cl；(2)根据最小支持度min_sup，由候选l-项集的集合Cl产生频繁1一项集的集合Ll；(3)对k=l；(4)由Lk执行连接和剪枝操作，产生候选(k+1)．项集的集合Ck+l-(5)根据最小支持度min_sup，由候选(k+1)一项集的集合Ck+l产生频繁(k+1)-项集的集合Lk+1．(6)若L?≠①，则k．k+1，跳往步骤(4)；否则，跳往步骤(7)；(7)根据最小置信度min_conf,由频繁项集产生强关联规则，结束。

apriori算法找频繁项集这是我的解题过程，希望你能看明白，或者你已经有正确答案了，也希望能共享一下！谢谢
如何实现apriori算法import java.util.HashMap;import java.util.HashSet;import java.util.Iterator;import java.util.Map;import java.util.Set;import java.util.TreeMap;/*** 关联规则挖掘：Apriori算法* * 按照Apriori算法的基本思想来实现* * @author king* @since 2013/06/27* */public class Apriori { private Map> txDatabase; // 事务数据库 private Float minSup; // 最小支持度 private Float minConf; // 最小置信度 private Integer txDatabaseCount; // 事务数据库中的事务数private Map>> freqItemSet; // 频繁项集集合 private Map, Set>> assiciationRules; // 频繁关联规则集合public Apriori(Map> txDatabase,Float minSup,Float minConf) {this.txDatabase = txDatabase;this.minSup = minSup;this.minConf = minConf;this.txDatabaseCount = this.txDatabase.size();freqItemSet = new TreeMap>>();assiciationRules = new HashMap, Set>>(); }/** * 扫描事务数据库，计算频繁1-项集 * @return */ public Map, Float> getFreq1ItemSet() {Map, Float> freq1ItemSetMap = new HashMap, Float>();Map, Integer> candFreq1ItemSet = this.getCandFreq1ItemSet();Iterator, Integer>> it = candFreq1ItemSet.entrySet().iterator();while(it.hasNext()) {Map.Entry, Integer> entry = it.next();// 计算支持度Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);if(supported>=minSup) {freq1ItemSetMap.put(entry.getKey(), supported);}}return freq1ItemSetMap; }/** * 计算候选频繁1-项集 * @return */ public Map, Integer> getCandFreq1ItemSet() {Map, Integer> candFreq1ItemSetMap = new HashMap, Integer>();Iterator>> it = txDatabase.entrySet().iterator();// 统计支持数，生成候选频繁1-项集while(it.hasNext()) {Map.Entry> entry = it.next();Set itemSet = entry.getValue();for(String item : itemSet) {Set key = new HashSet();key.add(item.trim());if(!candFreq1ItemSetMap.containsKey(key)) {Integer value = https://www.zaoxu.com/jjsh/bkdq/1;candFreq1ItemSetMap.put(key, value);}else {Integer value = 1+candFreq1ItemSetMap.get(key);candFreq1ItemSetMap.put(key, value);}}}return candFreq1ItemSetMap; }/** * 根据频繁(k-1)-项集计算候选频繁k-项集 ** @param m 其中m=k-1 * @param freqMItemSet 频繁(k-1)-项集 * @return */ public Set> aprioriGen(int m, Set> freqMItemSet) {Set> candFreqKItemSet = new HashSet>();Iterator> it = freqMItemSet.iterator();Set originalItemSet = null;while(it.hasNext()) {originalItemSet = it.next();Iterator> itr = this.getIterator(originalItemSet, freqMItemSet);while(itr.hasNext()) {Set identicalSet = new HashSet(); // 两个项集相同元素的集合(集合的交运算)identicalSet.addAll(originalItemSet);Set set = itr.next();identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet与set集合中公有的元素if(identicalSet.size() == m-1) { // (k-1)-项集中k-2个相同Set differentSet = new HashSet(); // 两个项集不同元素的集合(集合的差运算)differentSet.addAll(originalItemSet);differentSet.removeAll(set); // 因为有k-2个相同，则differentSet中一定剩下一个元素，即differentSet大小为1differentSet.addAll(set); // 构造候选k-项集的一个元素(set大小为k-1,differentSet大小为k)if(!this.has_infrequent_subset(differentSet, freqMItemSet))candFreqKItemSet.add(differentSet); // 加入候选k-项集集合}}}return candFreqKItemSet; }/*** 使用先验知识，剪枝。若候选k项集中存在k-1项子集不是频繁k-1项集，则删除该候选k项集* @param candKItemSet* @param freqMItemSet* @return*/ private boolean has_infrequent_subset(Set candKItemSet, Set> freqMItemSet) {Set tempSet = new HashSet();tempSet.addAll(candKItemSet);Iterator itItem = candKItemSet.iterator();while(itItem.hasNext()) {String item = itItem.next();tempSet.remove(item);// 该候选去掉一项后变为k-1项集if(!freqMItemSet.contains(tempSet))// 判断k-1项集是否是频繁项集return true;tempSet.add(item);// 恢复}return false; }/** * 根据一个频繁k-项集的元素(集合) ，获取到频繁k-项集的从该元素开始的迭代器实例 * @param itemSet * @param freqKItemSet 频繁k-项集 * @return */ private Iterator> getIterator(Set itemSet, Set> freqKItemSet) {Iterator> it = freqKItemSet.iterator();while(it.hasNext()) {if(itemSet.equals(it.next())) {break;}}return it; }/** * 根据频繁(k-1)-项集，调用aprioriGen方法，计算频繁k-项集 ** @param k* @param freqMItemSet 频繁(k-1)-项集 * @return */ public Map, Float> getFreqKItemSet(int k, Set> freqMItemSet) {Map, Integer> candFreqKItemSetMap = new HashMap, Integer>();// 调用aprioriGen方法，得到候选频繁k-项集Set> candFreqKItemSet = this.aprioriGen(k-1, freqMItemSet);// 扫描事务数据库Iterator>> it = txDatabase.entrySet().iterator();// 统计支持数while(it.hasNext()) {Map.Entry> entry = it.next();Iterator> kit = candFreqKItemSet.iterator();while(kit.hasNext()) {Set kSet = kit.next();Set set = new HashSet();set.addAll(kSet);set.removeAll(entry.getValue()); // 候选频繁k-项集与事务数据库中元素做差运算if(set.isEmpty()) { // 如果拷贝set为空，支持数加1if(candFreqKItemSetMap.get(kSet) == null) {Integer value = 1;candFreqKItemSetMap.put(kSet, value);}else {Integer value = 1+candFreqKItemSetMap.get(kSet);candFreqKItemSetMap.put(kSet, value);}}}}

我用spss clementine中的 Apriori做数据挖掘,怎么得到的支持度和置信度值不对呢spss clementine
的定义有问题，他的支持度其实是前向的出现概率
和统计定义不同，你选择条件支持度
统计研究生专业数据分析

数据挖掘关联规则中的“支持度”和“置信度”一般设为多少？《数据挖掘：概念与技术》上面写到：
“关联规则被认为是有趣的，如果它满足最小支持度阈值和最小置信度阈值。这些阈值可以由用户或领域专家设定。”

我认为可以根据你现有的数据集，做实验，通过实验结果来确定那个阈值比较合理。因为阈值与数据集是有很大关系的。

关联规则apriori算法用什么软件做1.1什么是关联规则
一言蔽之，关联规则是形如X→Y的蕴涵式，表示通过X可以推导“得到”Y，其中X和Y分别称为关联规则的先导(antecedent或left-hand-side, LHS)和后继(consequent或right-hand-side, RHS)
1.2如何量化关联规则
关联规则挖掘的一个典型例子便是购物车分析。通过关联规则挖掘能够发现顾客放入购物车中的不同商品之间的关联，分析顾客的消费习惯。这种关联规则的方向能够帮助卖家了解哪些商品被顾客频繁购买，从而帮助他们开发更好的营销策略。比如：将经常同时购买的商品摆近一些，以便进一步刺激这些商品一起销售；或者，将两件经常同时购买的商品摆远一点，这样可能诱发买这两件商品的用户一路挑选其他商品。
在数据挖掘当中，通常用“支持度”（support）和“置性度”（confidence）两个概念来量化事物之间的关联规则。它们分别反映所发现规则的有用性和确定性。比如：
Computer => antivirus_software , 其中 support=2%, confidence=60%
表示的意思是所有的商品交易中有2%的顾客同时买了电脑和杀毒软件，并且购买电脑的顾客中有60%也购买了杀毒软件。在关联规则的挖掘过程中，通常会设定最小支持度阈值和最小置性度阈值，如果某条关联规则满足最小支持度阈值和最小置性度阈值，则认为该规则可以给用户带来感兴趣的信息。
1.3关联规则挖掘过程
1）几个基本概念：
关联规则A->B的支持度support=P(AB)，指的是事件A和事件B同时发生的概率。
置信度confidence=P(B|A)=P(AB)/P(A),指的是发生事件A的基础上发生事件B的概率。
同时满足最小支持度阈值和最小置信度阈值的规则称为强规则。
如果事件A中包含k个元素，那么称这个事件A为k项集，并且事件A满足最小支持度阈值的事件称为频繁k项集。
2）挖掘过程：
第一，找出所有的频繁项集；
第二，由频繁项集产生强规则。
2．什么是Apriori
2.1Apriori介绍
Apriori算法使用频繁项集的先验知识，使用一种称作逐层搜索的迭代方法，k项集用于探索(k+1)项集。首先，通过扫描事务（交易）记录，找出所有的频繁1项集，该集合记做L1，然后利用L1找频繁2项集的集合L2，L2找L3，如此下去，直到不能再找到任何频繁k项集。最后再在所有的频繁集中找出强规则，即产生用户感兴趣的关联规则。
其中，Apriori算法具有这样一条性质：任一频繁项集的所有非空子集也必须是频繁的。因为假如P(I)< 最小支持度阈值，当有元素A添加到I中时，结果项集（A∩I）不可能比I出现次数更多。因此A∩I也不是频繁的。
2.2连接步和剪枝步
在上述的关联规则挖掘过程的两个步骤中，第一步往往是总体性能的瓶颈。Apriori算法采用连接步和剪枝步两种方式来找出所有的频繁项集。
1）连接步
为找出Lk（所有的频繁k项集的集合），通过将Lk-1（所有的频繁k-1项集的集合）与自身连接产生候选k项集的集合。候选集合记作Ck 。设l1和l2是Lk-1中的成员。记li[j]表示li中的第j项。假设Apriori算法对事务或项集中的项按字典次序排序，即对于（k-1）项集li，li[1]<li[2]<……….<li[k-1] 。将Lk-1与自身连接，如果(l1[1]=l2[1])&&( l1[2]=l2[2])&&……..&& (l1[k-2]=l2[k-2])&&(l1[k-1]<l2[k-1]) ，那认为l1和l2是可连接。连接l1和l2 产生的结果是{l1[1],l1[2],……,l1[k-1],l2[k-1]} 。
2）剪枝步
CK是LK的超集，也就是说， CK的成员可能是也可能不是频繁的。通过扫描所有的事务（交易），确定CK中每个候选的计数，判断是否小于最小支持度计数，如果不是，则认为该候选是频繁的。为了压缩Ck,可以利用Apriori性质：任一频繁项集的所有非空子集也必须是频繁的，反之，如果某个候选的非空子集不是频繁的，那么该候选肯定不是频繁的，从而可以将其从CK中删除。
（Tip：为什么要压缩CK呢？因为实际情况下事务记录往往是保存在外存储上，比如数据库或者其他格式的文件上，在每次计算候选计数时都需要将候选与所有事务进行比对，众所周知，访问外存的效率往往都比较低，因此Apriori加入了所谓的剪枝步，事先对候选集进行过滤，以减少访问外存的次数。）

关于数据挖掘中的apriori算法，帮忙推出关联规则事务数为 5 支持度为0.6，置信度为0.6abc的支持数P1=3，acd的支持数P2=3，bcd的支持数P3=3，关联规则的输出就是在由频繁项集的项组成的关联规则中，找出置信度大于等于最小置信度阈值的关联规则。因为由频繁项集的项组成的关联规则的支持度大于等于最小支持阈值，所以规则产生过程就是在由频繁项集的项组成的关联规则中，找出置信度大于等于最小置信度阈值的强关联规则，基本步骤如下：
1）对于每个频繁项集L，产生L的所有非空真子集。
2）对于L的每个非空真子集，如果L的支持计数除以的支持计数大于等于最小置信度阈值min_conf，则输出强关联规则 =>（L- ）。
例如：abc的非空真子集有a，b ， c ， ab，ac，bc 。分别算出他们的支持数，再除以abc的支持数，若结果大于0.6则可输出强关联规则。Pa/P1=4/3>0.6,则可以输出关联规则：a=>bc；同理可输出强关联规则：b=>ac，c=>ab；
同理，对于acd，bcd采用同样地方法。

请教推荐算法中关联规则的最小支持度和最小置信度如何确认apriori算法有支持度和置信度两个概念，都是在执行算法之前自己设定的，在每一次迭代过程后，大于支持度的项集被保留为频繁项集，最后生成的规则由最终的频繁项集组成，简单说也就是支持度越小，频繁项集越多，置信度越小

python哪个包实现apriori如连接中的例子，虽然新的{I1, I2, I3, I4}项集满足子集{I1, I2, I3}; {I1, I2, I4} 都是频繁项集，但其他子集也得满足，这里特指剩下两个{I1, I3, I4},{I2, I3, I4} 。所以验证一下他们，如果他们不满足，可根据定理1 ，新的项集也肯定不频繁。

所以剪枝的过程就是验证Ck中所有项集的所有k-1子集是否都频繁（只要看看他们是不是在Lk-1集合中即可），这样虽然要检查很多遍，但不需要对整个数据库进行遍历就能筛去许多不满足的情况。

上述方法是经典的Apriori算法，这两个步骤在k较高（3或以上）时效果非常好，因为商品同时存在的可能性会随k增大显著减小。

但是在k=2的时候（k=1用不到Apriori算法，必须遍历一遍数据库，相当于“链引发”），因为1项集一般都是频繁的，所以上述两个步骤基本上相当于没有用，还得遍历C(n,2)次数据库， n为频繁1项集的数量。

有大神会用Python做关联规则apriori算法吗#include #include using namespace std; class Vector { private: int size, length; int * data; public: Vector(int input_size) { size = input_size; length = 0; data = https://www.zaoxu.com/jjsh/bkdq/new int[size]; } }; int main() { int n; cin >> n; Vector arr(n)...

python apriori算法代码怎么实现class Apriori(object):def __init__(self, filename, min_support, item_start, item_end):self.filename = filenameself.min_support = min_support # 最小支持度self.min_confidence = 50self.line_num = 0 # item的行数self.item_start = item_start #取哪行的itemself.item_end = item_endself.location = [[i] for i in range(self.item_end - self.item_start + 1)]self.support = self.sut(self.location)self.num = list(sorted(set([j for i in self.location for j in i])))# 记录itemself.pre_support = [] # 保存前一个support,location,numself.pre_location = []self.pre_num = []self.item_name = [] # 项目名self.find_item_name()self.loop()self.confidence_sup()def deal_line(self, line):"提取出需要的项"return [i.strip() for i in line.split(' ') if i][self.item_start - 1:self.item_end]def find_item_name(self):"根据第一行抽取item_name"with open(self.filename, 'r') as F:for index,line in enumerate(F.readlines()):if index == 0:self.item_name = self.deal_line(line)breakdef sut(self, location):"""输入[[1,2,3],[2,3,4],[1,3,5]...]输出每个位置集的support [123,435,234...]"""with open(self.filename, 'r') as F:support = [0] * len(location)for index,line in enumerate(F.readlines()):if index == 0: continue# 提取每信息item_line = self.deal_line(line)for index_num,i in enumerate(location):flag = 0for j in i:if item_line[j] != 'T':flag = 1breakif not flag:support[index_num] += 1self.line_num = index # 一共多少行,出去第一行的item_namereturn supportdef select(self, c):"返回位置"stack = []for i in self.location:for j in self.num:if j in i:if len(i) == c:stack.append(i)else:stack.append([j] + i)# 多重列表去重import itertoolss = sorted([sorted(i) for i in stack])location = list(s for s,_ in itertools.groupby(s))return locationdef del_location(self, support, location):"清除不满足条件的候选集"# 小于最小支持度的剔除for index,i in enumerate(support):if iself.min_confidence:print ','.join(s) , '->>' , self.item_name[each_location[index]] , ' min_support: ' , str(support) + '%' , ' min_confidence:' , str(confidence) + '%'def main():c = Apriori('basket.txt', 14, 3, 13)d = Apriori('simple.txt', 50, 2, 6)if __name__ == '__main__':main()Apriori(filename, min_support, item_start, item_end)参数说明filename:(路径)文件名min_support:最小支持度item_start:item起始位置item_end:item结束位置import aprioric = apriori.Apriori('basket.txt', 11, 3, 13)输出：
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算法使用了什么性质Apriori性质：一个频繁项集的任一子集也应该是频繁项集。证明根据定义，若一个项集I不满足最小支持度阈值min_sup，则I不是频繁的，即P（I）<min_sup 。若增加一个项A到项集I中，则结果新项集（I∪A）也不是频繁的，在整个事务数据库中所出现的次数也不可能多于原项集I出现的次数，因此P（I∪A）<min_sup，即（I∪A）也不是频繁的。这样就可以根据逆反公理很容易地确定Apriori性质成立。
http://baike.baidu.com/link?url=8F29ZS1ufQ4gtAsaXsyZr_lOEn0I6VOGVoeszB7nCesMkZxU4vWNKnHeDyKWvXjSjTYiRtLoLs1OJ_Eut632ia

python apriori包怎么使用classApriori(object):def__init__(self,filename,min_support,item_start,item_end):self.filename=filenameself.min_support=min_support#最小支持度self.min_confidence=50self.line_num=0#item的行数self.item_start=item_start#取哪行的itemself.item_end=item_endself.location=[[i]foriinrange(self.item_end-self.item_start+1)]self.support=self.sut(self.location)self.num=list(sorted(set([jforiinself.locationforjini])))#记录itemself.pre_support=[]#保存前一个support,location,numself.pre_location=[]self.pre_num=[]self.item_name=[]#项目名self.find_item_name()self.loop()self.confidence_sup()defdeal_line(self,line):"提取出需要的项"return[i.strip()foriinline.split('')ifi][self.item_start-1:self.item_end]deffind_item_name(self):"根据第一行抽取item_name"withopen(self.filename,'r')asF:forindex,lineinenumerate(F.readlines()):ifindex==0:self.item_name=self.deal_line(line)breakdefsut(self,location):"""输入[[1,2,3],[2,3,4],[1,3,5]]输出每个位置集的support[123,435,234]"""withopen(self.filename,'r')asF:support=[0]*len(location)forindex,lineinenumerate(F.readlines()):ifindex==0:continue#提取每信息item_line=self.deal_line(line)forindex_num,iinenumerate(location):flag=0forjini:ifitem_line[j]!='T':flag=1breakifnotflag:support[index_num]+=1self.line_num=index#一共多少行,出去第一行的item_namereturnsupportdefselect(self,c):"返回位置"stack=[]foriinself.location:forjinself.num:ifjini:iflen(i)==c:stack.append(i)else:stack.append([j]+i)#多重列表去重importitertoolss=sorted([sorted(i)foriinstack])location=list(sfors,_initertools.groupby(s))returnlocationdefdel_location(self,support,location):"清除不满足条件的候选集"#小于最小支持度的剔除forindex,iinenumerate(support):ifiself.min_confidence:print','.join(s),'->>',self.item_name[each_location[index]],'min_support:',str(support)+'%','min_confidence:',str(confidence)+'%'defmain():c=Apriori('basket.txt',14,3,13)d=Apriori('simple.txt',50,2,6)if__name__=='__main__':main()Apriori(filename,min_support,item_start,item_end)参数说明filename:(路径)文件名min_support:最小支持度item_start:item起始位置item_end:item结束位置importaprioric=apriori.Apriori('basket.txt',11,3,13)输出：

python 有apriori算法的模块吗Apriori算法是数据挖掘中频发模式挖掘的鼻祖，从60年代就开始流行，其算法思想也十分简单朴素，首先挖掘出长度为1的频繁模式，然后k=2
将这些频繁模式合并组成长度为k的频繁模式，算出它们的频繁次数，而且要保证其所有k-1长度的子集也是频繁的，值得注意的是，为了避免重复，合并的时候，只合并那些前k-2个字符都相同，而k-1的字符一边是少于另一边的。
以下是算法的Python实现：

[python] view plain copy print?
__author__ = 'linfuyuan'
min_frequency = int(raw_input('please input min_frequency:'))
file_name = raw_input('please input the transaction file:')
transactions = []

def has_infrequent_subset(candidate, Lk):
for i in range(len(candidate)):
subset = candidate[:-1]
subset.sort()
if not ''.join(subset) in Lk:
return False
lastitem = candidate.pop()
candidate.insert(0, lastitem)
return True

def countFrequency(candidate, transactions):
count = 0
for transaction in transactions:
if transaction.issuperset(candidate):
count += 1
return count

with open(file_name) as f:
for line in f.readlines():
line = line.strip()
tokens = line.split(',')
if len(tokens) > 0:
transaction = set(tokens)
transactions.append(transaction)
currentFrequencySet = {}
for transaction in transactions:
for item in transaction:
time = currentFrequencySet.get(item, 0)
currentFrequencySet[item] = time + 1
Lk = set()
for (itemset, count) in currentFrequencySet.items():
if count >= min_frequency:
Lk.add(itemset)
print ', '.join(Lk)

while len(Lk) > 0:
newLk = set()
for itemset1 in Lk:
for itemset2 in Lk:
cancombine = True
for i in range(len(itemset1)):
if i < len(itemset1) - 1:
cancombine = itemset1[i] == itemset2[i]
if not cancombine:
break
else:
cancombine = itemset1[i] < itemset2[i]
if not cancombine:
break
if cancombine:
newitemset = []
for char in itemset1:
newitemset.append(char)
newitemset.append(itemset2[-1])
if has_infrequent_subset(newitemset, Lk) and countFrequency(newitemset, transactions) >= min_frequency:
newLk.add(''.join(newitemset))
print ', '.join(newLk)
Lk = newLk

scikit-learn 是不是没有 Apriori，FP-Growth 的 APIscikit-learn 是不是没有 Apriori，FP-Growth 的 API
Python开源工具包：scikit-learn 是关于机器学习的开发包，主页：http://scikit-learn.org/stable/index.html
这个包把经典的机器学习算法都利用python进行了实现，是学习机器学习很好理论与实践结合材料，但是在安装scikit-learn 出现各种奇怪问题，这里做一个总结。
为了方便以后python各类工具包安装，可以先安装python easy_install

在weka中apriori算法无法使用?。ㄎ业氖菔谴觘xcel格式转换成csv格式导入weka中）numeric就不是离散的，需要做预处理。
用NumericalToNominal过滤器离散化

sklearn 为什么没有apriori算法本剧已经确定被删的剧目有：

问读音：null，Apriori，FP-Growth的读法汉语标出可真不准确，不方便啊
servlet /sə:vlit/--/se wu li te/
HTML 就是一个一个字母的读，它是hyper text markup language简写
null /nʌl/--/na ou/

apriori 英文发音为:/əpriɔri/--/e pe rui ao rui/
FP-Growth 英文发音为：/aif pi: grəuθ/--/F P-ge rou si/
前面一个词一般读中文普瑞奥瑞
后面的一个词直接读英文

用Matlab实现apriori算法关联规则的挖掘程序，完整有详细注解下面这段是apriori算法中由2频繁项集找k频繁项集的程序，程序中有两个问题：
1、似乎while循环的K永远都是固定的，也就是都是频繁2项集的个数。得到频繁3项集后K的个数不是要变吗？如何体现呢？
2、程序中有两个for的大循环，但是发现结果是只要找到一个频繁3项集第二个for循环就会结束，但是其实还应该有其它的频繁3项集。for循环不是应该无条件执行到参数k结束吗？当时k值是15 ，可是程序结束的时候i=2，j=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项集，这个表示频繁项集的第i项
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));
%树剪枝,若一个候选项的某个K-1项子集为非频繁，则剪枝掉
sub_set=subset(houxuan);
%生成该候选项的所有K-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;
%候选k项集
cand{nl}=houxuan;
%记录每个候选k项集出现的次数
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

求用Matlab实现apriori算法关联规则的挖掘程序,完整有详细注解毕业设计要用的http://www.pudn.com/downloads355/sourcecode/math/detail1548181.html

谁有matlab实现关联规则Apriori算法的程序包啊，做项目急求，非常感谢啊下面这段是apriori算法中由2频繁项集找k频繁项集的程序，程序中有两个问题：
1、似乎while循环的K永远都是固定的，也就是都是频繁2项集的个数。得到频繁3项集后K的个数不是要变吗？如何体现呢？
2、程序中有两个for的大循环，但是发现结果是只要找到一个频繁3项集第二个for循环就会结束，但是其实还应该有其它的频繁3项集。for循环不是应该无条件执行到参数k结束吗？当时k值是15，可是程序结束的时候i=2 ， j=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项集，这个表示频繁项集的第i项
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));
%树剪枝,若一个候选项的某个K-1项子集为非频繁，则剪枝掉
sub_set=subset(houxuan);
%生成该候选项的所有K-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;
%候选k项集
cand{nl}=houxuan;
%记录每个候选k项集出现的次数
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

求个实现关联规则挖掘的Apriori算法的代码Apriori算法改进与实现研究
文章摘要：传统的关联规则挖掘的Apriori算法的时间开销要大，建议挖掘ORAR的基于关系代数理论的关联规则算法，不仅要扫描一次数据库使用大量的模拟实验证明改善关系matrix.Through ORAR算法是非常有效的，根据收集运行时间集中频繁项减少大量开挖。
关键词：Apriori算法; ORAR;改进;关系矩阵的关联规则

在线急求apriori算法，要求能实现关联规则摘要
随着信息时代的发展，信息量呈几何级数增长，人们发现从这些海量信息中获取有用的信息越来越困难，要找出信息背后隐藏的规律更是不可想象。数据挖掘就是从大量数据中获取有用信息的一门新技术，关联规则挖掘是数据挖掘方法中的一种。本文详细论述了基于Apriori算法的关联规则挖掘系统的设计开发过程。系统基于经典的Apriori算法，对事务数据库进行了位图矩阵转换，大大提高了搜索效率，并能分别挖掘频繁项集和关联规则。
论文组织如下：首先介绍了数据挖掘的产生、定义和应用；接着阐述了关联规则挖掘的基本概念；然后对系统的需求进行了分析，并提出设计方案；紧接着是系统的具体实现；最后对系统进行了测试，将系统用于挖掘中药方剂库中的药对药组，验证了系统的正确性和实用性。
关键词：数据挖掘；关联规则；Apriori算法

需求分析和设计方案
4.1需求分析
由于事务数据库一般只具有对大量数据的存取、检索功能，对于用户的一般性的使用可以满足，然而，正是由于数据库中存放了大量的数据，不同的数据项，以及多个数据项之间还存在有大量的隐含的、未知的、有意义的数据关系，这些关系对于用户有着及其重要的作用，所以数据挖掘便在此情况下产生了。而关联规则挖掘是数据挖掘中一个重要规则，Apriori算法又是关联挖掘的一个经典算法，它能发现大量数据中项集之间有趣的关联和相关联系。随着大量数据不停地收集和存储，许多业界人士对于从他们的数据库中挖掘关联规则越来越感兴趣。从大量商务事务记录中发现有趣的关联关系，可以帮助许多商务决策的制定，如分类设计、交叉购物和促销分析。

1引言
随着数据库技术的迅速发展以及数据库管理系统的广泛应用，人们积累的数据越来越多。激增的数据背后隐藏着许多重要的信息，人们希望能够对其进行更高层次的分析，以便更好地利用这些数据。目前的数据库系统可以高效地实现数据的录入、查询、统计等功能，但无法发现数据中存在的关系和规则，无法根据现有的数据预测未来的发展趋势。缺乏找出数据背后隐藏的知识的手段，导致了“数据爆炸但知识贫乏”的现象。于是数据挖掘技术应运而生，并显示出强大的生命力。数据挖掘就是从大量的、不完全的、有噪声的、模糊的、随机的数据中，提取隐含在其中的、人们事先不知道的、但又是潜在有用的信息和知识的过程。它使人类分析问题和发现知识能力得到了延伸。
2数据挖掘概述
2.1数据挖掘的产生
随着信息时代的发展，信息量呈几何级数增长，然而用于对这些数据进行分析处理的工具却很少，人们拥有了海量的数据的同时却苦于信息的缺乏。而激增的数据背后隐藏着许多重要的信息，人们希望能够对其进行更高层次的分析，以便更好地利用这些数据。目前的数据库系统可以高效地实现数据的录入、查询、统计等功能，但无法发现数据中存在的关系和规则，无法根据现有的数据预测未来的发展趋势。缺乏挖掘数据背后隐藏的知识的手段，导致了“数据爆炸但知识贫乏”的现象。信息爆炸是一把双刃剑：巨量的信息既是最重要的财富，又是最危险的杀手。巨量信息也导致决策与理解危机。面对“人人被数据淹没，人们却饥饿于知识”的挑战，数据挖掘和知识发现技术应运而生，并得以蓬勃发展，越来越显示出其强大的生命力。
数据挖掘是信息技术自然演化的结果。演化过程的见证是数据库业界开发以下功能：数据收集和数据库创建，数据管理（包括数据存储和检索，数据库事务处理），以及数据分析与理解（涉及数据仓库和数据挖掘）。例如，数据收集和数据库创建机制的早期开发已成为稍后数据存储和检索、查询和事务处理有效机制开发的必备基础。随着提供查询和事务处理的大量数据库系统广泛付诸实践，数据分析和理解自然成为下一个目标。
2.2数据挖掘的定义
数据挖掘是从大量数据中提取或“挖掘”知识。具体来说，数据挖掘就是从大量的、不完全的、有噪声的、模糊的、随机的数据中，提取隐含在其中的、人们事先不知道的、但又是潜在有用的信息和知识的过程。
人们把原始数据看作是形成知识的源泉，就像从矿石中采矿一样。原始数据有结构化的，如关系数据库中的数据，也有半结构化的，如文本、图形、图像数据，甚至是分布在网络上的异构型数据。发现知识的方法可以是数学的，也可以是非数学的;可以是演绎的，也可以是归纳的。发现了的知识可以被用于信息管理、查询优化、决策支持、过程控制等，还可以用于数据自身的维护。因此，数据挖掘是一门很广义的交叉学科，它汇聚了不同领域的研究者，尤其是数据库、人工智能、数理统计、可视化、并行计算等方面的学者和工程技术人员。
数据挖掘使用复杂的统计分析和建模技术来揭示企业数据库中隐藏的模式与关系——而这些模式是有可能被普通的方法所忽略的。数据挖掘从数据的分析入手、帮助决策，能从数据中寻找有价值的规律的技术。同时它也代表一个分析过程，我们具体化为方法学。实际上，数据库中的知识发现是一门交叉性学科，涉及到机器学习、模式识别、统计学、智能数据库、知识获取、数据可视化、高性能计算、专家系统等多个领域。从数据库中发现出来的知识可以用在信息管理、过程控制、科学研究、决策支持等许多方面。
特别要指出的是，数据挖掘技术从一开始就是面向应用的。它不仅是面向特定数据库的简单检索查询调用，而且要对这些数据进行微观、中观乃至宏观的统计、分析、综合和推理，以指导实际问题的求解，企图发现事件间的相互关联，甚至利用已有的数据对未来的活动进行预测。
许多人把数据挖掘视为另一个常用的术语数据库中的知识发现或KDD (knowledge discovery in databases)的同义词。而另一些人只是把数据挖掘视为数据库中知识发现过程的一个基本步骤。知识发现过程如图1所示，由以下步骤组成：
1) 数据清理（消除噪声或不一致数据）
2) 数据集成（多种数据源可以组合在一起）
3) 数据选择（从数据库中检索与分析任务相关的数据）
4) 数据变换（数据变换或统一成适合挖掘的形式，如通过汇总或聚集操作）
5) 数据挖掘（基本步骤，使用智能方法提取数据模式）
6) 模式评估（根据某种兴趣度度量，识别出真正有趣的模式）
7) 知识表示（使用可视化和知识表示技术，向用户提供挖掘的知识）