如何用SAS来做Apriori关联算法

prior 和 priori的区别prior 词义: adj. 优先的; 占先的; 在…之前;n. 小修道院院长，大修道院的副院长; （隐修院） 会长; [史] 行政长官; 普赖尔;adv. 在前; 居先;priori 词义: [计][拉] 先验（的），同a priori;

priori是什么意思。prioriun.先验的先天；倍欧丽；先验上例句：At any rate that certainly is not knowable a priori.不管怎样，那肯定不是一个可知的先验。

在康德那里，“先验的”（transzendental）和“先天的”（apriori）这两个概念是既联系又有区别的。一般说来，“先天的”在概念的外延上要比“先验的”更宽，先验知识肯定是先天的，但先天的知识不一定是先验的。因为“先天的”只管先于经验，至于先于经验来干什么，它并不考虑；而“先验的”则是指先于经验（就此而论它也是一种“先天的”）而又关于经验的，它应当考察经验知识如何可能的，是以哪些先天条件为前提才得以可能的。所以“先验的”指的是关于“先天的”研究。在这个意义上，贺麟先生把“apriori”和“transzendental”的区别归结为“先天的”与“先天学的”区别是有道理的。所以，“先验感性论”的“先验”一词正表明康德是要从先天方面来研究感性知识的能力，即研究感性中的先天知识的来源及其如何可能的。如果说，“先天”属于第一层次的知识，那么，“先验”就是第二层次的知识，它是知识的知识，属于“认识论”的范围，它讨论的重点是先天知识的可能性。如“先验感性论”考察的是感性的先天形式（时空）作为一切显现的先天条件的可能性；“先验分析论”考察的是知性的先天范畴作为一切知识的先天条件的可能性；“先验辩证论”是考察在一定认识中出现必然的错误与矛盾的可能性。总而言之，所谓先验的，指一切涉及先天知识可能性的普遍条件的东西。对“先验的”系统阐述，可以参见邓晓芒教授在《康德哲学诸问题》里所讲述的，建议在看完康德的前两大批判后再进行阅读。

之前的

apriori美 [əpriˈɔri]  。adj.先验的；推测的adv.自原因推及结果地例句：Application research of Apriori algorithm in process of industrial quality control Apriori算法在流程工业质量控制中的应用研究The Teaching Quality Analysis Based on the Improved Apriori Algorithm 基于改进的Apriori算法的教学质量分析The Improved Apriori Algorithm Application to The Teaching Quality Analysis 一种改进的Apriori算法在教学质量分析中的应用Data Mining Model Based on the Improvement of Apriori Algorithm and Genetic Algorithm 基于改进的Apriori算法和遗传算法的数据挖掘模型An Improved Apriori Algorithm based on the Operation of Bit Storage 一种基于BIT存贮运算的Apriori改进算法

通常意义上理解，同“经验”相对，意为先于经验的，但为构成经验所不可或缺的。但此概念涉及对近代西方哲学基本问题的探讨，在不同语境，词义有微妙的区别。它针对的是某一次具体的统计学检验，就是说在检验某个事件是否会发生之前先估计一下它发生可能性的大小、赋予这个事件一个概率，这就是“先验”概率。相关如下例如在搜集某个证据检验某科学假说是否成立之前估计一下该假说成立的可能性有多大就叫“假说的先验概率”。这种在检验之前的概率估测既有可能是依据过去的证据材料计算得来的，叫做“客观先验概率”，这样的概率依赖于过去的经验，不是a priori的。也有可能只是依据个人感觉就直接赋予了，这叫“主观先验概率”，显然不是像“1+1=2”那样确定不移的判断，也不是a priori的。反正“先验概率”中的“先验”就不是a priori，而只是“在检验之前”，为避免误会，建议改译成“验前概率”。唯心主义认识论的根本特点。它从意识第一性，物质第二性的前提出发，把人的意识说成先天就有的东西，是先于物质、先于实践的东西，物质世界反而是这种意识的产物。先验论坚持“从思想和感觉到物的路线”。

Apriori算法是第一个关联规则挖掘算法，也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系，以形成规则，其过程由连接（类矩阵运算）与剪枝（去掉那些没必要的中间结果）组成。该算法中项集的概念即为项的集合。包含K个项的集合为k项集。项集出现的频率是包含项集的事务数，称为项集的频率。如果某项集满足最小支持度，则称它为频繁项集。算法应用随着高校贫困生人数的不断增加，学校管理部门资助工作难度也越加增大。针对这一现象，提出一种基于数据挖掘算法的解决方法。将关联规则的Apriori算法应用到贫困助学体系中，并且针对经典Apriori挖掘算法存在的不足进行改进，先将事务数据库映射为一个布尔矩阵，用一种逐层递增的思想来动态的分配内存进行存储，再利用向量求＂与＂运算，寻找频繁项集。

经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率，但是apriori的算法扩展性较好，可以用于并行计算等领域。基本算法：Apriori algorithm是关联规则里一项基本算法Apriori算法将发现关联规则的过程分：第一通过迭代，检索出事务数据库1中的所有频繁项集，即支持度不低于用户设定的阈值的项集；第二利用频繁项集构造出满足用户最小信任度的规则。其中，挖掘或识别出所有频繁项集是该算法的核心，占整个计算量的大部分。

Incant是施咒，tatem应该是一个名词，priori在这儿应该是“更早的”，通常被译为“先验”，连接起来应该是……你自己看着办吧（喂维基上说这是priori incantato 闪回前咒的延伸版本，“It is sometimes referred to as the "reverse-spell effect."，即“也被称作‘逆转魔法效果"”（或是“反向”？大概是这个意思……）不如我们私聊来讨论一下吧……上面的那些东西看看就好了别较真……

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

