apriori算法思想

⑴ Apriori算法是什么适用于什么情境

经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率。但是apriori的算法扩展性较好，可以用于并行计算等领域。

Apriori algorithm是关联规则里一项基本算法。是由Rakesh Agrawal和Ramakrishnan Srikant两位博士在1994年提出的关联规则挖掘算法。关联规则的目的就是在一个数据集中找出项与项之间的关系，也被称为购物蓝分析 (Market Basket analysis)，因为“购物蓝分析”很贴切的表达了适用该算法情景中的一个子集。

⑵ Apriori算法的核心是

• 连接和剪枝。

• 简言之就是对一个已知的交易数据库D，有一个最小支持阈值min_support，即为该算法的输入；算法的输出为满足最小支持阈值的频繁项集L。

• 具体为：扫描D，对每个交易商品（T1，...，Tk---1项候选项集）计数，找出满足计数大于min_support的项集，即为1项频繁集L1；

• 关键的来了：如何由1项频繁集L1产生2项候选项集C2，此步称为连接。

• 如何由C2得到L2，此步即为剪枝。从C2中找出计数大于min_support的项集，即为L2。

• 重复以上过程，增大频繁项集的长度，直至没有更长的频繁项集。
  

⑶ apriori算法使用了什么性质

Apriori性质：一个频繁项集的任一子集也应该是频繁项集。证明根据定义，若一个项集I不满足最小支持度阈值min_sup，则I不是频繁的，即P（I）<min_sup。若增加一个项A到项集I中，则结果新项集（I∪A）也不是频繁的，在整个事务数据库中所出现的次数也不可能多于原项集I出现的次数，因此P（I∪A）<min_sup，即（I∪A）也不是频繁的。这样就可以根据逆反公理很容易地确定Apriori性质成立。
http://ke..com/link?url=8F29ZS1ufQ4gtAsaXsyZr__Eut632ia

⑷ 如何实现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);
	}
	}
	}
	}
	

⑸ 数据挖掘十大经典算法及各自优势

数据挖掘十大经典算法及各自优势

