apriori算法r语言

㈠ r 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=所有的频繁集；

Procere 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;

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

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

㈢ 用R语言进行关联分析

用R语言进行关联分析
关联是两个或多个变量取值之间存在的一类重要的可被发现的某种规律性。关联分析目的是寻找给定数据记录集中数据项之间隐藏的关联关系，描述数据之间的密切度。
几个基本概念
1. 项集
这是一个集合的概念，在一篮子商品中的一件消费品即为一项（Item），则若干项的集合为项集，如{啤酒，尿布}构成一个二元项集。
2. 关联规则
一般记为的形式，X为先决条件，Y为相应的关联结果，用于表示数据内隐含的关联性。如：，表示购买了尿布的消费者往往也会购买啤酒。
关联性强度如何，由三个概念——支持度、置信度、提升度来控制和评价。
例：有10000个消费者购买了商品，其中购买尿布1000个，购买啤酒2000个，购买面包500个，同时购买尿布和面包800个，同时购买尿布和面包100个。
3. 支持度（Support）
支持度是指在所有项集中{X, Y}出现的可能性，即项集中同时含有X和Y的概率：
该指标作为建立强关联规则的第一个门槛，衡量了所考察关联规则在“量”上的多少。通过设定最小阈值（minsup），剔除“出镜率”较低的无意义规则，保留出现较为频繁的项集所隐含的规则。
设定最小阈值为5%，由于{尿布，啤酒}的支持度为800/10000=8%，满足基本输了要求，成为频繁项集，保留规则；而{尿布，面包}的支持度为100/10000=1%，被剔除。
4. 置信度（Confidence）
置信度表示在先决条件X发生的条件下，关联结果Y发生的概率：
这是生成强关联规则的第二个门槛，衡量了所考察的关联规则在“质”上的可靠性。相似的，我们需要对置信度设定最小阈值（mincon）来实现进一步筛选。
具体的，当设定置信度的最小阈值为70%时，置信度为800/1000=80%，而的置信度为800/2000=40%，被剔除。
5. 提升度（lift）
提升度表示在含有X的条件下同时含有Y的可能性与没有X这个条件下项集中含有Y的可能性之比：
该指标与置信度同样衡量规则的可靠性，可以看作是置信度的一种互补指标。
R中Apriori算法
算法步骤：
1. 选出满足支持度最小阈值的所有项集，即频繁项集；
2. 从频繁项集中找出满足最小置信度的所有规则。
> library(arules) #加载arules包
> click_detail =read.transactions("click_detail.txt",format="basket",sep=",",cols=c(1)) #读取txt文档（文档编码为ANSI）
> rules <- apriori(click_detail, parameter =list(supp=0.01,conf=0.5,target="rules")) #调用apriori算法
> rules
set of419 rules
> inspect(rules[1:10]) #查看前十条规则
解释
1) library(arules)：加载程序包arules，当然如果你前面没有下载过这个包，就要先install.packages(arules)
2) click_detail =read.transactions("click_detail.txt",format="basket",sep=",",cols=c(1))：读入数据
read.transactions(file, format =c("basket", "single"), sep = NULL,
cols = NULL, rm.plicates =FALSE, encoding = "unknown")
file:文件名，对应click_detail中的“click_detail.txt”
format:文件格式，可以有两种，分别为“basket”,“single”，click_detail.txt中用的是basket。
basket: basket就是篮子，一个顾客买的东西都放到同一个篮子，所有顾客的transactions就是一个个篮子的组合结果。如下形式，每条交易都是独立的。
文件形式：
item1,item2
item1
item2,item3
读入后：
items
1 {item1,
item2}
2 {item1}
3 {item2,
item3}
single: single的意思，顾名思义，就是单独的交易，简单说，交易记录为：顾客1买了产品1， 顾客1买了产品2，顾客2买了产品3……(产品1，产品2，产品3中可以是单个产品，也可以是多个产品)，如下形式：
trans1 item1
trans2 item1
trans2 item2
读入后：
items transactionID
1 {item1} trans1
2 {item1,
item2} trans2
sep:文件中数据是怎么被分隔的，默认为空格，click_detail里面用逗号分隔
cols:对basket, col=1,表示第一列是数据的transaction ids(交易号)，如果col=NULL，则表示数据里面没有交易号这一列；对single，col=c(1,2)表示第一列是transaction ids，第二列是item ids
rm.plicates:是否移除重复项，默认为FALSE
encoding:写到这里研究了encoding是什么意思，发现前面txt可以不是”ANSI”类型，如果TXT是“UTF-8”，写encoding=”UTF-8”，就OK了.
3) rules <- apriori(click_detail,parameter = list(supp=0.01,conf=0.5,target="rules"))：apriori函数
apriori(data, parameter = NULL, appearance = NULL, control = NULL)
data:数据
parameter：设置参数，默认情况下parameter=list(supp=0.1,conf=0.8,maxlen=10,minlen=1,target=”rules”)
supp:支持度（support）
conf:置信度（confidence）
maxlen,minlen:每个项集所含项数的最大最小值
target:“rules”或“frequent itemsets”（输出关联规则/频繁项集）
apperence:对先决条件X（lhs），关联结果Y（rhs）中具体包含哪些项进行限制，如：设置lhs=beer，将仅输出lhs含有beer这一项的关联规则。默认情况下，所有项都将无限制出现。
control：控制函数性能，如可以设定对项集进行升序sort=1或降序sort=-1排序，是否向使用者报告进程（verbose=F/T）
补充
通过支持度控制：rules.sorted_sup = sort(rules, by=”support”)
通过置信度控制：rules.sorted_con = sort(rules, by=”confidence”)
通过提升度控制：rules.sorted_lift = sort(rules, by=”lift”)
Apriori算法
两步法：
1. 频繁项集的产生：找出所有满足最小支持度阈值的项集，称为频繁项集；
2. 规则的产生：对于每一个频繁项集l，找出其中所有的非空子集；然后，对于每一个这样的子集a，如果support(l)与support(a)的比值大于最小可信度，则存在规则a==>(l-a)。
频繁项集产生所需要的计算开销远大于规则产生所需的计算开销
频繁项集的产生
几个概念：
1， 一个包含K个项的数据集，可能产生2^k个候选集