Apriori算法的主要思想是找出存在于事物数据集中的最大频繁项集，再利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。 项集是项的集合。包含k个项的项集成为k项集。项集的出现频率是所有包含项集的事务计数，又称为绝对支持度或支持度计数。如果项集I的相对支持度满足预定义的最小支持度阈值，则I是频繁项集。频繁k项集通常记作k。 项集A、B同时发生的概率称为关联规则的支持度（也称为相对支持度）。 项集A发生，则项集B发生的概率为关联规则的置信度。 最小支持度是用户或专家定义的衡量支持度的一个阈值，表示项目集在统计意义上的最低重要性；最小置信度是用户或专家定义的衡量置信度的一个阈值，表示关联规则的最低可靠性。同时满足最小支持度阈值和最小置信度阈值的规则称为强规则。 项集A的支持度计数是事务数据集中包含项集A的事务个数，简称为项集的频率或计数。 频繁项集哦的所有非空自己也必须是频繁项集。根据该性质可以得出：向不是频繁项集I的项集中添加事务A，新的项集I U A一定也不是频繁项集。 1）找出所有的频繁项集（支持度必须大于等于给丁的最小支持度阈值），在这个过程中连接步和剪枝步互相融合，最终得到最大频繁项集Lk。 连接步的目的是找到K项集，对给定的最小支持度阈值，分别对1项候选集C1，剔除小于该阈值的项集得到1项频繁项集L1；下一步由L1自身连接产生2项候选集C2，保留C2中满足约束条件的项集得到2项频繁集，记为L2；再下一步由L2与L3连接产生3项候选集C3，保留C2中满足约束条件的项集得到3项频繁集，记为L3···这样循环下去，得到最大频繁项集Lk。 剪枝步紧接着连接步，在产生候选项Ck的过程中起到减小搜索空间的目的。由于Ck是Lk-1与L1连接产生的，根据Apriori的性质频繁项集的所有非空子集也必须是频繁项集，所以不满足该性质的项集不会存在于Ck中，该过程就是剪枝。 2）由频繁项集产生强关联规则：由过程1）可知未超过预定的最小支持度阈值的项集已被提出，如果剩下这些规则又满足了预定的最小置信度阈值，那么就挖掘出了强关联规则。

也叫或然率或然率（Probability），即一事件中某不定事象发生机会的测量值。例如有人抛掷一枚硬币，若其出现正面朝上的机会为一半，则称该抛掷一枚硬币之事件，其发生正面朝上之事象的或然率为二分之一。或然率有其数学理论之严密且完整的定义，一事件中某事象发生之或然率，有下列两种理论：一、理论或然率（TheoreticalProbability）：即根据事件本性推理而得的或然率，又称先天（Priori）或然率。例如：一枚硬币有正反两面，将其抛掷，其正面朝上之或然率，不待试验即可推知其为二分之一；又例如：若一摸彩箱中共有彩券三十张，其中有奖之彩券共十张，则可推知其中奖之或然率为三分之一。二、经验或然率（EmpiricalProbability）：即根据实际现象归纳众多次数而得之或然率。例如：将一枚硬币抛掷一百次，若其出现正面朝上之次数为五十二次，即称抛掷该枚硬币出现正面朝上之或然率为52/100=0.52；又例如：若甲县某年内共出生婴儿四千八百六十五人，其中男婴为二千五百三十四人，则该县男婴出生之或然率即为2534/4865=0.52。此种或然率又称后天的（Posteriori）或然率。

经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率。但是apriori的算法扩展性较好，可以用于并行计算等领域。 Apriori algorithm是关联规则里一项基本算法。是由Rakesh Agrawal和Ramakrishnan Srikant两位博士在1994年提出的关联规则挖掘算法。关联规则的目的就是在一个数据集中找出项与项之间的关系，也被称为购物蓝分析 (Market Basket analysis)，因为“购物蓝分析”很贴切的表达了适用该算法情景中的一个子集。

上一讲我们讲到， 知识总是表现为判断的形式， 就是说只有形成了A是B这样的判断，才是知识。这是经验主义也承认的观点。那么既然 一切知识都开始于经验，所以一切知识是经验判断。 然后我讲了康德发现 经验判断里面包含有经验性判断，但这种判断完全是后天的，而经验判断里既包含后天的成分，也同时包含一些先天的东西。 今天我们就从“先天”（a priori）这个概念讲起。“先天”是一个拉丁词，有人把它译成“先天的”，也有人把它译成“先验的”，韦卓民先生把它译作“ 验前的 ”。严格说来，韦先生的译法比较好，但没有流行开来，这大概与中国人不太习惯逻辑思维有关，其实“验前的”的译法逻辑性更强。虽然我也遵循约定俗成，用“先天的” 这一译法，可是你要注意，汉语的“先天的”，容易让人误解。这个词拉丁文的本意，是从逻辑的意义上讲的，而不能把它理解成汉语的“天生的”、“与生俱来的”的意思，这部著作里的“先天的”，指的是 逻辑上在先的 。 搞清楚这一点，我们再来回顾上一讲说的，经验里面有先天的东西，但是 一切知识又开始于经验。这个“开始”是从时间上说的，而“先天的”则是先于经验的，这里的“先”，是从逻辑上说的，所以两者并不冲突。 时间上在先的东西，并非逻辑上在先，分析一下经验知识的结构就会发现， 如果没有先天的东西，后天的经验也不可能发生。 所以我们要从逻辑上在先，来理解“先天的”含义，那就是 独立于经验或先于经验的。 康德举过一个例子，说一个人在挖一所房子的墙角，另一个人看到后说，你别再挖了，再挖房子就倒了，挖墙的人问，你怎么知道这个房子要倒呢？你是不是先天就知道？从这个意义上，也可以说他先天地预见到这个房子会倒。等后来房子倒了他会说，你看，这个房子果然倒了，经验还没发生，我就先于这个经验预见到这个经验会发生。 这种意义上的先天，是日常意义上的，这种先天不是严格的、逻辑意义上的先天，因为这样一种先天归根结底还是一种后天。你为什么知道这个房子会倒呢？你还是根据以往的或别人的经验，比如根据牛顿力学得出的结论，也就是说还是从经验中来的。 然后，康德对真正意义上的先天做了两个规定： 第一，它具有 普遍性（university） ，放之四海而皆准。预测到某个经验事件会怎么发生，可能不具有普遍性。你在一种情况下做出了正确的预测，而在另外的情况下则可能是错误的。譬如，一座房子，在地球上可能会倒，但是在太空中不会倒，所以房子倒不倒，是有一定的时间、地点、条件的，这就没有普遍性。康德讲的先天的普遍性，是绝对的普遍性， 不以经验为转移，在任何地方都具有如此的普遍性。 第二，它具有 必然性（necessity） 。意思是，它不可能是别的样子，先天的知识不可能有它的反面，一加一只能等于二。数学中的先天知识，都具有这个特点。先天的知识也没有偶然性，不是今天等于二，明天就等于三了。普遍性和必然性是“先天”的两个必要的本质属性。 到此我们可以得出这样的结论：虽然经验知识里面的先天成分是放之四海而皆准，但它的内容，比如感觉、知觉、印象等等，都是 偶然 的，我们在先天知识的框架里，塞进一些什么样的知识内容，也是偶然的。 在《纯粹理性批判》中，康德的任务就是： 第一，对这些 先天知识的来源 加以探讨。我们上面讲了，一切知识都是开始于经验，但并非都来源于经验，那么来源于先天的那些知识，作为经验知识里面的要素，它们又是从何而来的呢？既然经验知识一部分来源于经验，一部分来源于先天，那么这些先天的知识又来源于何处呢？ 第二，是对 先天知识的范围 加以研究。我们刚才讲过，先天知识具有普遍性，放之四海而皆准，但是放之四海而皆准也有自身的范围，比如说放在“自在之物”身上就不准。 说到这儿，我还要强调一下康德哲学中，这个“自在之物”（thing-in-itself）的准确含义，就是 我们所看到和认识到的事物都只是事物的表面现象，而不是现象下面的事物本身，康德把这个事物本身，称为“自在之物”。 回到刚才的话题。所谓的“放之四海”，指的是现象界，对于凡是能够呈现出来的万物都是适用的，但是它有它的范围，要对这个范围加以研究。问题推进到这里康德说，我们要悬置知识，为信仰留下地盘。他的意思就是，在信仰领域，知识暂时沉默吧，就不要多嘴了。 我们上一讲也谈到，科学知识不能解决信仰问题，信仰是另外一个问题，用科学来解决，估计就没有信仰了。其实，康德时代的人们已经意识到，科学知识有自身的范围，信仰、宗教、审美这些问题，都属于自在之物的范围，不是单纯的科学就能解决的。所以，要对先天知识的范围加以研究。 此外，要对先天知识的种类加以研究，包括它的等级、成分等等。 先天知识的种类 ，譬如说感性，感性里面也有先天知识，知性也有先天知识，理性也有先天知识。我们上面讲，康德把知识分为三个层次：感性、知性和理性。它们都依赖于它们的先天知识，先天的感性、先天的知性和先天的理性。而所有这些知识，都被康德称作“先验的知识”。 那又怎么区别康德的先天知识和先验知识呢？在某种意义上，先天的知识和先验的知识是可以打通的。但是，先天的知识不仅仅是先验的知识，比如说形式逻辑是先天的知识，但它不是先验的知识，我们后面会讲到康德提出的“先验的逻辑”，它才是先验的知识，而形式逻辑只是为先验逻辑做准备的。 先验的知识和先天的知识的区别在于： 先验知识是对先天知识本身加以研究的 ，或者我们可以把它叫做“先天知识的先天知识”。我们要 对先天知识的来源、范围和种类加以研究，这一番研究所获得的就是先验的知识，它也是先天的。 所以我们讲，凡是先验的知识，都是先天的知识；但并非所有先天的知识，都是先验的知识。譬如， 形式逻辑之所以是先天的而不是先验的，就是因为它没有对自身的来源和范围加以研究。 形式逻辑没有自觉性，而仅仅是一套摆在那里用来思维的工具，它没有专属于自己的使用范围，只要应用概念，就必须要有形式逻辑。只有那种对先天的知识反过来再加以研究的知识才是先验的知识。这是先天和先验的一方面的区别，在其它方面的区别我们后面再讲。 康德提出，先天知识是逻辑上在经验之前，并且独立于经验的知识，它具有不以经验为转移的普遍性，和不会随意变化的必然性。但是，先天知识的普遍性也有一定的范围，不适用于信仰、宗教和审美这样的自在之物。在感性、知性和理性知识中都有先天知识，康德也把它们叫做先验知识。

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算法的两大缺点。