不仅仅是选中的十大算法，其实参加评选的18种算法，实际上随便拿出一种来都可以称得上是经典算法，它们在数据挖掘领域都产生了极为深远的影响。
1. C4.5
C4.5算法是机器学习算法中的一种分类决策树算法,其核心算法是ID3算法. C4.5算法继承了ID3算法的优点，并在以下几方面对ID3算法进行了改进：
1) 用信息增益率来选择属性，克服了用信息增益选择属性时偏向选择取值多的属性的不足；2) 在树构造过程中进行剪枝；3) 能够完成对连续属性的离散化处理；4) 能够对不完整数据进行处理。
C4.5算法有如下优点：产生的分类规则易于理解，准确率较高。其缺点是：在构造树的过程中，需要对数据集进行多次的顺序扫描和排序，因而导致算法的低效。
2. The k-means algorithm 即K-Means算法
k-means algorithm算法是一个聚类算法，把n的对象根据他们的属性分为k个分割，k < n。它与处理混合正态分布的最大期望算法很相似，因为他们都试图找到数据中自然聚类的中心。它假设对象属性来自于空间向量，并且目标是使各个群组内部的均 方误差总和最小。
3. Support vector machines
支持向量机，英文为Support Vector Machine，简称SV机（论文中一般简称SVM）。它是一种监督式学习的方法，它广泛的应用于统计分类以及回归分析中。支持向量机将向量映射到一个更 高维的空间里，在这个空间里建立有一个最大间隔超平面。在分开数据的超平面的两边建有两个互相平行的超平面。分隔超平面使两个平行超平面的距离最大化。假 定平行超平面间的距离或差距越大，分类器的总误差越小。一个极好的指南是C.J.C Burges的《模式识别支持向量机指南》。van der Walt 和 Barnard 将支持向量机和其他分类器进行了比较。
4. The Apriori algorithm
Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该关联规则在分类上属于单维、单层、布尔关联规则。在这里，所有支持度大于最小支持度的项集称为频繁项集，简称频集。
5. 最大期望(EM)算法
在统计计算中，最大期望（EM，Expectation–Maximization）算法是在概率（probabilistic）模型中寻找参数最大似然 估计的算法，其中概率模型依赖于无法观测的隐藏变量（Latent Variabl）。最大期望经常用在机器学习和计算机视觉的数据集聚（Data Clustering）领域。
6. PageRank
PageRank是Google算法的重要内容。2001年9月被授予美国专利，专利人是Google创始人之一拉里·佩奇（Larry Page）。因此，PageRank里的page不是指网页，而是指佩奇，即这个等级方法是以佩奇来命名的。
PageRank根据网站的外部链接和内部链接的数量和质量俩衡量网站的价值。PageRank背后的概念是，每个到页面的链接都是对该页面的一次投票， 被链接的越多，就意味着被其他网站投票越多。这个就是所谓的“链接流行度”——衡量多少人愿意将他们的网站和你的网站挂钩。PageRank这个概念引自 学术中一篇论文的被引述的频度——即被别人引述的次数越多，一般判断这篇论文的权威性就越高。
7. AdaBoost
Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器 (强分类器)。其算法本身是通过改变数据分布来实现的，它根据每次训练集之中每个样本的分类是否正确，以及上次的总体分类的准确率，来确定每个样本的权 值。将修改过权值的新数据集送给下层分类器进行训练，最后将每次训练得到的分类器最后融合起来，作为最后的决策分类器。
8. kNN: k-nearest neighbor classification
K最近邻(k-Nearest Neighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。
9. Naive Bayes
在众多的分类模型中，应用最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型（Naive Bayesian Model，NBC）。 朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以 及稳定的分类效率。同时，NBC模型所需估计的参数很少，对缺失数据不太敏感，算法也比较简单。理论上，NBC模型与其他分类方法相比具有最小的误差率。 但是实际上并非总是如此，这是因为NBC模型假设属性之间相互独立，这个假设在实际应用中往往是不成立的，这给NBC模型的正确分类带来了一定影响。在属 性个数比较多或者属性之间相关性较大时，NBC模型的分类效率比不上决策树模型。而在属性相关性较小时，NBC模型的性能最为良好。10. CART: 分类与回归树
CART, Classification and Regression Trees。 在分类树下面有两个关键的思想。第一个是关于递归地划分自变量空间的想法；第二个想法是用验证数据进行剪枝。

以上是小编为大家分享的关于数据挖掘十大经典算法及各自优势的相关内容，更多信息可以关注环球青藤分享更多干货

⑹ 试解释Apriori算法核心思想,算法的不足,及算法改进的途径

自己去找论文下载看看，万方都有的，你直接搜“Apriori算法”即可，一大堆，自己看着挑吧

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

⑻ Arnoldi算法的优缺点

1.优点：适合稀疏数据集。算法原理简单，易实现。适合事务数据库的关联规则挖掘。2.缺点：可能产生庞大的候选集。算法需多次遍历数据集，算法效率低，耗时。
Apriori算法是第一个关联规则挖掘算法，也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系，以形成规则，其过程由连接（类矩阵运算）与剪枝（去掉那些没必要的中间结果）组成。该算法中项集的概念即为项的集合。包含K个项的集合为k项集。项集出现的频率是包含项集的事务数，称为项集的频率。如果某项集满足最小支持度，则称它为频繁项集。

⑼ 关联规则算法(The Apriori algorithm)

        关联规则的目的在于在一个数据集中找出项之间的关系，也称之为购物篮分析 (market basket analysis)。例如，购买鞋的顾客，有10%的可能也会买袜子，60%的买面包的顾客，也会买牛奶。这其中最有名的例子就是"尿布和啤酒"的故事了。

        本篇的Apriori算法主要是基于频繁集的关联分析。其主要目的就是为了寻找强关联规则。

        要理解频繁集、强关联规则，要先借助下面的一个情境，来介绍几个重要概念。

        下表是一些购买记录：

将购买记录整理，可得到下表，横栏和纵栏的数字表示同时购买这两种商品的交易条数。如购买有Orange的交易数为4，而同时购买Orange和Coke的交易数为2。

        置信度，表示这条规则有多大程度上值得可信。

        设条件的项的集合为A,结果的集合为B。置信度计算在A中，同时也含有B的概率。即Confidence(A->B)=P(B|A)。例 如计算"如果Orange则Coke"的置信度。由于在含有Orange的4条交易中，仅有2条交易含有Coke。其置信度为0.5。

        支持度，计算在所有的交易集中，既有A又有B的概率。

        例如在5条记录中，既有Orange又有Coke的记录有2条。则此条规则的支持度为2/5=0.4。现在这条规则可表述为，如果一个顾客购买了Orange,则有50%的可能购买Coke。而这样的情况（即买了Orange会再买Coke）会有40%的可能发生。

支持度大于预先定好的最小支持度的项集。

       关联规则：令项集I={i1,i2,...in}，且有一个数据集合D，它其中的每一条记录T，都是I的子集。那么关联规则是形如A->B的表达式，A、B均为I的子集，且A与B的交集为空。这条关联规则的支持度：support = P(A并B)。这条关联规则的置信度：confidence = support(A并B）/suport(A)。

       强关联规则：如果存在一条关联规则，它的支持度和置信度都大于预先定义好的最小支持度与置信度，我们就称它为强关联规则。

下面用一个例子说明算法的过程：

项目集合 I={1，2，3，4，5};

事务集 T：

设定最小支持度（minsup）=3/7，最小置信度（misconf）=5/7。

假设：n-频繁项目集为包含n个元素的项目集，例如1-频繁项目集为包含1个元素的项目集

则这里，1-频繁项目集有：{1}，{2}，{3}，{4}，{5}

生成2-频繁项目集的过程如下：

        首先列出所有可能的2-项目集，如下：

        {1，2}，{1，3}，{1，4}，{1，5}

        {2，3}，{2，4}，{2，5}

        {3，4}，{3，5}

        {4，5}

        计算它们的支持度，发现只有{1，2}，{1，3}，{1，4}，{2，3}，{2，4}，{2，5}的支持度    满足要求，因此求得2-频繁项目集：

        {1，2}，{1，3}，{1，4}，{2，3}，{2，4}

生成3-频繁项目集：

对于现有的2-频繁项目集，两两取并集，并确保第三个二元组也在2-频繁项目集内，把得到的所有3-项目集分别计算支持度，剔除不满足最小支持度的项目集；

例如，

{1，2}，{1，3}的并集得到{1，2，3}；

{1，2}，{1，4}的并集得到{1，2，4}；

{1，3}，{1，4}的并集得到{1，3，4}；

{2，3}，{2，4}的并集得到{2，3，4}；

但是由于{1，3，4}的子集{3，4}不在2-频繁项目集中，所以需要把{1，3，4}剔除掉。{2，3，4} 同理剔除。

然后再来计算{1，2，3}和{1，2，4}的支持度，发现{1，2，3}的支持度为3/7 ，{1，2，4}的支持度为2/7，所以需要把{1，2，4}剔除。因此得到3-频繁项目集：{1，2，3}。

重复上面步骤继续寻找n-频繁项目集，直到不能发现更大的频繁项目集。所以，到此，频繁项目集生成过程结束。

这里只说明3-频繁项目集生成关联规则的过程，即以集合{1，2，3}为例：

回顾事物集，先生成1-后件的关联规则：

（1，2）—>3，置信度=3/4（出现（1，2）的记录共4条，其中有3条包含3，所以3/4）；

（1，3）—>2，置信度=3/5；

（2，3）—>1，置信度=3/3；

第二条置信度<5/7，未达到最小置信度，所以剔除掉。所以对于3-频繁项目集生成的强关联规则为：（1，2）—>3和（2，3）—>1。

这表示，如果1、2出现了，则极有可能出现3；2、3出现，则极有可能有1。

http://www.cnblogs.com/junyuhuang/p/5572364.html

⑽ apriori算法是什么

经典的关联规则挖掘算法包括Apriori算法和FP-growth算法。

apriori算法多次扫描交易数据库，每次利用候选频繁集产生频繁集；而FP-growth则利用树形结构，无需产生候选频繁集而是直接得到频繁集，大大减少扫描交易数据库的次数，从而提高了算法的效率，但是apriori的算法扩展性较好，可以用于并行计算等领域。

基本算法：

Apriori algorithm是关联规则里一项基本算法

Apriori算法将发现关联规则的过程分：

第一通过迭代，检索出事务数据库1中的所有频繁项集，即支持度不低于用户设定的阈值的项集；

第二利用频繁项集构造出满足用户最小信任度的规则。其中，挖掘或识别出所有频繁项集是该算法的核心，占整个计算量的大部分。