2，先验原理：如果一个项集是频繁的，则它的所有子集也是频繁的（理解了频繁项集的意义，这句话很容易理解的）；相反，如果一个项集是非频繁的，则它所有子集也一定是非频繁的。

3基于支持度（SUPPORT）度量的一个关键性质：一个项集的支持度不会超过它的子集的支持度（很好理解，支持度是共同发生的概率，假设项集{A,B,C}，{A,B}是它的一个自己，A,B,C同时发生的概率肯定不会超过A,B同时发生的概率）。
上面这条规则就是Apriori中使用到的，如下图，当寻找频繁项集时，从上往下扫描，当遇到一个项集是非频繁项集（该项集支持度小于Minsup），那么它下面的项集肯定就是非频繁项集，这一部分就剪枝掉了。
一个例子（网络到的一个PPT上的）：
当我在理解频繁项集的意义时，在R上简单的复现了这个例子，这里采用了eclat算法，跟apriori应该差不多：
代码：
item <- list(
c("bread","milk"),
c("bread","diaper","beer","eggs"),
c("milk","diaper","beer","coke"),
c("bread","milk","diaper","beer"),
c("bread","milk","diaper","coke")
)
names(item) <- paste("tr",c(1:5),sep = "")
item
trans <- as(item,"transactions") #将List转为transactions型
rules = eclat(trans,parameter = list(supp = 0.6,
target ="frequent itemsets"),control = list(sort=1))
inspect(rules) #查看频繁项集
运行后结果：
>inspect(rules)
items support
1{beer,
diaper} 0.6
2{diaper,
milk} 0.6
3{bread,
diaper} 0.6
4{bread,
milk} 0.6
5{beer} 0.6
6{milk} 0.8
7{bread} 0.8
8{diaper} 0.8
以上就是该例子的所有频繁项集，然后我发现少了{bread,milk,diaper}这个项集，回到例子一看，这个项集实际上只出现了两次，所以是没有这个项集的。
规则的产生
每个频繁k项集能产生最多2k-2个关联规则
将项集Y划分成两个非空的子集X和Y-X，使得X ->Y-X满足置信度阈值
定理：如果规则X->Y-X不满足置信度阈值，则X’->Y-X’的规则一定也不满足置信度阈值，其中X’是X的子集
Apriori按下图进行逐层计算，当发现一个不满足置信度的项集后，该项集所有子集的规则都可以剪枝掉了。