西方的宗教或唯心主义哲学的一般术语。欧洲中世纪经院哲学就已使用过，I.康德第一次把这两个术语作了区分。在康德哲学中，这两个术语是不能相互替换的。所谓“先验的”，在认识论中有先于经验的意思。康德用来表示在先天可能的范围内，关于认识方式的知识。康德所说“先验的”，是指这样一种特殊知识：它不涉及对象，而只涉及我们认识对象的形式，并且在这种形式中也只限于先天可能的形式。康德借此企图说明，先天知识为什么是经验之所以可能的一般条件以及为什么只能限于经验的使用。这种理论知识的体系就是康德的先验哲学，即所谓观察先天知识的限界、本性与可能性的一门科学。 所谓“超验的”，一般指思维或意识的一种活动性质，即超出经验世界的界限而进入超经验的领域。在康德的先验唯心论体系中，“超验的”是理性的辩证本性的表现。与知性不同，理性追求绝对的完整性，即无条件者，而经验的东西只具有相对的完整性，即有条件者。因此，理性所追求的无条件者就超出了经验的界限，它在经验世界中没有相应的对象。康德指出，理性这种对经验世界的超越是必然的，问题在于对这种理性的必然性要有批判的认识。康德认为理性超越经验界而必然形成的只是“理念”，它们只具有规范性的意义，不存在于经验界，因而不是认识的对象，而是“物自体”。理性的理念有三种：“心灵”，是主体的绝对统一；世界或宇宙，是客体的绝对统一；上帝，是主体与客体的统一。康德认为，旧的形而上学正是对于理性自身超越作用的必然性没有批判的认识，因而陷入了“假相”，即把“物自体”当作了可认识的对象，产生一系列谬误推理和二律背反。康德认为，知识是“内在的”，不能超出主体可能的经验，理性的超越作用是必然的，但要予以批判的考察即规定它的正当地位。

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

D

康德“transzendental”概念的第一个继承者是哲学神童谢林。谢林对这个概念的理解不仅是在时间上、而且也是在含义上最切近康德的。只不过他没有像康德那样把自己的整个哲学称作“Transzendentalphilosophie”，而是只用它来命名其中的一部分。谢林的哲学预设了一个二元论的前提：自然与理智的平行关系。他认为要想完整地描述这种关系，“单靠transzendental哲学或者单靠自然哲学都是不可能的，而只有靠这两种永远对立的科学，二者决然不能变成一个东西。”这样，自然哲学与transzendental哲学便处在对立的位置上，但它们同时也相互需求和相互补充。自然哲学的进路在于：使客观的东西成为第一性的，然后说明主观的东西如何会依附于它。这是自然科学的讨论方式。Transzendental哲学的进路则正好相反：使主观的东西成为第一性的，然后说明客观的东西如何会依附于它，这是哲学的讨论方式。Transzendental哲学于是成为整个哲学的代名词。谢林对transzendental的这个界定直到今天都留下清晰的痕迹：每当我们看到有人将“transzendental-natuerlich”作为概念对来使用时，我们多半可以猜想他受谢林的影响较深。显而易见，康德的transzendental立场在谢林这里是经过一定的修改才得到维续的。康德的立场意味着：不讨论知识以及作为知识之总和的自然科学是否可能的问题，而只思考它们如何可能。谢林所做的修改在于，自然科学也是哲学所要讨论的问题，更确切地说，是自然哲学所要讨论的问题。撇开这些差异不论，我们可以特别关注谢林一下对transzendental概念的定义：“Transzendental考察方式的本性只能是主观的东西把自己变成自己对象的一种持续不断的活动。”他也提到“transzendental直观”，这无非是指对直观者（主体）自身的反思直观。在这个意义上，transzendental根本不同于a priori的概念。这在谢林那里特别明显地表现出来。[12]因为在他的哲学体系中，如果说“transzendental哲学”是对主观的东西本身的思考，那么与它相对的应当是自然哲学。而a priori只占transzendental哲学中的一小部分。它与它的对立概念a postriori的关系只是在“以transzendental唯心论为原则的理论哲学体系”的第三个时期才出现。由此可见transzendental和a priori这两个概念的差异有多大。至于a priori和a postriori的关系，谢林曾言简意赅地说，“我们的认识原本不是a priori，也不是a postriori，因为这里的全部区别都仅仅是从哲学意识方面被作出来的。”换言之，a priori和a postriori的区别是一个由transzendental的思考方式所造出的、并且包含在它之中的区别。诚然，在谢林那里也出现诸如“transzendental抽象”、“transzendental范式”的概念，就像在康德的论著中出现“transzendental自我”、“transzendental认识”等等一样。这些概念最容易误导人将“transzendental”与“a priori”两者混为一谈。但在康德和谢林那里，这类组合概念的意思还是明确的，只要我们把“超越论的”和“先天的”概念通过中译名区分开来：它们都意味着：“为超越论所把握和探讨的”或“在超越论范围内的”，如此等等。最后还需指出一点：即便我们把“先验”一词仅仅保留给a priori使用，这个中译对a priori严格地说仍然是不合适的。例如，10的十次方的结果是一个apriori的认识；我们无法说它必定是先于经验或后于经验，但却可以说：它独立于经验而成立。因此，康德对“Erkenntnisse a priori”（通常称作“先天认识”）的定义并不是“先于经验的认识”，而是“绝然独立于经验而成立的认识”，而对“Erkenntnisse a postriori”（通常称作“后天认识”）的定义则是“源自经验的认识”。当然，这个词的通常译名如“先天”、“先在”等等，也都不能说是理想的翻译，而是各自带有自己的缺陷。但与“先验”的译名相比，它们还算是更好的选择。

解释如下：Apriori是基于广度优先的关联规则算法，即从频繁1项集开始，采用频繁k项集搜索频繁k+1项集，直到不能找到包含更多项的频繁项集为止。