㈣ R语言 apriori中规则如何忽略先后顺序

a→b，b→a 本来就是两个不一样的规则。
对照置信度的定义 他们的值都不一样，
它们只是支持度一样，
如果你只要一个， 那就只挖频繁项集就可以，不必生成规则。

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

㈥ 多维关联规则挖掘算法r语言能实现吗

一下自己学习关联规则经典算法Apriori的笔记。
1、概述
Apriori算法是用一种称为逐层搜索的迭代方法，从项集长度k=1开始，选出频繁的k=1项集，根据先验性质：频繁项集的子集一定是频繁的（逆否命题：非频繁项集的超集一定是非频繁的，通俗的说就是某件事发生的概率很低，比这件事发生条件更严苛的事情发生的概率会更低），筛选k=2项集中的频繁项集，以此迭代k=3...。每迭代一次都要完整的扫描一次数据库。
2、关联规则三度：
支持度：占比
置信度：条件概率
提升度：相关性
3、R语言示例代码如下：（小众语言的辛酸：选项里没有。。）
[plain] view plain
library(arules)
#从rattle包中读入数据
dvdtrans <- read.csv(system.file("csv", "dvdtrans.csv",package="rattle"))
str(dvdtrans)
#将数据转化为合适的格式
data <- as(split(dvdtrans$Item,dvdtrans$ID),"transactions")
data

#用 apriori命令生成频繁项集，设其支持度为0.5，置信度为0.8
rules <- apriori(data, parameter=list(support=0.5,confidence=0.8,minlen = 2))

#用inspect命令查看提取规则
inspect(rules)
常用数据形式有data.frame格式和list格式，前者即A项集为一列B项集为另一列，后者为A和B放在同一个购物篮中。

去除冗余规则以及提取子规则代码如下：

[plain] view plain
rendant.rm <- function(rule,by="lift")
{
#rule：需要进行简化的规则
#by：在清除的时候根据那个变量来选择，
#可能取值为"support","lift","confidence"
a <- sort(rule,by=by)
m<- is.subset(a,a,proper=TRUE)
m[lower.tri(m, diag=TRUE)] <- NA
r <- colSums(m, na.rm=TRUE) >= 1
finall.rules <- a[!r]
return(finall.rules)
}
rules <- rendant.rm(rules)
rules.sub <- subset(rules, subset = lhs %in% "筛选项集名称" & lift > 1)

㈦ 利用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算法和FP-growth算法。

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

基本算法：

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

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

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

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

㈨ 机器学习有哪些算法

1. 线性回归
在统计学和机器学习领域，线性回归可能是最广为人知也最易理解的算法之一。
2. Logistic 回归
Logistic 回归是机器学习从统计学领域借鉴过来的另一种技术。它是二分类问题的首选方法。
3. 线性判别分析
Logistic 回归是一种传统的分类算法，它的使用场景仅限于二分类问题。如果你有两个以上的类，那么线性判别分析算法（LDA）是首选的线性分类技术。
4.分类和回归树
决策树是一类重要的机器学习预测建模算法。
5. 朴素贝叶斯
朴素贝叶斯是一种简单而强大的预测建模算法。
6. K 最近邻算法
K 最近邻（KNN）算法是非常简单而有效的。KNN 的模型表示就是整个训练数据集。
7. 学习向量量化
KNN 算法的一个缺点是，你需要处理整个训练数据集。
8. 支持向量机
支持向量机（SVM）可能是目前最流行、被讨论地最多的机器学习算法之一。
9. 袋装法和随机森林
随机森林是最流行也最强大的机器学习算法之一，它是一种集成机器学习算法。

想要学习了解更多机器学习的知识，推荐CDA数据分析师课程。CDA（Certified Data Analyst），即“CDA 数据分析师”，是在数字经济大背景和人工智能时代趋势下，面向全行业的专业权威国际资格认证，旨在提升全民数字技能，助力企业数字化转型，推动行业数字化发展。点击预约免费试听课。