一、何谓「先天」（先验）与「后天」（后验）康德他认为所有的知识都是随著经验开始的，但是并非都是源自于经验的。因此一切都是感官作用而来，因此并不承认如之前哲学家所提的人有先天的观念。而知识则有先天与後天之别，所谓「先天」(a priori)是不依赖经验而成立的，所以又有学者翻译成「先验」，在课本中是用「先天」，有时也会用「先验」(因为怕与先天观念误用)。「先验」顾名思义乃是「先」於经「验」的意思(以下还是以用「先天」为主)；然而「先」在此很容易被误解为「在时间上先於经验」，其实它应该更适当的说是「作为经验的先决条件」，也就是使经验成为可能的先决要素与基础。然而「先天」是相对于经验，所以，对于「经验」便被称为「后天」(a posteriori)或「后验」。因此，所谓的认识过程上的「先天」，便是说在认识过程之的「先决条件」，也就是使得经验知识成为可能的先决条件。更明确地说是客体对像被认识的认识根基，这个部分是存在主体之中，也就是主体的认识结构与功能。总之，主体的认识结构与功能，为一个先天的架构，在任识过程中会产生所谓的「先验形式」，因而引申出来经验知识，因此知识的成立，便成为可能。举例来说：先天： 音响内部的结构与功能 ≒ 主体的认识的架构与功能後天： 声音的呈现 ≒ 客体的经验知识由上面的分析得知，音响的内部结构，可以是产生或引申出声音的呈现，如同主体的认识结构，可以引申出经验之知一样；所以音响的内部结构是声音呈现的先决条件，如同主体的认识结构，是使经验成为可能的先决条件一样。所以，「先天」或「先验」，便是主体认知的先决条件，是不来自於经验的，是在主体之内的。

　　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　　

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;/*** <B>关联规则挖掘：Apriori算法</B>* * <P>按照Apriori算法的基本思想来实现* * @author king* @since 2013/06/27* */public class Apriori { private Map<Integer, Set<String>> txDatabase; // 事务数据库 private Float minSup; // 最小支持度 private Float minConf; // 最小置信度 private Integer txDatabaseCount; // 事务数据库中的事务数 private Map<Integer, Set<Set<String>>> freqItemSet; // 频繁项集集合 private Map<Set<String>, Set<Set<String>>> assiciationRules; // 频繁关联规则集合 public Apriori(     Map<Integer, Set<String>> txDatabase,      Float minSup,      Float minConf) {    this.txDatabase = txDatabase;    this.minSup = minSup;    this.minConf = minConf;    this.txDatabaseCount = this.txDatabase.size();    freqItemSet = new TreeMap<Integer, Set<Set<String>>>();    assiciationRules = new HashMap<Set<String>, Set<Set<String>>>(); } /** * 扫描事务数据库，计算频繁1-项集 * @return */ public Map<Set<String>, Float> getFreq1ItemSet() {    Map<Set<String>, Float> freq1ItemSetMap = new HashMap<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();     // 计算支持度     Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);     if(supported>=minSup) {      freq1ItemSetMap.put(entry.getKey(), supported);     }    }    return freq1ItemSetMap; } /** * 计算候选频繁1-项集 * @return */ public Map<Set<String>, Integer> getCandFreq1ItemSet() {    Map<Set<String>, Integer> candFreq1ItemSetMap = new HashMap<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(String item : itemSet) {      Set<String> key = new HashSet<String>();      key.add(item.trim());      if(!candFreq1ItemSetMap.containsKey(key)) {       Integer value = 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<Set<String>> aprioriGen(int m, Set<Set<String>> freqMItemSet) {    Set<Set<String>> candFreqKItemSet = new HashSet<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 = new HashSet<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 = new HashSet<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-项集集合      }     }    }    return candFreqKItemSet; } /**  * 使用先验知识，剪枝。若候选k项集中存在k-1项子集不是频繁k-1项集，则删除该候选k项集  * @param candKItemSet  * @param freqMItemSet  * @return  */ private boolean has_infrequent_subset(Set<String> candKItemSet, Set<Set<String>> freqMItemSet) { Set<String> tempSet = new HashSet<String>(); tempSet.addAll(candKItemSet); Iterator<String> 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<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;     }    }    return it; } /** * 根据频繁(k-1)-项集，调用aprioriGen方法，计算频繁k-项集 *  * @param k  * @param freqMItemSet 频繁(k-1)-项集 * @return */ public Map<Set<String>, Float> getFreqKItemSet(int k, Set<Set<String>> freqMItemSet) {    Map<Set<String>, Integer> candFreqKItemSetMap = new HashMap<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 = new HashSet<String>();      set.addAll(kSet);      set.removeAll(entry.getValue()); // 候选频繁k-项集与事务数据库中元素做差运算      if(set.isEmpty()) { // 如果拷贝set为空，支持数加1       if(candFreqKItemSetMap.get(kSet) == null) {        Integer value = 1;        candFreqKItemSetMap.put(kSet, value);       }       else {        Integer value = 1+candFreqKItemSetMap.get(kSet);        candFreqKItemSetMap.put(kSet, value);       }      }     }    }  

关联分析，顾名思义就是找出哪几项之间是有关联关系的，举个例子： 以上是五个购物记录，从中我们可以发现，购买了尿布的人其中有3个购买了啤酒，那么久我们可以推测，尿布和啤酒之间有较强的关联关系，尽管他们之间看起来并没有什么联系，也就是能得到规则： 因为购物分析能较好地描述关联分析，所以又被叫做 购物篮分析 。 为了较好的描述这个分析的各种名词，我们把上面的表格重新设计一下： 把每一个购物订单中，涉及到的商品都变成1，没涉及到的变成0，也就是将各个商品的购买记录 二元化 。 当然肯定也有多个分类的情况。 那么面包，牛奶这些就叫数据集的 项 ，而他们组合起来的子集就叫做 项集 。可以为空，空集是不包含任何项的项集，如果一个项集包含k个子项，就叫做k-项集。 订单12345叫做 事务 ，某个项集在所有事务中出现多少次，叫做项集的 支持度计数 。 在上面的表格中，项集{啤酒、尿布、牛奶}的支持度计数为2，因为有两个事务（3、4）包含这一项集。 用 支持度 和 置信度 来衡量，假定存在规则 ，其中X和Y是 不相交 的项集，则支持度为： 其中N是数据集中的事务个数，相当于表示该规则在数据集中出现了多少次。 置信度为： 置信度的意思就是，在出现X的情况下，有多少次同时出现了Y，代表这个关联规则的频繁程度。 注意置信度的分母是 ，因此这个评价可能会存在一定的问题。 关联分析的核心目标就是找出支持度大于等于某个阈值， 同时 置信度大于等于某个阈值的所有规则，这两个阈值记为 和 。 为了更有效率的完成这个过程，通常把关联规则算法分为两步： 可以看出来，首先要求得频繁项集，这步骤的开销很大，但是只需要考虑支持度就可以了，第二步只考虑置信度就可以了。 下面就可以分两步来解析算法： 首先我们可以把项集联想成一个树形结构，每层代表着不同的k-项集，依层递增，非叶子节点来自于他的几个父节点的并集，如图： 我们肯定不能通过传统的方式，遍历这些节点，算出支持度，然后筛选掉不满足最小支持度的那些，这样开销太大，因此我们引入先验原理，来辅助剪枝。 这个原理不难想象，假如一个项集{a,b}是非频繁项集，那么{a,b,c}肯定也是，因为ab是，在{a,b,c}中与之关联的c必须在ab出现之后才存在，因此他的支持度肯定不会大于{a,b}。 频繁的就是支持度大于等于最小支持度的项集，非频繁就是小于的。 我们可以利用这一定理，把非频繁项集的超集一并从树中减去，这样就能大大的降低计算次数，如图： 虚线圈上的，就是在{a,b}确定是非频繁项集之后，剪掉的超集，这些是不用计算的。 根据这个原理，可以说一下Apriori算法。 根据上面说的先验原理，Apriori算法先从项集宽度最低的1开始，遍历所有的项集支持度，找出频繁项集（因为第一层在找出支持度之前），之后根据先验原理，挑选任意两个频繁项集组成2-频繁项集（很简单，如果挑非频繁的，那组成的项集就不是频繁项集了），再用2-项集挑选3-项集，直到挑选不出更高层次的项集为止，把这些项集作为 候选项集 ，如图： 图中1-项集中，啤酒，面包，尿布，牛奶的支持度大于等于3（设 为3），则由他们组成2-项集，继续筛选满足支持度不小于3的项集，再由2-项集生成3-项集，这就是 Apriori 算法筛选频繁项集的基本步骤。总结如下： 上面提到了用k-1项集生成k-项集，那么如何才能最有效率的产生k-项集呢，这里用了 的方法，也就是找到一对（k-1）-项集，当他们的前（k-2）项都相同时，进行合并，合并之后的结果就是{ }，因为前k-2项是相同的。 举个例子： 上面说了如何产生候选项集，接下来就是如何更有效率的确定支持度计数了，同样，如果遍历一个一个查的话效率是很低的，我们可以用枚举的方法遍历每个事务包含的项集，以查找3-项集为例，如图： 因为我们要查3-项集，因此树状结构就分到3-项集为止。 因为3-项集的开头第一个项肯定在1，2，3之间，我们就设定这三个数为三个分支，无论到哪个节点，都严格按照这个来分（1在左，2在中，3在右），在下面的层次中如何碰到比123更大的，则再向右分，就可以得到图中的关于事务t的所有3-项集。 有了所有项集的列表，我们可以用候选项集去匹配这些项集，从而看t中是否包含候选项集，如果包含，则支持度+1。 可以使用Hash树来进行匹配，从而实现支持度计数。 如下图，就是一个Hash树的例子，每个内部节点都使用Hash函数 来确定应当沿着当前节点的哪个分支向下，所以1，4，7就到了同一分支。 我们对于单个事务，可以遍历Hash树，设事务为t，则保证所有包含属于事务t的候选3-项集的叶节点至少访问一次。 由于我们之前已经通过树的方式枚举出了t中所有的3-项集，那么我们跟这个Hash一走分支，找到对应3-项集的就+1支持度，即可算出每个候选项集的支持度。 提取规则相应的比较简单，设有 频繁项集Y ，我们忽略前件为空和后件为空的规则，每个频繁项集能产生 个关联规则，提取方法就是将Y划分为两个 非空 的子集X和Y-X，使得 满足 置信度阈值 也就是最小置信度。 同样的，提取规则也有一个原理： 参考频繁项集的寻找过程，我们可以利用树形结构对规则进行剪枝。 树的每层对应规则后件中的项数，如图： 假设规则{ } { }不满足置信度阈值的要求，那么可以丢弃后件包含{a}的所有规则，如上图所示。 至此我们经历了寻找频繁项集和提取规则的过程，基本Apriori算法就算完成了，不过还有一些需要考虑的细节。 在实际应用过程中，往往频繁项集产生的数量可能很大，所以很难表示，我们需要寻找一种方法，找到一些有代表性的频繁项集，以保证其描述性。 通常有如下两种方法： 如图： 这种表示很明显降低了需要表示项集的个数，我们需要别的候选项集，直接取极大频繁项集的子集就行，任意一个肯定都是。 但是这么做，表示不出他们子集的支持度，所以就需要再遍历数据集，确定非极大频繁项集的支持度，不是很方便。 所以我们还可以用闭频繁项集来表示。 先来看闭项集的概念： 那么闭频繁项集的概念就很好理解了： 如图，我们假设 是40%。 这种做法可以保证支持度和描述性。 之前举的例子都是二元分类的，要么1要么0，下面看多分类的，我们很容易想到可以用独热编码解决这个问题，把所有分类二元化，但是这样就存在一个问题，有的属性值可能会不够频繁，没办法成为频繁项集。 所以最好是把多分类的项根据实际情况进行分类化，不要针对每个属性都设置独热编码。 或者将不太频繁的属性值合并为一个称作其他的类别。 所以面对多分类属性，我们要做的就是： 独热编码二元化-针对这些值进行一定的合并，或者分类或者并为其他 - 删除冗余的项 - 避免包含多个来自同一属性的项的候选集（例如{ }，被写到了一个候选集中，但是实际上这种情况不可能发生，由于独热编码进行的二元化而产生了这种情况，需要避免。） 我们也会遇到一些连续属性，可以通过以下几种方式处理： 这种做法有一个问题就是分类的效果取决于区间的个数和跨度，如果取不好很难得到理想的结果。 如果要验证统计出的值是否具有统计意义，可以参考假设检验中针对不同比较的不同公式，这里不再举例。 把mini-Apriori算法中的支持度代入到Apriori算法的支持度中即可。 举个例子： 想要衡量模型的好与坏，肯定要有一个评估指标，我们可以根据业务实际去评价，这是主管评价，叫做 主观兴趣度度量 ，这个显然要结合业务，所以我们要看看一些客观指标。 指标的评价往往依赖于相依表，这个相依表有点类似于混淆矩阵： 其中A，B代表在事务中出现，!A,!B代表没有在事务中出现，空列空行例如 代表A的支持度计数， 表示包含B但是不包含A的事务的个数。 最基本的就是置信度和支持度了，但是这两种指标都很难做到客观评价模型，会受到多种因素的影响。 我们可以用 兴趣因子 来衡量模型： 首先我们引入 提升度 的概念，它用于计算规则置信度和 规则后件 中项集的支持度之间的比率， 对于二元变量，提升度等价于另一种称作兴趣因子的客观度量，定义为： 其中N是事务个数。 如果 但是兴趣因子有一定局限性，看上图，{p,q}和{r,s}的兴趣因子分别为1.02和4.08，虽然p和q同时出现在88%的文档中，但是他们的兴趣因子接近于1，表明他们相互独立，另一方面，{r,s}的兴趣因子闭{p,q}的高，但是r和s很少出现在一个文档中，这种情况下，置信度要比兴趣因子更可信，置信度表明p和q之间的联系94.6%远高于r和s之间。 另外还可以引入 相关系数 ，逻辑类似于向量的相关系数： 相关度的值从-1到1，如果变量相互独立，则Φ=0。 他的局限性在于在食物中把同时出现和同时不出现视为同等重要，这往往不符合实际规律，同时对于倾斜的变量很难度量。 IS度量 可以用于处理非对称二元变量，定义如下： IS数学上等价于二元变量的余弦度量。 但是IS取决于A和B的支持度，所以存在与置信度度量类似的问题——即使是不相关或者负相关的模式，度量值也可能相当大。 支持度，全置信度，可以应用于较大的项集，兴趣因子，IS、PS、Jaccard系数等使用多维相依表中的频率，可以扩展到多个变量。 针对大多数项具有较低或中等的频率，但是少数项具有很高频率的数据集。 交叉支持模式是一个项集 ，他的支持度比率是： 小于用户指定的阈值 。 需要保证全置信度小于上面的支持度比率，而全置信度是： 其中 . 全置信度能够确保项集中的项之间是强关联的，例如，假定一个项集X的全置信度是80%，如果X中的一个项出现在某个事物中，则X中其他的项至少也有80%的几率属于同一个事务，这种强关联模式又称 超团模式 。

1.其后果是在该建筑（/机构）的存在时期中的区域性撤回。2.仅考虑被建立的目标，从世界各地的几个城市的历史中学习到的显示出相似之处的界限。3.相信人类会花越来越多的时间在（经推断）还没对人类生活有贡献的领域。a priori adj., adv.从事实推断结果；由因及果。由于人类花越来越多的时间在那些领域上，可以推断出那些领域还没对人类生活有贡献。

9.1 基于Apriori算法的关联分析 Aprior算法是关联规则分析中较为经典的频繁项集算法。关联规则反映的是两个或多个事物相互之间的依存性和关联性。如果两个或者多个事物相互之间存在一定的关联关系，则它们之间存在一种关联规则使得它们之间可以进行搭配。 9.1.1 基本概要 Apriori算法利用频繁项集的先验知识，不断地按照层次进行迭代，计算数据集中的所有可能的频繁项集，它的分析主要包括两个核心部分。 1、根据支持度找出频繁项集； 2、根据置信度产生关联规则。 9.1.2 Apriori算法原理 基本流程： 1、扫描历史数据，并对每项数据进行频率次数统计。 2、构建候选集 ，并计算其支持度，即数据出现频率次数与总数的比。 3、对候选项集进行筛选，筛选的数据项支持度应当不小于最小支持度，从而形成频繁项集 . 4、对频繁项集 进行连接生成候选集 ，重复上述步骤，最终形成频繁K项集或者最大频繁项集。 Apriori算法存在两大定理： 1、如果一个集合是频繁项集，那么它的所有子集都是频繁集合。 2、如果一个集合它不是频繁集合，那么它的所有超集都不是频繁项集。 9.1.3 Apriori算法优缺点 优：运算过程非常简单，理论方法也比较容易理解，对数据特征的要求也相对较低。 缺： 1、产生候选集是产生较多的组合，没有考虑将一些无关的元素排除后再进行组合。 2、每次计算项集的过程中都会扫描元素的数据表。 针对不足推出不断改进的Apriori算法： 1、将数据表（事务表）进行压缩。 2、利用哈希表的快速查找特性对项集进行计数统计。 3、合理选样。

prioradj.先前的；较早的；在前的；优先的n.（小隐修院）院长；（隐修院）会长adv.词性类型较多，而priori只有两个个词性adj. adv. 表示先验的/地。而prior则表示强调优先（在一般情况下的），而priori则偏重与一些预言，实验等学术方面的优先，但prior其实包括了priori，而priori主要用于特定的领域（比较正式在这种领域），其实靠语感，会更好点。

一模一样

经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率，但是apriori的算法扩展性较好，可以用于并行计算等领域。扩展资料：Apriori algorithm是关联规则里一项基本算法Apriori算法将发现关联规则的过程分：第一通过迭代，检索出事务数据库1中的所有频繁项集，即支持度不低于用户设定的阈值的项集；第二利用频繁项集构造出满足用户最小信任度的规则。其中，挖掘或识别出所有频繁项集是该算法的核心，占整个计算量的大部分。参考资料来源：百度百科-关联规则算法

通常意义上理解，同“经验”相对，意为先于经验的，但为构成经验所不可或缺的。但此概念涉及对近代西方哲学基本问题的探讨，在不同语境，词义有微妙的区别。中文里面还有“先验概率”这种译法，它对应的英文术语是“prior probability”，是常常在贝叶斯定理中出现的项目。这里的“先验”是“先于检验”、“在检验之前”的意思，而不是a priori所说的那种“独立于经验即可被认识”。它针对的是某一次具体的统计学检验，就是说在检验某个事件是否会发生之前先估计一下它发生可能性的大小、赋予这个事件一个概率，这就是“先验”概率。扩展资料例如在搜集某个证据检验某科学假说是否成立之前估计一下该假说成立的可能性有多大就叫“假说的先验概率”。这种在检验之前的概率估测既有可能是依据过去的证据材料计算得来的，叫做“客观先验概率”，这样的概率依赖于过去的经验，不是a priori的。也有可能只是依据个人感觉就直接赋予了，这叫“主观先验概率”，显然不是像“1+1=2”那样确定不移的判断，也不是a priori的。反正“先验概率”中的“先验”就不是a priori，而只是“在检验之前”，为避免误会，建议改译成“验前概率”。参考资料来源：百度百科-先验参考资料来源：百度百科-先验概率

经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率。但是apriori的算法扩展性较好，可以用于并行计算等领域。 Apriori algorithm是关联规则里一项基本算法。是由Rakesh Agrawal和Ramakrishnan Srikant两位博士在1994年提出的关联规则挖掘算法。关联规则的目的就是在一个数据集中找出项与项之间的关系，也被称为购物蓝分析 (Market Basket analysis)，因为“购物蓝分析”很贴切的表达了适用该算法情景中的一个子集。

优先(Priorition)指企业调查表中占竞争优势的企业

先验算呵呵

　　经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率。但是apriori的算法扩展性较好，可以用于并行计算等领域。　　Apriori algorithm是关联规则里一项基本算法。是由Rakesh Agrawal和Ramakrishnan Srikant两位博士在1994年提出的关联规则挖掘算法。关联规则的目的就是在一个数据集中找出项与项之间的关系，也被称为购物蓝分析 （Market Basket analysis），因为“购物蓝分析”很贴切的表达了适用该算法情景中的一个子集。

算法：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 属于 Ctc.count++;}Lk={c属于Ck | c.count>=min_sup}}Return L=所有的频繁集；Procedure apriori_gen(Lk-1:frequent(k-1)-itemsets)For each项集l1属于Lk-1For each项集 l2属于Lk-1If((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) thendelete 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 cIf s不属于Lk-1 thenReturn true;Return false;

the a priori 既然a priori justification 先验的理由

一模一样

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,由频繁项集产生强关联规则，结束。

class Apriori(object):    def __init__(self, filename, min_support, item_start, item_end):        self.filename = filename        self.min_support = min_support # 最小支持度        self.min_confidence = 50        self.line_num = 0 # item的行数        self.item_start = item_start #  取哪行的item        self.item_end = item_end        self.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])))# 记录item        self.pre_support = [] # 保存前一个support,location,num        self.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)                    break    def 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 = 0                    for j in i:                        if item_line[j] != "T":                            flag = 1                            break                    if not flag:                        support[index_num] += 1            self.line_num = index # 一共多少行,出去第一行的item_name        return support    def 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 itertools        s = sorted([sorted(i) for i in stack])        location = list(s for s,_ in itertools.groupby(s))        return location    def del_location(self, support, location):        "清除不满足条件的候选集"        # 小于最小支持度的剔除        for index,i in enumerate(support):            if i < self.line_num * self.min_support / 100:                support[index] = 0        # apriori第二条规则,剔除        for index,j in enumerate(location):            sub_location = [j[:index_loc] + j[index_loc+1:]for index_loc in range(len(j))]            flag = 0            for k in sub_location:                if k not in self.location:                    flag = 1                    break            if flag:                support[index] = 0        # 删除没用的位置        location = [i for i,j in zip(location,support) if j != 0]        support = [i for i in support if i != 0]        return support, location    def loop(self):        "s级频繁项级的迭代"        s = 2        while True:            print "-"*80            print "The" ,s - 1,"loop"            print "location" , self.location            print "support" , self.support            print "num" , self.num            print "-"*80            # 生成下一级候选集            location = self.select(s)            support = self.sut(location)            support, location = self.del_location(support, location)            num = list(sorted(set([j for i in location for j in i])))            s += 1            if  location and support and num:                self.pre_num = self.num                self.pre_location = self.location                self.pre_support = self.support                self.num = num                self.location = location                self.support = support            else:                break    def confidence_sup(self):        "计算confidence"        if sum(self.pre_support) == 0:            print "min_support error" # 第一次迭代即失败        else:            for index_location,each_location in enumerate(self.location):                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.pre_location] # 删除不存在上一级频繁项级子集                del_support = [self.pre_support[self.pre_location.index(i)] for i in del_num if i in self.pre_location] # 从上一级支持度查找                # print del_num                # print self.support[index_location]                # print del_support                for index,i in enumerate(del_num): # 计算每个关联规则支持度和自信度                    index_support = 0                    if len(self.support) != 1:                        index_support = index                    support =  float(self.support[index_location])/self.line_num * 100 # 支持度                    s = [j for index_item,j in enumerate(self.item_name) if index_item in i]                    if del_support[index]:                        confidence = float(self.support[index_location])/del_support[index] * 100                        if confidence > self.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)输出：

bi ci

　　经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率。但是apriori的算法扩展性较好，可以用于并行计算等领域。　　Apriori algorithm是关联规则里一项基本算法。是由Rakesh Agrawal和Ramakrishnan Srikant两位博士在1994年提出的关联规则挖掘算法。关联规则的目的就是在一个数据集中找出项与项之间的关系，也被称为购物蓝分析 （Market Basket analysis），因为“购物蓝分析”很贴切的表达了适用该算法情景中的一个子集。

如连接中的例子，虽然新的{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项集的数量。

from operator import and_from itertools import combinationsclass AprioriAssociationRule:    def __init__(self, inputfile):        self.transactions = []        self.itemSet = set([])        inf = open(inputfile, "rb")        for line in inf.readlines():            elements = set(filter(lambda entry: len(entry)>0, line.strip().split(",")))            if len(elements)>0:                self.transactions.append(elements)                for element in elements:                    self.itemSet.add(element)        inf.close()        self.toRetItems = {}        self.associationRules = []    def getSupport(self, itemcomb):        if type(itemcomb) != frozenset:            itemcomb = frozenset([itemcomb])        within_transaction = lambda transaction: reduce(and_, [(item in transaction) for item in itemcomb])        count = len(filter(within_transaction, self.transactions))        return float(count)/float(len(self.transactions))    def runApriori(self, minSupport=0.15, minConfidence=0.6):        itemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,                                  map(lambda item: (frozenset([item]), self.getSupport(item)), self.itemSet))        currentLset = set(map(lambda freqpair: freqpair[0], itemCombSupports))        k = 2        while len(currentLset)>0:            currentCset = set([i.union(j) for i in currentLset for j in currentLset if len(i.union(j))==k])            currentItemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,                                             map(lambda item: (item, self.getSupport(item)), currentCset))            currentLset = set(map(lambda freqpair: freqpair[0], currentItemCombSupports))            itemCombSupports.extend(currentItemCombSupports)            k += 1        for key, supportVal in itemCombSupports:            self.toRetItems[key] = supportVal        self.calculateAssociationRules(minConfidence=minConfidence)    def calculateAssociationRules(self, minConfidence=0.6):        for key in self.toRetItems:            subsets = [frozenset(item) for k in range(1, len(key)) for item in combinations(key, k)]            for subset in subsets:                confidence = self.toRetItems[key] / self.toRetItems[subset]                if confidence > minConfidence:                    self.associationRules.append([subset, key-subset, confidence])用Scala也大概六十多行：import scala.io.Sourceimport scala.collection.immutable.Listimport scala.collection.immutable.Setimport java.io.Fileimport scala.collection.mutable.Mapclass AprioriAlgorithm(inputFile: File) {  var transactions : List[Set[String]] = List()  var itemSet : Set[String] = Set()  for (line<-Source.fromFile(inputFile).getLines()) {    val elementSet = line.trim.split(",").toSet    if (elementSet.size > 0) {      transactions = transactions :+ elementSet      itemSet = itemSet ++ elementSet    }  }  var toRetItems : Map[Set[String], Double] = Map()  var associationRules : List[(Set[String], Set[String], Double)] = List()  def getSupport(itemComb : Set[String]) : Double = {    def withinTransaction(transaction : Set[String]) : Boolean = itemComb                                                                  .map( x => transaction.contains(x))                                                                  .reduceRight((x1, x2) => x1 && x2)    val count = transactions.filter(withinTransaction).size    count.toDouble / transactions.size.toDouble  }  def runApriori(minSupport : Double = 0.15, minConfidence : Double = 0.6) = {    var itemCombs = itemSet.map( word => (Set(word), getSupport(Set(word))))                           .filter( wordSupportPair => (wordSupportPair._2 > minSupport))    var currentLSet : Set[Set[String]] = itemCombs.map( wordSupportPair => wordSupportPair._1).toSet    var k : Int = 2    while (currentLSet.size > 0) {      val currentCSet : Set[Set[String]] = currentLSet.map( wordSet => currentLSet.map(wordSet1 => wordSet | wordSet1))                                                      .reduceRight( (set1, set2) => set1 | set2)                                                      .filter( wordSet => (wordSet.size==k))      val currentItemCombs = currentCSet.map( wordSet => (wordSet, getSupport(wordSet)))                                        .filter( wordSupportPair => (wordSupportPair._2 > minSupport))      currentLSet = currentItemCombs.map( wordSupportPair => wordSupportPair._1).toSet      itemCombs = itemCombs | currentItemCombs      k += 1    }    for (itemComb<-itemCombs) {      toRetItems += (itemComb._1 -> itemComb._2)    }    calculateAssociationRule(minConfidence)  }  def calculateAssociationRule(minConfidence : Double = 0.6) = {    toRetItems.keys.foreach(item =>      item.subsets.filter( wordSet => (wordSet.size<item.size & wordSet.size>0))          .foreach( subset => {associationRules = associationRules :+ (subset, item diff subset,                                                                       toRetItems(item).toDouble/toRetItems(subset).toDouble)                              }                  )    )    associationRules = associationRules.filter( rule => rule._3>minConfidence)  }}我不建议用Java，应改用Python或Scala一类的语言。如果用Python，代码大概50行左右，但可以想像用Java便看起来复杂得多。看如下：

apriori算法是聚类。Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该关联规则在分类上属于单维、单层、布尔关联规则。在这里，所有支持度大于最小支持度的项集称为频繁项集，简称频集。该算法的基本思想是：首先找出所有的频集，这些项集出现的频繁性至少和预定义的最小支持度一样。然后由频集产生强关联规则，这些规则必须满足最小支持度和最小可信度。然后使用第1步找到的频集产生期望的规则，产生只包含集合的项的所有规则，其中每一条规则的右部只有一项，这里采用的是中规则的定义。一旦这些规则被生成，那么只有那些大于用户给定的最小可信度的规则才被留下来。为了生成所有频集，使用了递归的方法。

代码

656有